From 863d01562807e75be02070552f2ff22732913b01 Mon Sep 17 00:00:00 2001 From: DanS Date: Thu, 4 Jun 2026 21:15:28 -0500 Subject: [PATCH] feat(lite): lite wallet foundation (inherited working-tree state) Preserve the previously-uncommitted lite wallet implementation and related dev WIP under version control: - src/wallet/ lite services: client bridge, bridge runtime, connection, lifecycle, sync, gateway, result parsers, state mapper, artifact contract/resolver, refresh services, UI adapters, wallet_backend/capabilities. (Includes two small M1 fixes: lifecycle walletReady now parses the response; default chain name -> "main".) - src/chat/ chat protocol; tests/fixtures/ (lite + hushchat); tools/hushchat_fixture_check.cpp; scripts/build-lite-backend-artifact.sh. - Pre-existing modified app_network/security/wizard, network_refresh_service, sidebar, mining_tab, bootstrap dialog, and version headers captured as-is. Co-Authored-By: Claude Opus 4.8 (1M context) --- scripts/build-lite-backend-artifact.sh | 769 + src/app_network.cpp | 45 +- src/app_security.cpp | 5 +- src/app_wizard.cpp | 11 + src/chat/chat_protocol.cpp | 1855 ++ src/chat/chat_protocol.h | 586 + src/config/version.h | 30 +- src/config/version.h.in | 2 +- src/services/network_refresh_service.cpp | 96 +- src/services/network_refresh_service.h | 6 +- src/ui/sidebar.h | 25 +- src/ui/windows/bootstrap_download_dialog.h | 2 + src/ui/windows/mining_tab.cpp | 30 +- src/wallet/lite_backend_artifact_contract.cpp | 419 + src/wallet/lite_backend_artifact_contract.h | 195 + src/wallet/lite_backend_artifact_resolver.cpp | 925 + src/wallet/lite_backend_artifact_resolver.h | 414 + src/wallet/lite_bridge_runtime.cpp | 17669 ++++++++++++++++ src/wallet/lite_bridge_runtime.h | 7268 +++++++ src/wallet/lite_client_bridge.cpp | 186 + src/wallet/lite_client_bridge.h | 84 + src/wallet/lite_connection_service.cpp | 309 + src/wallet/lite_connection_service.h | 123 + src/wallet/lite_result_parsers.cpp | 570 + src/wallet/lite_result_parsers.h | 169 + src/wallet/lite_sync_service.cpp | 371 + src/wallet/lite_sync_service.h | 162 + .../lite_wallet_app_refresh_coordinator.cpp | 172 + .../lite_wallet_app_refresh_coordinator.h | 96 + .../lite_wallet_app_refresh_orchestrator.cpp | 197 + .../lite_wallet_app_refresh_orchestrator.h | 109 + src/wallet/lite_wallet_gateway.cpp | 409 + src/wallet/lite_wallet_gateway.h | 163 + src/wallet/lite_wallet_lifecycle_service.cpp | 397 + src/wallet/lite_wallet_lifecycle_service.h | 152 + .../lite_wallet_lifecycle_ui_adapter.cpp | 440 + src/wallet/lite_wallet_lifecycle_ui_adapter.h | 146 + .../lite_wallet_refresh_readiness_policy.cpp | 205 + .../lite_wallet_refresh_readiness_policy.h | 106 + src/wallet/lite_wallet_refresh_service.cpp | 189 + src/wallet/lite_wallet_refresh_service.h | 92 + ...lite_wallet_server_lifecycle_readiness.cpp | 407 + .../lite_wallet_server_lifecycle_readiness.h | 197 + .../lite_wallet_server_selection_adapter.cpp | 463 + .../lite_wallet_server_selection_adapter.h | 161 + .../lite_wallet_state_apply_executor.cpp | 118 + src/wallet/lite_wallet_state_apply_executor.h | 71 + src/wallet/lite_wallet_state_apply_plan.cpp | 405 + src/wallet/lite_wallet_state_apply_plan.h | 98 + src/wallet/lite_wallet_state_mapper.cpp | 217 + src/wallet/lite_wallet_state_mapper.h | 139 + ...te_wallet_sync_app_refresh_integration.cpp | 344 + ...lite_wallet_sync_app_refresh_integration.h | 172 + .../lite_wallet_sync_execution_readiness.cpp | 461 + .../lite_wallet_sync_execution_readiness.h | 238 + src/wallet/wallet_backend.h | 93 + src/wallet/wallet_capabilities.h | 179 + tests/fixtures/hushchat/CAPTURE_MANIFEST.md | 27 + tests/fixtures/hushchat/IMPORT_CHECKLIST.md | 40 + tests/fixtures/hushchat/README.md | 31 + .../hushchat/cont-exclusion.pending.json | 7 + .../corrupted-auth-failure.pending.json | 7 + .../hushchat/incoming-memo.pending.json | 7 + .../hushchat/outgoing-memo.pending.json | 7 + .../seed-public-key-projection.pending.json | 7 + .../templates/capture-manifest.template.json | 54 + .../lite/release_package_manifest.json | 60 + tests/fixtures/lite/result_parsers.json | 107 + tools/hushchat_fixture_check.cpp | 227 + 69 files changed, 39458 insertions(+), 85 deletions(-) create mode 100755 scripts/build-lite-backend-artifact.sh create mode 100644 src/chat/chat_protocol.cpp create mode 100644 src/chat/chat_protocol.h create mode 100644 src/wallet/lite_backend_artifact_contract.cpp create mode 100644 src/wallet/lite_backend_artifact_contract.h create mode 100644 src/wallet/lite_backend_artifact_resolver.cpp create mode 100644 src/wallet/lite_backend_artifact_resolver.h create mode 100644 src/wallet/lite_bridge_runtime.cpp create mode 100644 src/wallet/lite_bridge_runtime.h create mode 100644 src/wallet/lite_client_bridge.cpp create mode 100644 src/wallet/lite_client_bridge.h create mode 100644 src/wallet/lite_connection_service.cpp create mode 100644 src/wallet/lite_connection_service.h create mode 100644 src/wallet/lite_result_parsers.cpp create mode 100644 src/wallet/lite_result_parsers.h create mode 100644 src/wallet/lite_sync_service.cpp create mode 100644 src/wallet/lite_sync_service.h create mode 100644 src/wallet/lite_wallet_app_refresh_coordinator.cpp create mode 100644 src/wallet/lite_wallet_app_refresh_coordinator.h create mode 100644 src/wallet/lite_wallet_app_refresh_orchestrator.cpp create mode 100644 src/wallet/lite_wallet_app_refresh_orchestrator.h create mode 100644 src/wallet/lite_wallet_gateway.cpp create mode 100644 src/wallet/lite_wallet_gateway.h create mode 100644 src/wallet/lite_wallet_lifecycle_service.cpp create mode 100644 src/wallet/lite_wallet_lifecycle_service.h create mode 100644 src/wallet/lite_wallet_lifecycle_ui_adapter.cpp create mode 100644 src/wallet/lite_wallet_lifecycle_ui_adapter.h create mode 100644 src/wallet/lite_wallet_refresh_readiness_policy.cpp create mode 100644 src/wallet/lite_wallet_refresh_readiness_policy.h create mode 100644 src/wallet/lite_wallet_refresh_service.cpp create mode 100644 src/wallet/lite_wallet_refresh_service.h create mode 100644 src/wallet/lite_wallet_server_lifecycle_readiness.cpp create mode 100644 src/wallet/lite_wallet_server_lifecycle_readiness.h create mode 100644 src/wallet/lite_wallet_server_selection_adapter.cpp create mode 100644 src/wallet/lite_wallet_server_selection_adapter.h create mode 100644 src/wallet/lite_wallet_state_apply_executor.cpp create mode 100644 src/wallet/lite_wallet_state_apply_executor.h create mode 100644 src/wallet/lite_wallet_state_apply_plan.cpp create mode 100644 src/wallet/lite_wallet_state_apply_plan.h create mode 100644 src/wallet/lite_wallet_state_mapper.cpp create mode 100644 src/wallet/lite_wallet_state_mapper.h create mode 100644 src/wallet/lite_wallet_sync_app_refresh_integration.cpp create mode 100644 src/wallet/lite_wallet_sync_app_refresh_integration.h create mode 100644 src/wallet/lite_wallet_sync_execution_readiness.cpp create mode 100644 src/wallet/lite_wallet_sync_execution_readiness.h create mode 100644 src/wallet/wallet_backend.h create mode 100644 src/wallet/wallet_capabilities.h create mode 100644 tests/fixtures/hushchat/CAPTURE_MANIFEST.md create mode 100644 tests/fixtures/hushchat/IMPORT_CHECKLIST.md create mode 100644 tests/fixtures/hushchat/README.md create mode 100644 tests/fixtures/hushchat/cont-exclusion.pending.json create mode 100644 tests/fixtures/hushchat/corrupted-auth-failure.pending.json create mode 100644 tests/fixtures/hushchat/incoming-memo.pending.json create mode 100644 tests/fixtures/hushchat/outgoing-memo.pending.json create mode 100644 tests/fixtures/hushchat/seed-public-key-projection.pending.json create mode 100644 tests/fixtures/hushchat/templates/capture-manifest.template.json create mode 100644 tests/fixtures/lite/release_package_manifest.json create mode 100644 tests/fixtures/lite/result_parsers.json create mode 100644 tools/hushchat_fixture_check.cpp diff --git a/scripts/build-lite-backend-artifact.sh b/scripts/build-lite-backend-artifact.sh new file mode 100755 index 0000000..324f20b --- /dev/null +++ b/scripts/build-lite-backend-artifact.sh @@ -0,0 +1,769 @@ +#!/usr/bin/env bash + +set -euo pipefail + +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +PROJECT_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)" + +ABI_VERSION="sdxl-c-v1" +LINK_MODE="imported" +BACKEND_DIR="$PROJECT_ROOT/external/SilentDragonXLite/lib" +BACKEND_SOURCE_DIR="" +BUILD_BACKEND_DIR="" +BACKEND_DEPENDENCY_DIR="" +BACKEND_DEPENDENCY_OVERRIDE_REQUESTED=false +OUT_DIR="$PROJECT_ROOT/build/lite-backend" +PLATFORM="" +RUST_TARGET="" +CARGO_TARGET_DIR_VALUE="${CARGO_TARGET_DIR:-}" +ARTIFACT_PATH="" +BUILD_ARTIFACT=true +BUILDER="${DRAGONX_LITE_BACKEND_BUILDER:-local}" +JOBS="${JOBS:-}" +SOURCE_DATE_EPOCH_VALUE="${SOURCE_DATE_EPOCH:-}" +REPRODUCIBLE=false +SIGNATURE_REQUIRED=false +SIGNATURE_FILE="" +SIGNATURE_FORMAT="" +SIGNATURE_VERIFICATION_TOOL="" +SIGNATURE_VERIFICATION_COMMAND="" +SIGNATURE_KEY_FINGERPRINT="" +SIGNATURE_CERTIFICATE_IDENTITY="" +SIGNATURE_CERTIFICATE_ISSUER="" +SIGNATURE_TRANSPARENCY_LOG_URL="" +SIGNATURE_VERIFIED_SHA256="" +SIGNATURE_POLICY_NAME="dragonx-lite-backend-signature-policy-v1" +SIGNATURE_POLICY_DEFINED_MANIFEST_VALUE=true +SIGNATURE_REQUIRED_MANIFEST_VALUE=false +SIGNATURE_METADATA_PROVIDED=false +SIGNATURE_VERIFICATION_PERFORMED=false +SIGNATURE_VERIFICATION_STATUS="not-provided" +SIGNATURE_FILE_SHA256="" + +REQUIRED_SYMBOLS=( + litelib_wallet_exists + litelib_initialize_new + litelib_initialize_new_from_phrase + litelib_initialize_existing + litelib_execute + litelib_rust_free_string + litelib_check_server_online + litelib_shutdown +) + +EXTRA_CARGO_ARGS=() +EXTRA_REMAP_PATH_PREFIXES=() + +usage() { + cat <// + //lite-backend-symbols.txt + //lite-backend-artifact-manifest.json + +The script captures symbols, checksums, and optional read-only signature +verification metadata only. It does not load the library, resolve function +pointers, call SDXL, sign, upload, or publish artifacts. +EOF +} + +info() { printf '[lite-backend] %s\n' "$*"; } +warn() { printf '[lite-backend] warning: %s\n' "$*" >&2; } +die() { printf '[lite-backend] ERROR: %s\n' "$*" >&2; exit 1; } + +absolute_path() { + local path="$1" + if [[ "$path" = /* ]]; then + printf '%s\n' "$path" + else + printf '%s/%s\n' "$PWD" "$path" + fi +} + +host_platform() { + case "$(uname -s)" in + Linux) printf 'linux\n' ;; + Darwin) printf 'macos\n' ;; + MINGW*|MSYS*|CYGWIN*) printf 'windows\n' ;; + *) die "unsupported host platform: $(uname -s)" ;; + esac +} + +normalize_platform() { + case "$1" in + linux|Linux) printf 'linux\n' ;; + windows|win|Win|Windows) printf 'windows\n' ;; + macos|mac|darwin|Darwin) printf 'macos\n' ;; + "") host_platform ;; + *) die "unsupported platform: $1" ;; + esac +} + +while [[ $# -gt 0 ]]; do + case "$1" in + --platform) + [[ $# -ge 2 ]] || die "--platform requires a value" + PLATFORM="$(normalize_platform "$2")" + shift 2 + ;; + --rust-target) + [[ $# -ge 2 ]] || die "--rust-target requires a value" + RUST_TARGET="$2" + shift 2 + ;; + --cargo-target-dir) + [[ $# -ge 2 ]] || die "--cargo-target-dir requires a value" + CARGO_TARGET_DIR_VALUE="$(absolute_path "$2")" + shift 2 + ;; + --backend-dir) + [[ $# -ge 2 ]] || die "--backend-dir requires a value" + BACKEND_DIR="$(absolute_path "$2")" + shift 2 + ;; + --silentdragonxlitelib-dir) + [[ $# -ge 2 ]] || die "--silentdragonxlitelib-dir requires a value" + BACKEND_DEPENDENCY_DIR="$(absolute_path "$2")" + BACKEND_DEPENDENCY_OVERRIDE_REQUESTED=true + shift 2 + ;; + --out-dir) + [[ $# -ge 2 ]] || die "--out-dir requires a value" + OUT_DIR="$(absolute_path "$2")" + shift 2 + ;; + --artifact) + [[ $# -ge 2 ]] || die "--artifact requires a value" + ARTIFACT_PATH="$(absolute_path "$2")" + BUILD_ARTIFACT=false + shift 2 + ;; + --no-build) + BUILD_ARTIFACT=false + shift + ;; + --reproducible) + REPRODUCIBLE=true + shift + ;; + --remap-path-prefix) + [[ $# -ge 2 ]] || die "--remap-path-prefix requires FROM=TO" + [[ "$2" == *=* ]] || die "--remap-path-prefix requires FROM=TO" + EXTRA_REMAP_PATH_PREFIXES+=("$2") + shift 2 + ;; + --builder) + [[ $# -ge 2 ]] || die "--builder requires a value" + BUILDER="$2" + shift 2 + ;; + --signature-required) + SIGNATURE_REQUIRED=true + shift + ;; + --signature-file|--signature-path) + [[ $# -ge 2 ]] || die "$1 requires a value" + SIGNATURE_FILE="$(absolute_path "$2")" + shift 2 + ;; + --signature-format) + [[ $# -ge 2 ]] || die "--signature-format requires a value" + SIGNATURE_FORMAT="$2" + shift 2 + ;; + --signature-verification-tool|--signature-tool) + [[ $# -ge 2 ]] || die "$1 requires a value" + SIGNATURE_VERIFICATION_TOOL="$2" + shift 2 + ;; + --signature-verification-command) + [[ $# -ge 2 ]] || die "--signature-verification-command requires a value" + SIGNATURE_VERIFICATION_COMMAND="$2" + shift 2 + ;; + --signature-key-fingerprint) + [[ $# -ge 2 ]] || die "--signature-key-fingerprint requires a value" + SIGNATURE_KEY_FINGERPRINT="$2" + shift 2 + ;; + --signature-certificate-identity) + [[ $# -ge 2 ]] || die "--signature-certificate-identity requires a value" + SIGNATURE_CERTIFICATE_IDENTITY="$2" + shift 2 + ;; + --signature-certificate-issuer) + [[ $# -ge 2 ]] || die "--signature-certificate-issuer requires a value" + SIGNATURE_CERTIFICATE_ISSUER="$2" + shift 2 + ;; + --signature-transparency-log-url) + [[ $# -ge 2 ]] || die "--signature-transparency-log-url requires a value" + SIGNATURE_TRANSPARENCY_LOG_URL="$2" + shift 2 + ;; + --signature-verified-sha256) + [[ $# -ge 2 ]] || die "--signature-verified-sha256 requires a value" + SIGNATURE_VERIFIED_SHA256="$2" + shift 2 + ;; + -j|--jobs) + [[ $# -ge 2 ]] || die "--jobs requires a value" + JOBS="$2" + shift 2 + ;; + --cargo-arg) + [[ $# -ge 2 ]] || die "--cargo-arg requires a value" + EXTRA_CARGO_ARGS+=("$2") + shift 2 + ;; + -h|--help) + usage + exit 0 + ;; + *) die "unknown option: $1" ;; + esac +done + +PLATFORM="$(normalize_platform "$PLATFORM")" +BACKEND_SOURCE_DIR="$BACKEND_DIR" +BUILD_BACKEND_DIR="$BACKEND_SOURCE_DIR" + +if [[ "$PLATFORM" == "windows" && -z "$RUST_TARGET" ]]; then + RUST_TARGET="x86_64-pc-windows-gnu" +fi +if [[ "$PLATFORM" == "macos" && -z "$RUST_TARGET" && "$(host_platform)" != "macos" ]]; then + die "macOS artifacts require --rust-target when not running on macOS" +fi +if [[ "$BUILD_ARTIFACT" == false && -z "$ARTIFACT_PATH" ]]; then + die "--no-build requires --artifact" +fi + +backend_dependency_path_from_cargo() { + local cargo_toml="$1" + awk ' + /^[[:space:]]*silentdragonxlitelib[[:space:]]*=/ { + original = $0 + path = $0 + sub(/.*path[[:space:]]*=[[:space:]]*"/, "", path) + sub(/".*/, "", path) + if (path != original) print path + exit + } + ' "$cargo_toml" +} + +canonical_dependency_path() { + local path="$1" + if [[ -d "$path" ]]; then + (cd "$path" && pwd -P) + else + absolute_path "$path" + fi +} + +validate_backend_dependency_source() { + [[ -n "$BACKEND_DEPENDENCY_DIR" ]] || return + + if [[ ! -f "$BACKEND_DEPENDENCY_DIR/Cargo.toml" ]]; then + if [[ "$BUILD_ARTIFACT" == true || "$BACKEND_DEPENDENCY_OVERRIDE_REQUESTED" == true ]]; then + die "Cargo.toml not found in $BACKEND_DEPENDENCY_DIR" + fi + warn "Cargo.toml not found in silentdragonxlitelib source: $BACKEND_DEPENDENCY_DIR" + return + fi + + if ! grep -Eq '^[[:space:]]*name[[:space:]]*=[[:space:]]*"silentdragonxlitelib"' "$BACKEND_DEPENDENCY_DIR/Cargo.toml"; then + if [[ "$BUILD_ARTIFACT" == true || "$BACKEND_DEPENDENCY_OVERRIDE_REQUESTED" == true ]]; then + die "dependency path does not look like silentdragonxlitelib: $BACKEND_DEPENDENCY_DIR" + fi + warn "dependency path does not look like silentdragonxlitelib: $BACKEND_DEPENDENCY_DIR" + fi +} + +prepare_backend_source() { + BUILD_BACKEND_DIR="$BACKEND_SOURCE_DIR" + + if [[ "$BACKEND_DEPENDENCY_OVERRIDE_REQUESTED" == false ]]; then + if [[ -f "$BACKEND_SOURCE_DIR/Cargo.toml" ]]; then + local configured_dependency_path + configured_dependency_path="$(backend_dependency_path_from_cargo "$BACKEND_SOURCE_DIR/Cargo.toml")" + if [[ -n "$configured_dependency_path" ]]; then + if [[ "$configured_dependency_path" = /* ]]; then + BACKEND_DEPENDENCY_DIR="$(canonical_dependency_path "$configured_dependency_path")" + warn "backend Cargo.toml uses an absolute silentdragonxlitelib path; use --silentdragonxlitelib-dir for portable builders" + else + BACKEND_DEPENDENCY_DIR="$(canonical_dependency_path "$BACKEND_SOURCE_DIR/$configured_dependency_path")" + info "using relative silentdragonxlitelib dependency at $BACKEND_DEPENDENCY_DIR" + fi + validate_backend_dependency_source + fi + fi + return + fi + + [[ -f "$BACKEND_SOURCE_DIR/Cargo.toml" ]] || die "Cargo.toml not found in $BACKEND_SOURCE_DIR" + validate_backend_dependency_source + [[ "$BACKEND_DEPENDENCY_DIR" != *\"* ]] || die "--silentdragonxlitelib-dir path cannot contain a double quote" + + local prepared_root="$OUT_DIR/.prepared-backend/$PLATFORM" + [[ "$prepared_root" == */.prepared-backend/* ]] || die "refusing unsafe prepared backend path: $prepared_root" + rm -rf "$prepared_root" + mkdir -p "$prepared_root" + + ln -s "$BACKEND_SOURCE_DIR/src" "$prepared_root/src" + [[ -f "$BACKEND_SOURCE_DIR/Cargo.lock" ]] && ln -s "$BACKEND_SOURCE_DIR/Cargo.lock" "$prepared_root/Cargo.lock" + [[ -d "$BACKEND_SOURCE_DIR/.cargo" ]] && ln -s "$BACKEND_SOURCE_DIR/.cargo" "$prepared_root/.cargo" + [[ -d "$BACKEND_SOURCE_DIR/libsodium-mingw" ]] && ln -s "$BACKEND_SOURCE_DIR/libsodium-mingw" "$prepared_root/libsodium-mingw" + [[ -f "$BACKEND_SOURCE_DIR/silentdragonxlitelib.h" ]] && ln -s "$BACKEND_SOURCE_DIR/silentdragonxlitelib.h" "$prepared_root/silentdragonxlitelib.h" + + local replacement="silentdragonxlitelib = { path = \"$BACKEND_DEPENDENCY_DIR\" }" + awk -v replacement="$replacement" ' + BEGIN { replaced = 0 } + /^[[:space:]]*silentdragonxlitelib[[:space:]]*=/ { + print replacement + replaced = 1 + next + } + { print } + END { if (replaced != 1) exit 42 } + ' "$BACKEND_SOURCE_DIR/Cargo.toml" > "$prepared_root/Cargo.toml" \ + || die "failed to prepare backend Cargo.toml with portable silentdragonxlitelib path" + + BUILD_BACKEND_DIR="$prepared_root" + info "prepared backend source at $BUILD_BACKEND_DIR with silentdragonxlitelib from $BACKEND_DEPENDENCY_DIR" +} + +prepare_backend_source + +artifact_kind() { + local name="${1##*/}" + case "$name" in + *.a|*.lib) printf 'static-library\n' ;; + *.so|*.dylib|*.dll) printf 'shared-library\n' ;; + *) printf 'unknown\n' ;; + esac +} + +cargo_output_candidates() { + local cargo_target_root="$BUILD_BACKEND_DIR/target" + if [[ -n "$CARGO_TARGET_DIR_VALUE" ]]; then + cargo_target_root="$CARGO_TARGET_DIR_VALUE" + fi + + local base="$cargo_target_root/release" + if [[ -n "$RUST_TARGET" ]]; then + base="$cargo_target_root/$RUST_TARGET/release" + fi + + case "$PLATFORM" in + linux) + printf '%s\n' "$base/libsilentdragonxlite.a" "$base/silentdragonxlite.a" "$base/libsilentdragonxlite.so" + ;; + windows) + printf '%s\n' "$base/silentdragonxlite.lib" "$base/libsilentdragonxlite.a" "$base/silentdragonxlite.dll" + ;; + macos) + printf '%s\n' "$base/libsilentdragonxlite.a" "$base/silentdragonxlite.a" "$base/libsilentdragonxlite.dylib" "$base/silentdragonxlite.dylib" + ;; + esac +} + +source_revision_for() { + local dir="$1" + local revision_file + for revision_file in "$dir/DRAGONX_SOURCE_REVISION" "$dir/../DRAGONX_SOURCE_REVISION"; do + if [[ -f "$revision_file" ]]; then + sed -n '1p' "$revision_file" + return + fi + done + + if git -C "$dir" rev-parse --is-inside-work-tree >/dev/null 2>&1; then + git -C "$dir" rev-parse HEAD 2>/dev/null || printf 'unknown' + else + printf 'unknown' + fi +} + +default_source_date_epoch() { + if git -C "$PROJECT_ROOT" rev-parse --is-inside-work-tree >/dev/null 2>&1; then + git -C "$PROJECT_ROOT" log -1 --format=%ct 2>/dev/null || printf '0' + else + printf '0' + fi +} + +append_rustflag() { + local rustflag="$1" + if [[ -n "${RUSTFLAGS:-}" ]]; then + export RUSTFLAGS="${RUSTFLAGS} ${rustflag}" + else + export RUSTFLAGS="$rustflag" + fi +} + +append_rust_path_remap() { + local from_path="$1" + local to_path="$2" + [[ -n "$from_path" && -n "$to_path" ]] || return + append_rustflag "--remap-path-prefix=${from_path}=${to_path}" +} + +apply_reproducible_rustflags() { + local cargo_target_root="$BUILD_BACKEND_DIR/target" + if [[ -n "$CARGO_TARGET_DIR_VALUE" ]]; then + cargo_target_root="$CARGO_TARGET_DIR_VALUE" + fi + + append_rust_path_remap "$PROJECT_ROOT" "/dragonx-project" + append_rust_path_remap "$BACKEND_SOURCE_DIR" "/dragonx-lite-backend" + if [[ "$BUILD_BACKEND_DIR" != "$BACKEND_SOURCE_DIR" ]]; then + append_rust_path_remap "$BUILD_BACKEND_DIR" "/dragonx-lite-backend" + fi + append_rust_path_remap "$BACKEND_DEPENDENCY_DIR" "/dragonx-lite-backend-dependency" + for path_remap in "${EXTRA_REMAP_PATH_PREFIXES[@]}"; do + append_rustflag "--remap-path-prefix=${path_remap}" + done + + local cargo_home="${CARGO_HOME:-}" + if [[ -z "$cargo_home" && -n "${HOME:-}" ]]; then + cargo_home="$HOME/.cargo" + fi + if [[ -n "$cargo_home" && -d "$cargo_home" ]]; then + append_rust_path_remap "$cargo_home" "/cargo-home" + fi + append_rust_path_remap "$cargo_target_root" "/dragonx-lite-cargo-target" +} + +build_with_cargo() { + command -v cargo >/dev/null 2>&1 || die "cargo was not found" + [[ -f "$BUILD_BACKEND_DIR/Cargo.toml" ]] || die "Cargo.toml not found in $BUILD_BACKEND_DIR" + + if [[ -z "$SOURCE_DATE_EPOCH_VALUE" ]]; then + SOURCE_DATE_EPOCH_VALUE="$(default_source_date_epoch)" + fi + + export CARGO_INCREMENTAL=0 + export SOURCE_DATE_EPOCH="$SOURCE_DATE_EPOCH_VALUE" + if [[ -n "$CARGO_TARGET_DIR_VALUE" ]]; then + export CARGO_TARGET_DIR="$CARGO_TARGET_DIR_VALUE" + fi + if [[ "$REPRODUCIBLE" == true ]]; then + apply_reproducible_rustflags + fi + if [[ "$PLATFORM" == "windows" && -d "$BUILD_BACKEND_DIR/libsodium-mingw" ]]; then + export SODIUM_LIB_DIR="$BUILD_BACKEND_DIR/libsodium-mingw" + fi + + local cargo_cmd=(cargo build --locked --lib --release) + if [[ -n "$RUST_TARGET" ]]; then + cargo_cmd+=(--target "$RUST_TARGET") + fi + if [[ -n "$JOBS" ]]; then + cargo_cmd+=(-j "$JOBS") + fi + cargo_cmd+=("${EXTRA_CARGO_ARGS[@]}") + + info "building backend in $BUILD_BACKEND_DIR" + (cd "$BUILD_BACKEND_DIR" && "${cargo_cmd[@]}") + + while IFS= read -r candidate; do + if [[ -f "$candidate" ]]; then + ARTIFACT_PATH="$candidate" + return + fi + done < <(cargo_output_candidates) + + die "cargo finished, but no expected backend artifact was found under $BUILD_BACKEND_DIR/target" +} + +select_nm_tool() { + if [[ "$PLATFORM" == "windows" ]] && command -v x86_64-w64-mingw32-nm >/dev/null 2>&1; then + printf 'x86_64-w64-mingw32-nm\n' + return + fi + if command -v llvm-nm >/dev/null 2>&1; then + printf 'llvm-nm\n' + return + fi + if command -v nm >/dev/null 2>&1; then + printf 'nm\n' + return + fi + die "no symbol inventory tool found; install nm, llvm-nm, or x86_64-w64-mingw32-nm" +} + +compute_sha256() { + local file="$1" + if command -v sha256sum >/dev/null 2>&1; then + sha256sum "$file" | awk '{print $1}' + elif command -v shasum >/dev/null 2>&1; then + shasum -a 256 "$file" | awk '{print $1}' + else + die "sha256sum or shasum is required" + fi +} + +json_escape() { + local value="$1" + value="${value//\\/\\\\}" + value="${value//\"/\\\"}" + value="${value//$'\n'/\\n}" + value="${value//$'\r'/}" + value="${value//$'\t'/\\t}" + printf '"%s"' "$value" +} + +json_array() { + local first=true + printf '[' + for value in "$@"; do + if [[ "$first" == true ]]; then + first=false + else + printf ',' + fi + json_escape "$value" + done + printf ']' +} + +json_array_from_file() { + local file="$1" + local values=() + if [[ -f "$file" ]]; then + mapfile -t values < "$file" + fi + json_array "${values[@]}" +} + +signature_metadata_requested() { + [[ "$SIGNATURE_REQUIRED" == true || \ + -n "$SIGNATURE_FILE" || \ + -n "$SIGNATURE_FORMAT" || \ + -n "$SIGNATURE_VERIFICATION_TOOL" || \ + -n "$SIGNATURE_VERIFICATION_COMMAND" || \ + -n "$SIGNATURE_KEY_FINGERPRINT" || \ + -n "$SIGNATURE_CERTIFICATE_IDENTITY" || \ + -n "$SIGNATURE_CERTIFICATE_ISSUER" || \ + -n "$SIGNATURE_TRANSPARENCY_LOG_URL" || \ + -n "$SIGNATURE_VERIFIED_SHA256" ]] +} + +validate_signature_metadata() { + SIGNATURE_REQUIRED_MANIFEST_VALUE=false + if [[ "$SIGNATURE_REQUIRED" == true ]]; then + SIGNATURE_REQUIRED_MANIFEST_VALUE=true + fi + + if ! signature_metadata_requested; then + return + fi + + [[ -n "$SIGNATURE_FILE" ]] || die "signature metadata requires --signature-file" + [[ -f "$SIGNATURE_FILE" ]] || die "signature file does not exist: $SIGNATURE_FILE" + [[ -n "$SIGNATURE_FORMAT" ]] || die "signature metadata requires --signature-format" + case "$SIGNATURE_FORMAT" in + minisign|gpg|sigstore|external|other) ;; + *) die "unsupported --signature-format: $SIGNATURE_FORMAT" ;; + esac + [[ -n "$SIGNATURE_VERIFICATION_TOOL" ]] || die "signature metadata requires --signature-verification-tool" + [[ -n "$SIGNATURE_VERIFIED_SHA256" ]] || die "signature metadata requires --signature-verified-sha256" + [[ "$SIGNATURE_VERIFIED_SHA256" == "$SHA256_DIGEST" ]] || die "signature verified SHA-256 does not match artifact SHA-256" + if [[ -z "$SIGNATURE_KEY_FINGERPRINT" && -z "$SIGNATURE_CERTIFICATE_IDENTITY" ]]; then + die "signature metadata requires --signature-key-fingerprint or --signature-certificate-identity" + fi + + SIGNATURE_METADATA_PROVIDED=true + SIGNATURE_VERIFICATION_PERFORMED=true + SIGNATURE_VERIFICATION_STATUS="verified" + SIGNATURE_FILE_SHA256="$(compute_sha256 "$SIGNATURE_FILE")" +} + +if [[ "$BUILD_ARTIFACT" == true ]]; then + build_with_cargo +fi +if [[ -z "$SOURCE_DATE_EPOCH_VALUE" ]]; then + SOURCE_DATE_EPOCH_VALUE="$(default_source_date_epoch)" +fi + +[[ -f "$ARTIFACT_PATH" ]] || die "artifact not found: $ARTIFACT_PATH" + +KIND="$(artifact_kind "$ARTIFACT_PATH")" +[[ "$KIND" != "unknown" ]] || die "artifact kind is unsupported: $ARTIFACT_PATH" + +PLATFORM_OUT_DIR="$OUT_DIR/$PLATFORM" +mkdir -p "$PLATFORM_OUT_DIR" + +ARTIFACT_NAME="$(basename "$ARTIFACT_PATH")" +ARTIFACT_OUTPUT="$PLATFORM_OUT_DIR/$ARTIFACT_NAME" +if [[ "$(absolute_path "$ARTIFACT_PATH")" != "$(absolute_path "$ARTIFACT_OUTPUT")" ]]; then + cp -p "$ARTIFACT_PATH" "$ARTIFACT_OUTPUT" +fi + +SYMBOLS_FILE="$PLATFORM_OUT_DIR/lite-backend-symbols.txt" +RAW_SYMBOLS_FILE="$PLATFORM_OUT_DIR/lite-backend-symbols.raw.txt" +NM_TOOL="$(select_nm_tool)" + +info "capturing exported symbols with $NM_TOOL" +if ! "$NM_TOOL" -g --defined-only "$ARTIFACT_OUTPUT" > "$RAW_SYMBOLS_FILE" 2> "$PLATFORM_OUT_DIR/lite-backend-symbols.err.txt"; then + die "symbol inventory failed; see $PLATFORM_OUT_DIR/lite-backend-symbols.err.txt" +fi +awk '{print $NF}' "$RAW_SYMBOLS_FILE" \ + | sed 's/^_//' \ + | grep -E '^(litelib_[A-Za-z0-9_]*|blake3_PW)$' \ + | sort -u > "$SYMBOLS_FILE" || true + +[[ -s "$SYMBOLS_FILE" ]] || die "no SDXL C ABI symbols were found in $ARTIFACT_OUTPUT" + +MISSING_SYMBOLS=() +for required in "${REQUIRED_SYMBOLS[@]}"; do + if ! grep -Fxq "$required" "$SYMBOLS_FILE"; then + MISSING_SYMBOLS+=("$required") + fi +done +if [[ ${#MISSING_SYMBOLS[@]} -ne 0 ]]; then + printf '%s\n' "${MISSING_SYMBOLS[@]}" > "$PLATFORM_OUT_DIR/lite-backend-missing-symbols.txt" + die "artifact is missing required symbols; see $PLATFORM_OUT_DIR/lite-backend-missing-symbols.txt" +fi + +SHA256_DIGEST="$(compute_sha256 "$ARTIFACT_OUTPUT")" +validate_signature_metadata +ARTIFACT_SIZE_BYTES="$(wc -c < "$ARTIFACT_OUTPUT" | tr -d ' ')" +PROJECT_REVISION="$(source_revision_for "$PROJECT_ROOT")" +BACKEND_REVISION="$(source_revision_for "$BACKEND_SOURCE_DIR")" +BACKEND_DEPENDENCY_REVISION="" +if [[ -n "$BACKEND_DEPENDENCY_DIR" ]]; then + BACKEND_DEPENDENCY_REVISION="$(source_revision_for "$BACKEND_DEPENDENCY_DIR")" +fi +ARTIFACT_SET_ID="$PLATFORM-${SHA256_DIGEST:0:16}" +REPRODUCIBLE_MANIFEST_VALUE=false +if [[ "$BUILD_ARTIFACT" == true && "$REPRODUCIBLE" == true ]]; then + REPRODUCIBLE_MANIFEST_VALUE=true +fi +PORTABLE_DEPENDENCY_OVERRIDE_MANIFEST_VALUE=false +if [[ "$BACKEND_DEPENDENCY_OVERRIDE_REQUESTED" == true ]]; then + PORTABLE_DEPENDENCY_OVERRIDE_MANIFEST_VALUE=true +fi +FILE_DESCRIPTION="unknown" +if command -v file >/dev/null 2>&1; then + FILE_DESCRIPTION="$(file -b "$ARTIFACT_OUTPUT")" +fi + +MANIFEST_FILE="$PLATFORM_OUT_DIR/lite-backend-artifact-manifest.json" +{ + printf '{\n' + printf ' "schema": "dragonx.lite.backend-artifact.v1",\n' + printf ' "generated_by": "scripts/build-lite-backend-artifact.sh",\n' + printf ' "read_only_inventory": true,\n' + printf ' "artifact_mutation_requested": false,\n' + printf ' "upload_requested": false,\n' + printf ' "signing_requested": false,\n' + printf ' "publication_requested": false,\n' + printf ' "signature_verification": {\n' + printf ' "policy_name": '; json_escape "$SIGNATURE_POLICY_NAME"; printf ',\n' + printf ' "policy_defined": %s,\n' "$SIGNATURE_POLICY_DEFINED_MANIFEST_VALUE" + printf ' "required_for_release": %s,\n' "$SIGNATURE_REQUIRED_MANIFEST_VALUE" + printf ' "metadata_read_only": true,\n' + printf ' "metadata_provided": %s,\n' "$SIGNATURE_METADATA_PROVIDED" + printf ' "verification_performed": %s,\n' "$SIGNATURE_VERIFICATION_PERFORMED" + printf ' "verification_status": '; json_escape "$SIGNATURE_VERIFICATION_STATUS"; printf ',\n' + printf ' "signature_format": '; json_escape "$SIGNATURE_FORMAT"; printf ',\n' + printf ' "signature_path": '; json_escape "$SIGNATURE_FILE"; printf ',\n' + printf ' "signature_file_sha256": '; json_escape "$SIGNATURE_FILE_SHA256"; printf ',\n' + printf ' "verification_tool": '; json_escape "$SIGNATURE_VERIFICATION_TOOL"; printf ',\n' + printf ' "verification_command": '; json_escape "$SIGNATURE_VERIFICATION_COMMAND"; printf ',\n' + printf ' "key_fingerprint": '; json_escape "$SIGNATURE_KEY_FINGERPRINT"; printf ',\n' + printf ' "certificate_identity": '; json_escape "$SIGNATURE_CERTIFICATE_IDENTITY"; printf ',\n' + printf ' "certificate_issuer": '; json_escape "$SIGNATURE_CERTIFICATE_ISSUER"; printf ',\n' + printf ' "transparency_log_url": '; json_escape "$SIGNATURE_TRANSPARENCY_LOG_URL"; printf ',\n' + printf ' "verified_artifact_sha256": '; json_escape "$SIGNATURE_VERIFIED_SHA256"; printf '\n' + printf ' },\n' + printf ' "abi_version": '; json_escape "$ABI_VERSION"; printf ',\n' + printf ' "link_mode": '; json_escape "$LINK_MODE"; printf ',\n' + printf ' "platform": '; json_escape "$PLATFORM"; printf ',\n' + printf ' "rust_target": '; json_escape "$RUST_TARGET"; printf ',\n' + printf ' "artifact": {\n' + printf ' "path": '; json_escape "$ARTIFACT_OUTPUT"; printf ',\n' + printf ' "kind": '; json_escape "$KIND"; printf ',\n' + printf ' "size_bytes": %s,\n' "$ARTIFACT_SIZE_BYTES" + printf ' "sha256": '; json_escape "$SHA256_DIGEST"; printf ',\n' + printf ' "file_description": '; json_escape "$FILE_DESCRIPTION"; printf '\n' + printf ' },\n' + printf ' "symbol_inventory": {\n' + printf ' "tool": '; json_escape "$NM_TOOL"; printf ',\n' + printf ' "symbols_path": '; json_escape "$SYMBOLS_FILE"; printf ',\n' + printf ' "raw_symbols_path": '; json_escape "$RAW_SYMBOLS_FILE"; printf ',\n' + printf ' "required_symbols": '; json_array "${REQUIRED_SYMBOLS[@]}"; printf ',\n' + printf ' "exported_symbols": '; json_array_from_file "$SYMBOLS_FILE"; printf ',\n' + printf ' "missing_required_symbols": []\n' + printf ' },\n' + printf ' "provenance": {\n' + printf ' "owner_ready": true,\n' + printf ' "metadata_provided": true,\n' + printf ' "source": '; json_escape "$BACKEND_SOURCE_DIR"; printf ',\n' + printf ' "cargo_build_source": '; json_escape "$BUILD_BACKEND_DIR"; printf ',\n' + printf ' "portable_dependency_override": %s,\n' "$PORTABLE_DEPENDENCY_OVERRIDE_MANIFEST_VALUE" + printf ' "silentdragonxlitelib_source": '; json_escape "$BACKEND_DEPENDENCY_DIR"; printf ',\n' + printf ' "builder": '; json_escape "$BUILDER"; printf ',\n' + printf ' "source_revision": '; json_escape "$BACKEND_REVISION"; printf ',\n' + printf ' "silentdragonxlitelib_revision": '; json_escape "$BACKEND_DEPENDENCY_REVISION"; printf ',\n' + printf ' "project_revision": '; json_escape "$PROJECT_REVISION"; printf ',\n' + printf ' "artifact_set_id": '; json_escape "$ARTIFACT_SET_ID"; printf ',\n' + printf ' "source_date_epoch": '; json_escape "$SOURCE_DATE_EPOCH_VALUE"; printf ',\n' + printf ' "reproducible": %s,\n' "$REPRODUCIBLE_MANIFEST_VALUE" + printf ' "redacted": true\n' + printf ' }\n' + printf '}\n' +} > "$MANIFEST_FILE" + +info "artifact: $ARTIFACT_OUTPUT" +info "symbols: $SYMBOLS_FILE" +info "manifest: $MANIFEST_FILE" +info "sha256: $SHA256_DIGEST" +cat <lastError().c_str() : "(no daemon object)", daemon::EmbeddedDaemon::findDaemonBinary().c_str()); } - } else if (!use_embedded_daemon_) { + } else if (!isUsingEmbeddedDaemon()) { VERBOSE_LOGF("[connect #%d] Embedded daemon disabled (using external). No config found at %s\n", connect_attempt, confPath.c_str()); } @@ -273,7 +262,7 @@ void App::tryConnect() daemon_controller_->lastError().empty() ? "(none)" : daemon_controller_->lastError().c_str()); } else { VERBOSE_LOGF("[connect #%d] No embedded daemon object (use_embedded=%s)\n", - attempt, use_embedded_daemon_ ? "yes" : "no"); + attempt, isUsingEmbeddedDaemon() ? "yes" : "no"); } worker_->post([this, config, daemonStarting, externalDetected, attempt]() -> rpc::RPCWorker::MainCb { @@ -377,7 +366,7 @@ void App::tryConnect() onDisconnected("Connection failed"); VERBOSE_LOGF("[connect #%d] RPC connection failed — no daemon starting, no external detected\n", attempt); - if (use_embedded_daemon_ && !isEmbeddedDaemonRunning()) { + if (isUsingEmbeddedDaemon() && !isEmbeddedDaemonRunning()) { // Prevent infinite crash-restart loop if (daemon_controller_ && daemon_controller_->crashCount() >= 3) { { char buf[128]; snprintf(buf, sizeof(buf), TR("sb_daemon_crashed"), daemon_controller_->crashCount()); @@ -397,7 +386,7 @@ void App::tryConnect() daemon_controller_ ? daemon_controller_->lastError().c_str() : "(no daemon object)"); } } - } else if (!use_embedded_daemon_) { + } else if (!isUsingEmbeddedDaemon()) { VERBOSE_LOGF("[connect #%d] Embedded daemon disabled — external daemon at %s:%s not responding\n", attempt, config.host.c_str(), config.port.c_str()); } else { @@ -1392,11 +1381,11 @@ void App::refreshMarketData() void App::startMining(int threads) { -#if DRAGONX_LITE_BUILD - (void)threads; - ui::Notifications::instance().warning("Solo mining is unavailable in lite build"); - return; -#endif + if (!supportsSoloMining()) { + (void)threads; + ui::Notifications::instance().warning("Solo mining is unavailable in lite build"); + return; + } if (!state_.connected || !rpc_ || !worker_) return; if (mining_toggle_in_progress_.exchange(true)) return; // already in progress @@ -1426,9 +1415,7 @@ void App::startMining(int threads) void App::stopMining() { -#if DRAGONX_LITE_BUILD - return; -#endif + if (!supportsSoloMining()) return; if (!state_.connected || !rpc_ || !worker_) return; if (mining_toggle_in_progress_.exchange(true)) return; // already in progress @@ -1454,6 +1441,12 @@ void App::stopMining() void App::startPoolMining(int threads) { + if (!supportsPoolMining()) { + (void)threads; + ui::Notifications::instance().warning("Pool mining is unavailable in this build"); + return; + } + if (!xmrig_manager_) xmrig_manager_ = std::make_unique(); diff --git a/src/app_security.cpp b/src/app_security.cpp index 8f85959..d3f9e26 100644 --- a/src/app_security.cpp +++ b/src/app_security.cpp @@ -616,7 +616,7 @@ void App::checkIdleMining() { if (idle_mining_active_) { idle_mining_active_ = false; idle_scaled_to_idle_ = false; - if (settings_ && settings_->getPoolMode()) { + if (settings_ && (settings_->getPoolMode() || !supportsSoloMining())) { if (xmrig_manager_ && xmrig_manager_->isRunning()) stopPoolMining(); } else { @@ -634,7 +634,8 @@ void App::checkIdleMining() { int idleSec = util::Platform::getSystemIdleSeconds(); int delay = settings_->getMineIdleDelay(); - bool isPool = settings_->getPoolMode(); + bool isPool = settings_->getPoolMode() || !supportsSoloMining(); + if (isPool && !supportsPoolMining()) return; bool threadScaling = settings_->getIdleThreadScaling(); int maxThreads = std::max(1, (int)std::thread::hardware_concurrency()); diff --git a/src/app_wizard.cpp b/src/app_wizard.cpp index 977e355..b14a32f 100644 --- a/src/app_wizard.cpp +++ b/src/app_wizard.cpp @@ -72,6 +72,11 @@ WizardUiState s_wizardUi; void App::restartWizard() { + if (!supportsFullNodeLifecycleActions()) { + ui::Notifications::instance().warning("Lite wallet lifecycle requests are available from Settings as dry-run readiness checks"); + return; + } + DEBUG_LOGF("[App] Restarting setup wizard — stopping daemon...\n"); // Reset crash counter for fresh wizard attempt @@ -804,6 +809,7 @@ void App::renderFirstRunWizard() { ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImGui::ColorConvertU32ToFloat4(ui::material::PrimaryVariant())); ImGui::PushStyleColor(ImGuiCol_Text, ImGui::ColorConvertU32ToFloat4(ui::material::OnPrimary())); ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding, 8.0f * dp); + ImGui::BeginDisabled(!supportsFullNodeLifecycleActions()); if (ImGui::Button("Retry##bs", ImVec2(btnW2, btnH2))) { // Stop embedded daemon before bootstrap to avoid chain data corruption stopDaemonForBootstrap(); @@ -812,6 +818,7 @@ void App::renderFirstRunWizard() { bootstrap_->start(dataDir); wizard_phase_ = WizardPhase::BootstrapInProgress; } + ImGui::EndDisabled(); ImGui::PopStyleVar(); ImGui::PopStyleColor(3); @@ -985,6 +992,7 @@ void App::renderFirstRunWizard() { ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImGui::ColorConvertU32ToFloat4(ui::material::PrimaryVariant())); ImGui::PushStyleColor(ImGuiCol_Text, ImGui::ColorConvertU32ToFloat4(ui::material::OnPrimary())); ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding, 8.0f * dp); + ImGui::BeginDisabled(!supportsFullNodeLifecycleActions()); if (ImGui::Button("Download##bs", ImVec2(dlBtnW, btnH2))) { // Stop embedded daemon before bootstrap to avoid chain data corruption stopDaemonForBootstrap(); @@ -993,6 +1001,7 @@ void App::renderFirstRunWizard() { bootstrap_->start(dataDir); wizard_phase_ = WizardPhase::BootstrapInProgress; } + ImGui::EndDisabled(); ImGui::PopStyleVar(); ImGui::PopStyleColor(3); @@ -1002,6 +1011,7 @@ void App::renderFirstRunWizard() { ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImGui::ColorConvertU32ToFloat4(ui::material::PrimaryVariant())); ImGui::PushStyleColor(ImGuiCol_Text, ImGui::ColorConvertU32ToFloat4(ui::material::OnSurface())); ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding, 8.0f * dp); + ImGui::BeginDisabled(!supportsFullNodeLifecycleActions()); if (ImGui::Button("Mirror##bs_mirror", ImVec2(mirrorW, btnH2))) { stopDaemonForBootstrap(); bootstrap_ = std::make_unique(); @@ -1010,6 +1020,7 @@ void App::renderFirstRunWizard() { bootstrap_->start(dataDir, mirrorUrl); wizard_phase_ = WizardPhase::BootstrapInProgress; } + ImGui::EndDisabled(); if (ImGui::IsItemHovered()) { ImGui::SetTooltip("Download from mirror (bootstrap2.dragonx.is).\nUse this if the main download is slow or failing."); } diff --git a/src/chat/chat_protocol.cpp b/src/chat/chat_protocol.cpp new file mode 100644 index 0000000..2e348fd --- /dev/null +++ b/src/chat/chat_protocol.cpp @@ -0,0 +1,1855 @@ +#include "chat_protocol.h" + +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +namespace dragonx::chat { +namespace { + +bool isHexString(const std::string& value) +{ + for (unsigned char ch : value) { + if (!std::isxdigit(ch)) return false; + } + return true; +} + +std::optional hexNibble(unsigned char character) +{ + if (character >= '0' && character <= '9') return static_cast(character - '0'); + if (character >= 'a' && character <= 'f') return static_cast(character - 'a' + 10); + if (character >= 'A' && character <= 'F') return static_cast(character - 'A' + 10); + return std::nullopt; +} + +bool isCiphertextPayloadCandidate(const std::string& value) +{ + return !value.empty() && value.size() <= kHushChatMemoByteLimit && + value.size() % 2 == 0 && isHexString(value); +} + +bool isContactPayloadCandidate(const std::string& value) +{ + return !value.empty() && value.size() <= kHushChatMemoByteLimit && value.front() != '{'; +} + +bool readRequiredString(const nlohmann::json& object, + const char* key, + std::string& value, + std::string& error) +{ + auto it = object.find(key); + if (it == object.end()) { + error = std::string("missing field: ") + key; + return false; + } + if (!it->is_string()) { + error = std::string("field is not a string: ") + key; + return false; + } + value = it->get(); + return true; +} + +bool readRequiredInt(const nlohmann::json& object, + const char* key, + int& value, + std::string& error) +{ + auto it = object.find(key); + if (it == object.end()) { + error = std::string("missing field: ") + key; + return false; + } + if (!it->is_number_integer()) { + error = std::string("field is not an integer: ") + key; + return false; + } + value = it->get(); + return true; +} + +HushChatHeaderParseResult fail(std::string error) +{ + HushChatHeaderParseResult result; + result.error = std::move(error); + return result; +} + +std::optional readJsonString(const nlohmann::json& object, const char* key) +{ + auto it = object.find(key); + if (it == object.end() || !it->is_string()) return std::nullopt; + return it->get(); +} + +std::optional readJsonSize(const nlohmann::json& object, const char* key) +{ + auto it = object.find(key); + if (it == object.end() || (!it->is_number_integer() && !it->is_number_unsigned())) return std::nullopt; + if (it->is_number_unsigned()) return it->get(); + auto value = it->get(); + if (value < 0) return std::nullopt; + return static_cast(value); +} + +std::optional parseFixtureDirection(const std::string& value) +{ + if (value == "Incoming") return HushChatDecryptDirection::Incoming; + if (value == "Outgoing") return HushChatDecryptDirection::Outgoing; + return std::nullopt; +} + +std::optional parseFixtureSessionKeySelection(const std::string& value) +{ + if (value == "ClientRx") return HushChatSessionKeySelection::ClientRx; + if (value == "ServerTx") return HushChatSessionKeySelection::ServerTx; + return std::nullopt; +} + +std::optional parseFixtureKind(const std::string& value) +{ + if (value == "incoming_memo") return HushChatCompatibilityFixtureKind::IncomingMemo; + if (value == "outgoing_memo") return HushChatCompatibilityFixtureKind::OutgoingMemo; + if (value == "seed_public_key_projection") return HushChatCompatibilityFixtureKind::SeedPublicKeyProjection; + if (value == "corrupted_auth_failure") return HushChatCompatibilityFixtureKind::CorruptedAuthFailure; + if (value == "cont_exclusion") return HushChatCompatibilityFixtureKind::ContactExclusion; + return std::nullopt; +} + +std::optional parseFixtureFileStatus(const std::string& value) +{ + if (value == "pending") return HushChatCompatibilityFixtureFileStatus::Pending; + if (value == "ready") return HushChatCompatibilityFixtureFileStatus::Ready; + return std::nullopt; +} + +std::string lowerCopy(const std::string& value) +{ + std::string lowered; + lowered.reserve(value.size()); + for (unsigned char ch : value) lowered.push_back(static_cast(std::tolower(ch))); + return lowered; +} + +bool isProhibitedCaptureManifestKey(const std::string& key) +{ + const std::string lowered = lowerCopy(key); + if (lowered.rfind("no_", 0) == 0) return false; + + static const std::vector prohibitedKeys = { + "fixture", + "fixtures", + "passphrase", + "password", + "plaintext", + "plaintext_hash_hex", + "memo", + "memostr", + "memo_contents", + "header_memo", + "ciphertext", + "ciphertext_memo", + "ciphertext_bytes", + "private_key", + "viewing_key", + "spending_key", + "wallet_seed", + "wallet_file", + "wallet_files", + "stored_chat_key_hex", + "local_public_key_hex", + "peer_public_key_hex", + "public_key_hex", + "secretstream_header", + "derived_key", + "session_key", + "secret_key", + "seed_bytes" + }; + + return std::find(prohibitedKeys.begin(), prohibitedKeys.end(), lowered) != prohibitedKeys.end(); +} + +std::size_t countProhibitedCaptureManifestFields(const nlohmann::json& value) +{ + std::size_t count = 0; + if (value.is_object()) { + for (auto it = value.begin(); it != value.end(); ++it) { + if (isProhibitedCaptureManifestKey(it.key())) ++count; + count += countProhibitedCaptureManifestFields(it.value()); + } + } else if (value.is_array()) { + for (const auto& item : value) count += countProhibitedCaptureManifestFields(item); + } + return count; +} + +std::vector requiredCaptureHandlingFlags() +{ + return { + "disposable_wallets_only", + "non_sensitive_vectors_only", + "no_passphrases", + "no_plaintext", + "no_memo_contents", + "no_private_keys", + "no_wallet_files", + "no_ciphertext_byte_dumps", + "no_derived_keys", + "no_session_keys", + "redacted_report_only" + }; +} + +} // namespace + +const char* hushChatHeaderTypeName(HushChatHeaderType type) +{ + switch (type) { + case HushChatHeaderType::Message: + return "Memo"; + case HushChatHeaderType::ContactRequest: + return "Cont"; + } + return "Unknown"; +} + +const char* hushChatMemoGroupingIssueName(HushChatMemoGroupingIssue issue) +{ + switch (issue) { + case HushChatMemoGroupingIssue::InvalidHeader: + return "InvalidHeader"; + case HushChatMemoGroupingIssue::MissingPayload: + return "MissingPayload"; + case HushChatMemoGroupingIssue::DuplicateHeader: + return "DuplicateHeader"; + case HushChatMemoGroupingIssue::OversizedMemo: + return "OversizedMemo"; + } + return "Unknown"; +} + +const char* hushChatDecryptPreflightErrorName(HushChatDecryptPreflightError error) +{ + switch (error) { + case HushChatDecryptPreflightError::None: + return "None"; + case HushChatDecryptPreflightError::FeatureDisabled: + return "FeatureDisabled"; + case HushChatDecryptPreflightError::NonMessageHeader: + return "NonMessageHeader"; + case HushChatDecryptPreflightError::InvalidHeaderNumber: + return "InvalidHeaderNumber"; + case HushChatDecryptPreflightError::UnsupportedVersion: + return "UnsupportedVersion"; + case HushChatDecryptPreflightError::MissingReplyAddress: + return "MissingReplyAddress"; + case HushChatDecryptPreflightError::MissingConversationId: + return "MissingConversationId"; + case HushChatDecryptPreflightError::InvalidSecretstreamHeader: + return "InvalidSecretstreamHeader"; + case HushChatDecryptPreflightError::InvalidPublicKey: + return "InvalidPublicKey"; + case HushChatDecryptPreflightError::EmptyCiphertext: + return "EmptyCiphertext"; + case HushChatDecryptPreflightError::OversizedCiphertext: + return "OversizedCiphertext"; + case HushChatDecryptPreflightError::OddLengthCiphertext: + return "OddLengthCiphertext"; + case HushChatDecryptPreflightError::InvalidCiphertextHex: + return "InvalidCiphertextHex"; + case HushChatDecryptPreflightError::TruncatedCiphertext: + return "TruncatedCiphertext"; + } + return "Unknown"; +} + +const char* hushChatHexDecodeErrorName(HushChatHexDecodeError error) +{ + switch (error) { + case HushChatHexDecodeError::None: + return "None"; + case HushChatHexDecodeError::Empty: + return "Empty"; + case HushChatHexDecodeError::OddLength: + return "OddLength"; + case HushChatHexDecodeError::InvalidHex: + return "InvalidHex"; + case HushChatHexDecodeError::UnexpectedByteLength: + return "UnexpectedByteLength"; + } + return "Unknown"; +} + +const char* hushChatDecryptDirectionName(HushChatDecryptDirection direction) +{ + switch (direction) { + case HushChatDecryptDirection::Incoming: + return "Incoming"; + case HushChatDecryptDirection::Outgoing: + return "Outgoing"; + } + return "Unknown"; +} + +const char* hushChatSessionKeySelectionName(HushChatSessionKeySelection selection) +{ + switch (selection) { + case HushChatSessionKeySelection::ClientRx: + return "ClientRx"; + case HushChatSessionKeySelection::ServerTx: + return "ServerTx"; + } + return "Unknown"; +} + +const char* hushChatDecryptInputErrorName(HushChatDecryptInputError error) +{ + switch (error) { + case HushChatDecryptInputError::None: + return "None"; + case HushChatDecryptInputError::FeatureDisabled: + return "FeatureDisabled"; + case HushChatDecryptInputError::InvalidStoredChatKey: + return "InvalidStoredChatKey"; + case HushChatDecryptInputError::DecryptPreflightFailed: + return "DecryptPreflightFailed"; + case HushChatDecryptInputError::InvalidPeerPublicKey: + return "InvalidPeerPublicKey"; + case HushChatDecryptInputError::InvalidStreamHeader: + return "InvalidStreamHeader"; + case HushChatDecryptInputError::InvalidCiphertext: + return "InvalidCiphertext"; + } + return "Unknown"; +} + +const char* hushChatCompatibilityFixtureErrorName(HushChatCompatibilityFixtureError error) +{ + switch (error) { + case HushChatCompatibilityFixtureError::None: + return "None"; + case HushChatCompatibilityFixtureError::FeatureDisabled: + return "FeatureDisabled"; + case HushChatCompatibilityFixtureError::MissingFixtureId: + return "MissingFixtureId"; + case HushChatCompatibilityFixtureError::InvalidLocalPublicKey: + return "InvalidLocalPublicKey"; + case HushChatCompatibilityFixtureError::InvalidPeerPublicKey: + return "InvalidPeerPublicKey"; + case HushChatCompatibilityFixtureError::InvalidHeaderMemo: + return "InvalidHeaderMemo"; + case HushChatCompatibilityFixtureError::InvalidMemoPair: + return "InvalidMemoPair"; + case HushChatCompatibilityFixtureError::NonMemoHeader: + return "NonMemoHeader"; + case HushChatCompatibilityFixtureError::HeaderPublicKeyMismatch: + return "HeaderPublicKeyMismatch"; + case HushChatCompatibilityFixtureError::DecryptInputFailed: + return "DecryptInputFailed"; + case HushChatCompatibilityFixtureError::NotFixtureReady: + return "NotFixtureReady"; + case HushChatCompatibilityFixtureError::ExpectedStoredChatKeyLengthMismatch: + return "ExpectedStoredChatKeyLengthMismatch"; + case HushChatCompatibilityFixtureError::ExpectedSeedLengthMismatch: + return "ExpectedSeedLengthMismatch"; + case HushChatCompatibilityFixtureError::ExpectedLocalPublicKeyLengthMismatch: + return "ExpectedLocalPublicKeyLengthMismatch"; + case HushChatCompatibilityFixtureError::ExpectedPeerPublicKeyLengthMismatch: + return "ExpectedPeerPublicKeyLengthMismatch"; + case HushChatCompatibilityFixtureError::ExpectedStreamHeaderLengthMismatch: + return "ExpectedStreamHeaderLengthMismatch"; + case HushChatCompatibilityFixtureError::ExpectedCiphertextLengthMismatch: + return "ExpectedCiphertextLengthMismatch"; + case HushChatCompatibilityFixtureError::ExpectedPlaintextLengthMismatch: + return "ExpectedPlaintextLengthMismatch"; + case HushChatCompatibilityFixtureError::ExpectedRoleMismatch: + return "ExpectedRoleMismatch"; + case HushChatCompatibilityFixtureError::InvalidPlaintextHash: + return "InvalidPlaintextHash"; + } + return "Unknown"; +} + +const char* hushChatCompatibilityFixtureKindName(HushChatCompatibilityFixtureKind kind) +{ + switch (kind) { + case HushChatCompatibilityFixtureKind::IncomingMemo: + return "incoming_memo"; + case HushChatCompatibilityFixtureKind::OutgoingMemo: + return "outgoing_memo"; + case HushChatCompatibilityFixtureKind::SeedPublicKeyProjection: + return "seed_public_key_projection"; + case HushChatCompatibilityFixtureKind::CorruptedAuthFailure: + return "corrupted_auth_failure"; + case HushChatCompatibilityFixtureKind::ContactExclusion: + return "cont_exclusion"; + } + return "unknown"; +} + +const char* hushChatCompatibilityFixtureFileStatusName(HushChatCompatibilityFixtureFileStatus status) +{ + switch (status) { + case HushChatCompatibilityFixtureFileStatus::Pending: + return "pending"; + case HushChatCompatibilityFixtureFileStatus::Ready: + return "ready"; + } + return "unknown"; +} + +const char* hushChatCompatibilityFixtureFileErrorName(HushChatCompatibilityFixtureFileError error) +{ + switch (error) { + case HushChatCompatibilityFixtureFileError::None: + return "None"; + case HushChatCompatibilityFixtureFileError::FeatureDisabled: + return "FeatureDisabled"; + case HushChatCompatibilityFixtureFileError::InvalidJson: + return "InvalidJson"; + case HushChatCompatibilityFixtureFileError::JsonNotObject: + return "JsonNotObject"; + case HushChatCompatibilityFixtureFileError::InvalidSchema: + return "InvalidSchema"; + case HushChatCompatibilityFixtureFileError::MissingKind: + return "MissingKind"; + case HushChatCompatibilityFixtureFileError::UnknownKind: + return "UnknownKind"; + case HushChatCompatibilityFixtureFileError::MissingStatus: + return "MissingStatus"; + case HushChatCompatibilityFixtureFileError::UnknownStatus: + return "UnknownStatus"; + case HushChatCompatibilityFixtureFileError::MissingFixtureId: + return "MissingFixtureId"; + case HushChatCompatibilityFixtureFileError::MissingPendingReason: + return "MissingPendingReason"; + case HushChatCompatibilityFixtureFileError::MissingFixtureObject: + return "MissingFixtureObject"; + case HushChatCompatibilityFixtureFileError::InvalidFixtureField: + return "InvalidFixtureField"; + case HushChatCompatibilityFixtureFileError::FixtureVerificationFailed: + return "FixtureVerificationFailed"; + case HushChatCompatibilityFixtureFileError::ContactFixtureNotExcluded: + return "ContactFixtureNotExcluded"; + case HushChatCompatibilityFixtureFileError::FileReadFailed: + return "FileReadFailed"; + } + return "Unknown"; +} + +const char* hushChatSeedPublicKeyProjectionErrorName(HushChatSeedPublicKeyProjectionError error) +{ + switch (error) { + case HushChatSeedPublicKeyProjectionError::None: + return "None"; + case HushChatSeedPublicKeyProjectionError::FeatureDisabled: + return "FeatureDisabled"; + case HushChatSeedPublicKeyProjectionError::MissingFixtureId: + return "MissingFixtureId"; + case HushChatSeedPublicKeyProjectionError::InvalidStoredChatKey: + return "InvalidStoredChatKey"; + case HushChatSeedPublicKeyProjectionError::InvalidLocalPublicKey: + return "InvalidLocalPublicKey"; + case HushChatSeedPublicKeyProjectionError::ExpectedStoredChatKeyLengthMismatch: + return "ExpectedStoredChatKeyLengthMismatch"; + case HushChatSeedPublicKeyProjectionError::ExpectedSeedLengthMismatch: + return "ExpectedSeedLengthMismatch"; + case HushChatSeedPublicKeyProjectionError::ExpectedLocalPublicKeyLengthMismatch: + return "ExpectedLocalPublicKeyLengthMismatch"; + case HushChatSeedPublicKeyProjectionError::SodiumInitializationFailed: + return "SodiumInitializationFailed"; + case HushChatSeedPublicKeyProjectionError::KeypairProjectionFailed: + return "KeypairProjectionFailed"; + case HushChatSeedPublicKeyProjectionError::ProjectedPublicKeyMismatch: + return "ProjectedPublicKeyMismatch"; + } + return "Unknown"; +} + +const char* hushChatCorruptedAuthFailureReadinessErrorName(HushChatCorruptedAuthFailureReadinessError error) +{ + switch (error) { + case HushChatCorruptedAuthFailureReadinessError::None: + return "None"; + case HushChatCorruptedAuthFailureReadinessError::FeatureDisabled: + return "FeatureDisabled"; + case HushChatCorruptedAuthFailureReadinessError::FixturePending: + return "FixturePending"; + case HushChatCorruptedAuthFailureReadinessError::WrongFixtureKind: + return "WrongFixtureKind"; + case HushChatCorruptedAuthFailureReadinessError::FixtureNotVerified: + return "FixtureNotVerified"; + case HushChatCorruptedAuthFailureReadinessError::SeedProjectionNotVerified: + return "SeedProjectionNotVerified"; + } + return "Unknown"; +} + +const char* hushChatCompatibilityFixtureImportErrorName(HushChatCompatibilityFixtureImportError error) +{ + switch (error) { + case HushChatCompatibilityFixtureImportError::None: + return "None"; + case HushChatCompatibilityFixtureImportError::FeatureDisabled: + return "FeatureDisabled"; + case HushChatCompatibilityFixtureImportError::MissingRequiredKind: + return "MissingRequiredKind"; + case HushChatCompatibilityFixtureImportError::DuplicateKind: + return "DuplicateKind"; + case HushChatCompatibilityFixtureImportError::FixtureLoadFailed: + return "FixtureLoadFailed"; + case HushChatCompatibilityFixtureImportError::FixtureKindMismatch: + return "FixtureKindMismatch"; + case HushChatCompatibilityFixtureImportError::FixturePending: + return "FixturePending"; + case HushChatCompatibilityFixtureImportError::FixtureInvalid: + return "FixtureInvalid"; + case HushChatCompatibilityFixtureImportError::FixtureNotVerified: + return "FixtureNotVerified"; + case HushChatCompatibilityFixtureImportError::SeedProjectionFailed: + return "SeedProjectionFailed"; + case HushChatCompatibilityFixtureImportError::AuthFailureScaffoldFailed: + return "AuthFailureScaffoldFailed"; + case HushChatCompatibilityFixtureImportError::ContactFixtureNotExcluded: + return "ContactFixtureNotExcluded"; + } + return "Unknown"; +} + +const char* hushChatCaptureManifestErrorName(HushChatCaptureManifestError error) +{ + switch (error) { + case HushChatCaptureManifestError::None: + return "None"; + case HushChatCaptureManifestError::FeatureDisabled: + return "FeatureDisabled"; + case HushChatCaptureManifestError::FileReadFailed: + return "FileReadFailed"; + case HushChatCaptureManifestError::InvalidJson: + return "InvalidJson"; + case HushChatCaptureManifestError::JsonNotObject: + return "JsonNotObject"; + case HushChatCaptureManifestError::InvalidSchema: + return "InvalidSchema"; + case HushChatCaptureManifestError::MissingManifestId: + return "MissingManifestId"; + case HushChatCaptureManifestError::MissingStatus: + return "MissingStatus"; + case HushChatCaptureManifestError::UnknownStatus: + return "UnknownStatus"; + case HushChatCaptureManifestError::MissingFixtureDirectory: + return "MissingFixtureDirectory"; + case HushChatCaptureManifestError::MissingDryRunCommand: + return "MissingDryRunCommand"; + case HushChatCaptureManifestError::InvalidDryRunCommand: + return "InvalidDryRunCommand"; + case HushChatCaptureManifestError::MissingProvenance: + return "MissingProvenance"; + case HushChatCaptureManifestError::MissingSourceClient: + return "MissingSourceClient"; + case HushChatCaptureManifestError::InvalidSourceClient: + return "InvalidSourceClient"; + case HushChatCaptureManifestError::MissingSourceClientVersion: + return "MissingSourceClientVersion"; + case HushChatCaptureManifestError::MissingCaptureDate: + return "MissingCaptureDate"; + case HushChatCaptureManifestError::MissingNetwork: + return "MissingNetwork"; + case HushChatCaptureManifestError::MissingCaptureMethod: + return "MissingCaptureMethod"; + case HushChatCaptureManifestError::MissingHandling: + return "MissingHandling"; + case HushChatCaptureManifestError::MissingHandlingFlag: + return "MissingHandlingFlag"; + case HushChatCaptureManifestError::HandlingFlagNotTrue: + return "HandlingFlagNotTrue"; + case HushChatCaptureManifestError::MissingCategories: + return "MissingCategories"; + case HushChatCaptureManifestError::InvalidCategoryEntry: + return "InvalidCategoryEntry"; + case HushChatCaptureManifestError::UnknownCategory: + return "UnknownCategory"; + case HushChatCaptureManifestError::DuplicateCategory: + return "DuplicateCategory"; + case HushChatCaptureManifestError::MissingRequiredCategory: + return "MissingRequiredCategory"; + case HushChatCaptureManifestError::ProhibitedFieldPresent: + return "ProhibitedFieldPresent"; + } + return "Unknown"; +} + +HushChatSessionKeySelection hushChatSessionKeySelectionForDirection(HushChatDecryptDirection direction) +{ + switch (direction) { + case HushChatDecryptDirection::Incoming: + return HushChatSessionKeySelection::ClientRx; + case HushChatDecryptDirection::Outgoing: + return HushChatSessionKeySelection::ServerTx; + } + return HushChatSessionKeySelection::ClientRx; +} + +HushChatHeaderParseResult parseHushChatHeaderMemo(const std::string& memo) +{ + if (memo.empty()) return fail("empty memo"); + if (memo.size() > kHushChatMemoByteLimit) return fail("memo exceeds HushChat memo byte limit"); + if (memo.front() != '{') return fail("memo is not a HushChat header JSON object"); + + nlohmann::json object; + try { + object = nlohmann::json::parse(memo); + } catch (const nlohmann::json::parse_error& e) { + return fail(std::string("invalid JSON: ") + e.what()); + } + if (!object.is_object()) return fail("header memo JSON is not an object"); + + HushChatHeader header; + std::string type; + std::string error; + if (!readRequiredInt(object, "h", header.header_number, error)) return fail(error); + if (!readRequiredInt(object, "v", header.version, error)) return fail(error); + if (!readRequiredString(object, "z", header.reply_zaddr, error)) return fail(error); + if (!readRequiredString(object, "cid", header.conversation_id, error)) return fail(error); + if (!readRequiredString(object, "t", type, error)) return fail(error); + if (!readRequiredString(object, "e", header.secretstream_header_hex, error)) return fail(error); + if (!readRequiredString(object, "p", header.public_key_hex, error)) return fail(error); + + if (header.header_number < 1) return fail("header number must be positive"); + if (header.version != kHushChatSupportedVersion) return fail("unsupported HushChat version"); + if (header.reply_zaddr.empty()) return fail("reply z-address is empty"); + if (header.conversation_id.empty()) return fail("conversation id is empty"); + + if (type == "Memo") { + header.type = HushChatHeaderType::Message; + } else if (type == "Cont") { + header.type = HushChatHeaderType::ContactRequest; + } else { + return fail("unknown HushChat header type"); + } + + if (header.public_key_hex.size() != kHushChatPublicKeyHexLength || !isHexString(header.public_key_hex)) { + return fail("public key must be 32 bytes encoded as hex"); + } + + if (header.type == HushChatHeaderType::Message) { + if (header.secretstream_header_hex.size() != kHushChatSecretstreamHeaderHexLength || + !isHexString(header.secretstream_header_hex)) { + return fail("message header must include a 24 byte secretstream header encoded as hex"); + } + } else if (!header.secretstream_header_hex.empty()) { + return fail("contact request header must not include a secretstream header"); + } + + HushChatHeaderParseResult result; + result.ok = true; + result.header = std::move(header); + return result; +} + +HushChatMemoGroupingResult groupHushChatMemoOutputs(const std::vector& outputs) +{ + struct OrderedOutput { + std::size_t input_index = 0; + HushChatMemoOutput output; + }; + + std::vector ordered; + ordered.reserve(outputs.size()); + for (std::size_t index = 0; index < outputs.size(); ++index) { + ordered.push_back(OrderedOutput{index, outputs[index]}); + } + std::stable_sort(ordered.begin(), ordered.end(), [](const OrderedOutput& left, const OrderedOutput& right) { + if (left.output.position == right.output.position) return left.input_index < right.input_index; + return left.output.position < right.output.position; + }); + + HushChatMemoGroupingResult result; + std::optional pending_header_output; + std::optional pending_header; + + auto addIssue = [&](HushChatMemoGroupingIssue issue, std::size_t position, std::string detail) { + result.issues.push_back(HushChatMemoGroupingIssueInfo{issue, position, std::move(detail)}); + }; + + auto clearPendingAsMissing = [&]() { + if (!pending_header_output) return; + addIssue(HushChatMemoGroupingIssue::MissingPayload, + pending_header_output->position, + "header did not have a matching payload memo"); + pending_header_output.reset(); + pending_header.reset(); + }; + + for (const auto& entry : ordered) { + const auto& output = entry.output; + if (output.memo.size() > kHushChatMemoByteLimit) { + addIssue(HushChatMemoGroupingIssue::OversizedMemo, + output.position, + "memo exceeds HushChat memo byte limit"); + continue; + } + + if (!output.memo.empty() && output.memo.front() == '{') { + auto parsed = parseHushChatHeaderMemo(output.memo); + if (!parsed.ok) { + addIssue(HushChatMemoGroupingIssue::InvalidHeader, output.position, parsed.error); + continue; + } + + if (pending_header_output) { + addIssue(HushChatMemoGroupingIssue::DuplicateHeader, + output.position, + "encountered another HushChat header before a payload"); + clearPendingAsMissing(); + } + + pending_header_output = output; + pending_header = std::move(parsed.header); + continue; + } + + if (!pending_header_output || !pending_header) { + ++result.ignored_memo_count; + continue; + } + + const bool payload_matches = pending_header->type == HushChatHeaderType::Message + ? isCiphertextPayloadCandidate(output.memo) + : isContactPayloadCandidate(output.memo); + if (!payload_matches) { + ++result.ignored_memo_count; + continue; + } + + HushChatMemoPair pair; + pair.header = std::move(*pending_header); + pair.header_position = pending_header_output->position; + pair.payload_position = output.position; + pair.payload_memo = output.memo; + result.pairs.push_back(std::move(pair)); + pending_header_output.reset(); + pending_header.reset(); + } + + clearPendingAsMissing(); + return result; +} + +HushChatTransactionExtractionResult extractHushChatTransactionMetadata( + const HushChatTransactionInput& transaction, + bool featureEnabled) +{ + HushChatTransactionExtractionResult result; + result.feature_enabled = featureEnabled; + if (!featureEnabled || transaction.txid.empty()) return result; + + auto grouped = groupHushChatMemoOutputs(transaction.outputs); + result.ignored_memo_count = grouped.ignored_memo_count; + result.issues.reserve(grouped.issues.size()); + for (const auto& issue : grouped.issues) { + result.issues.push_back(HushChatMemoGroupingIssueInfo{ + issue.issue, + issue.position, + hushChatMemoGroupingIssueName(issue.issue) + }); + } + + result.metadata.reserve(grouped.pairs.size()); + for (const auto& pair : grouped.pairs) { + HushChatTransactionMetadata metadata; + metadata.txid = transaction.txid; + metadata.type = pair.header.type; + metadata.conversation_id = pair.header.conversation_id; + metadata.reply_zaddr = pair.header.reply_zaddr; + metadata.header_position = pair.header_position; + metadata.payload_position = pair.payload_position; + metadata.payload_size = pair.payload_memo.size(); + result.metadata.push_back(std::move(metadata)); + } + + return result; +} + +HushChatDecryptPreflightResult validateHushChatMemoDecryptPreflight( + const HushChatDecryptPreflightInput& input, + bool featureEnabled) +{ + auto failPreflight = [&](HushChatDecryptPreflightError error) { + HushChatDecryptPreflightResult result; + result.feature_enabled = featureEnabled; + result.error = error; + result.error_name = hushChatDecryptPreflightErrorName(error); + return result; + }; + + if (!featureEnabled) return failPreflight(HushChatDecryptPreflightError::FeatureDisabled); + + const auto& header = input.header; + if (header.type != HushChatHeaderType::Message) { + return failPreflight(HushChatDecryptPreflightError::NonMessageHeader); + } + if (header.header_number < 1) return failPreflight(HushChatDecryptPreflightError::InvalidHeaderNumber); + if (header.version != kHushChatSupportedVersion) { + return failPreflight(HushChatDecryptPreflightError::UnsupportedVersion); + } + if (header.reply_zaddr.empty()) return failPreflight(HushChatDecryptPreflightError::MissingReplyAddress); + if (header.conversation_id.empty()) return failPreflight(HushChatDecryptPreflightError::MissingConversationId); + if (header.secretstream_header_hex.size() != kHushChatSecretstreamHeaderHexLength || + !isHexString(header.secretstream_header_hex)) { + return failPreflight(HushChatDecryptPreflightError::InvalidSecretstreamHeader); + } + if (header.public_key_hex.size() != kHushChatPublicKeyHexLength || !isHexString(header.public_key_hex)) { + return failPreflight(HushChatDecryptPreflightError::InvalidPublicKey); + } + + if (input.ciphertext_hex.empty()) return failPreflight(HushChatDecryptPreflightError::EmptyCiphertext); + if (input.ciphertext_hex.size() > kHushChatMemoByteLimit) { + return failPreflight(HushChatDecryptPreflightError::OversizedCiphertext); + } + if (input.ciphertext_hex.size() % 2 != 0) return failPreflight(HushChatDecryptPreflightError::OddLengthCiphertext); + if (!isHexString(input.ciphertext_hex)) return failPreflight(HushChatDecryptPreflightError::InvalidCiphertextHex); + + const std::size_t ciphertextSize = input.ciphertext_hex.size() / 2; + if (ciphertextSize <= kHushChatSecretstreamABytes) { + return failPreflight(HushChatDecryptPreflightError::TruncatedCiphertext); + } + + HushChatDecryptPreflightResult result; + result.ok = true; + result.feature_enabled = true; + result.error = HushChatDecryptPreflightError::None; + result.error_name = hushChatDecryptPreflightErrorName(result.error); + result.ciphertext_size = ciphertextSize; + return result; +} + +HushChatHexDecodeResult decodeHushChatHexBytes(const std::string& hex, + std::size_t expectedByteLength) +{ + auto failDecode = [](HushChatHexDecodeError error) { + HushChatHexDecodeResult result; + result.error = error; + result.error_name = hushChatHexDecodeErrorName(error); + return result; + }; + + if (hex.empty()) { + if (expectedByteLength == 0) { + HushChatHexDecodeResult result; + result.ok = true; + return result; + } + return failDecode(HushChatHexDecodeError::Empty); + } + if (hex.size() % 2 != 0) return failDecode(HushChatHexDecodeError::OddLength); + if (!isHexString(hex)) return failDecode(HushChatHexDecodeError::InvalidHex); + if (hex.size() / 2 != expectedByteLength) { + return failDecode(HushChatHexDecodeError::UnexpectedByteLength); + } + + HushChatHexDecodeResult result; + result.ok = true; + result.bytes.reserve(expectedByteLength); + for (std::size_t index = 0; index < hex.size(); index += 2) { + auto high = hexNibble(static_cast(hex[index])); + auto low = hexNibble(static_cast(hex[index + 1])); + if (!high || !low) return failDecode(HushChatHexDecodeError::InvalidHex); + result.bytes.push_back(static_cast((*high << 4) | *low)); + } + return result; +} + +HushChatDecryptInputPreparationResult prepareHushChatDecryptInput( + const HushChatDecryptInputMaterial& material, + bool featureEnabled) +{ + auto failPreparation = [&](HushChatDecryptInputError error, + HushChatHexDecodeError hexError = HushChatHexDecodeError::None, + HushChatDecryptPreflightError preflightError = HushChatDecryptPreflightError::None) { + HushChatDecryptInputPreparationResult result; + result.feature_enabled = featureEnabled; + result.error = error; + result.error_name = hushChatDecryptInputErrorName(error); + result.hex_error = hexError; + result.preflight_error = preflightError; + return result; + }; + + if (!featureEnabled) return failPreparation(HushChatDecryptInputError::FeatureDisabled); + + auto storedChatKey = decodeHushChatHexBytes(material.stored_chat_key_hex, + kHushChatStoredChatKeyByteLength); + if (!storedChatKey.ok) { + return failPreparation(HushChatDecryptInputError::InvalidStoredChatKey, storedChatKey.error); + } + + auto preflight = validateHushChatMemoDecryptPreflight( + HushChatDecryptPreflightInput{material.header, material.ciphertext_hex}, + true); + if (!preflight.ok) { + return failPreparation(HushChatDecryptInputError::DecryptPreflightFailed, + HushChatHexDecodeError::None, + preflight.error); + } + + const std::string& peerPublicKeyHex = material.peer_public_key_hex.empty() + ? material.header.public_key_hex + : material.peer_public_key_hex; + auto peerPublicKey = decodeHushChatHexBytes(peerPublicKeyHex, + kHushChatPublicKeyByteLength); + if (!peerPublicKey.ok) { + return failPreparation(HushChatDecryptInputError::InvalidPeerPublicKey, peerPublicKey.error); + } + + auto streamHeader = decodeHushChatHexBytes(material.header.secretstream_header_hex, + kHushChatSecretstreamHeaderByteLength); + if (!streamHeader.ok) { + return failPreparation(HushChatDecryptInputError::InvalidStreamHeader, streamHeader.error); + } + + auto ciphertext = decodeHushChatHexBytes(material.ciphertext_hex, preflight.ciphertext_size); + if (!ciphertext.ok) { + return failPreparation(HushChatDecryptInputError::InvalidCiphertext, ciphertext.error); + } + + HushChatDecryptInputPreparationResult result; + result.ok = true; + result.feature_enabled = true; + result.error = HushChatDecryptInputError::None; + result.error_name = hushChatDecryptInputErrorName(result.error); + result.prepared.stored_chat_key_bytes = std::move(storedChatKey.bytes); + result.prepared.seed_bytes.reserve(kHushChatSeedByteLength); + for (std::size_t index = 0; index < kHushChatSeedByteLength; ++index) { + result.prepared.seed_bytes.push_back(static_cast(material.stored_chat_key_hex[index])); + } + result.prepared.peer_public_key_bytes = std::move(peerPublicKey.bytes); + result.prepared.stream_header_bytes = std::move(streamHeader.bytes); + result.prepared.ciphertext_bytes = std::move(ciphertext.bytes); + result.prepared.direction = material.direction; + result.prepared.session_key_selection = hushChatSessionKeySelectionForDirection(material.direction); + result.prepared.plaintext_capacity = result.prepared.ciphertext_bytes.size() - kHushChatSecretstreamABytes; + return result; +} + +HushChatDecryptFixtureReadinessResult inspectHushChatDecryptFixtureReadiness( + const HushChatPreparedDecryptInput& prepared) +{ + HushChatDecryptFixtureReadinessResult result; + result.stored_chat_key_size = prepared.stored_chat_key_bytes.size(); + result.seed_size = prepared.seed_bytes.size(); + result.peer_public_key_size = prepared.peer_public_key_bytes.size(); + result.stream_header_size = prepared.stream_header_bytes.size(); + result.ciphertext_size = prepared.ciphertext_bytes.size(); + result.plaintext_capacity = prepared.plaintext_capacity; + result.session_key_selection = prepared.session_key_selection; + result.ready = result.stored_chat_key_size == kHushChatStoredChatKeyByteLength && + result.seed_size == kHushChatSeedByteLength && + result.peer_public_key_size == kHushChatPublicKeyByteLength && + result.stream_header_size == kHushChatSecretstreamHeaderByteLength && + result.ciphertext_size > kHushChatSecretstreamABytes && + result.plaintext_capacity == result.ciphertext_size - kHushChatSecretstreamABytes; + return result; +} + +HushChatCompatibilityFixtureVerificationResult verifyHushChatCompatibilityFixture( + const HushChatCompatibilityFixture& fixture, + bool featureEnabled) +{ + auto failFixture = [&](HushChatCompatibilityFixtureError error, + HushChatHexDecodeError hexError = HushChatHexDecodeError::None) { + HushChatCompatibilityFixtureVerificationResult result; + result.feature_enabled = featureEnabled; + result.error = error; + result.error_name = hushChatCompatibilityFixtureErrorName(error); + result.hex_error = hexError; + return result; + }; + + if (!featureEnabled) return failFixture(HushChatCompatibilityFixtureError::FeatureDisabled); + if (fixture.fixture_id.empty()) return failFixture(HushChatCompatibilityFixtureError::MissingFixtureId); + + auto localPublicKey = decodeHushChatHexBytes(fixture.local_public_key_hex, + kHushChatPublicKeyByteLength); + if (!localPublicKey.ok) { + return failFixture(HushChatCompatibilityFixtureError::InvalidLocalPublicKey, localPublicKey.error); + } + + auto peerPublicKey = decodeHushChatHexBytes(fixture.peer_public_key_hex, + kHushChatPublicKeyByteLength); + if (!peerPublicKey.ok) { + return failFixture(HushChatCompatibilityFixtureError::InvalidPeerPublicKey, peerPublicKey.error); + } + + auto parsedHeader = parseHushChatHeaderMemo(fixture.header_memo); + if (!parsedHeader.ok) return failFixture(HushChatCompatibilityFixtureError::InvalidHeaderMemo); + + auto grouped = groupHushChatMemoOutputs({ + HushChatMemoOutput{0, fixture.header_memo}, + HushChatMemoOutput{1, fixture.ciphertext_memo} + }); + if (grouped.pairs.size() != 1 || !grouped.issues.empty()) { + return failFixture(HushChatCompatibilityFixtureError::InvalidMemoPair); + } + + const auto& header = grouped.pairs[0].header; + if (header.type != HushChatHeaderType::Message) { + return failFixture(HushChatCompatibilityFixtureError::NonMemoHeader); + } + + const std::string& expectedHeaderPublicKey = fixture.direction == HushChatDecryptDirection::Incoming + ? fixture.peer_public_key_hex + : fixture.local_public_key_hex; + if (header.public_key_hex != expectedHeaderPublicKey) { + return failFixture(HushChatCompatibilityFixtureError::HeaderPublicKeyMismatch); + } + + auto preparation = prepareHushChatDecryptInput(HushChatDecryptInputMaterial{ + fixture.stored_chat_key_hex, + header, + fixture.ciphertext_memo, + fixture.direction, + fixture.peer_public_key_hex + }, true); + + if (!preparation.ok) { + HushChatCompatibilityFixtureVerificationResult result = failFixture( + HushChatCompatibilityFixtureError::DecryptInputFailed, + preparation.hex_error); + result.decrypt_input_error = preparation.error; + result.preflight_error = preparation.preflight_error; + result.preparation = std::move(preparation); + return result; + } + + auto readiness = inspectHushChatDecryptFixtureReadiness(preparation.prepared); + if (!readiness.ready) { + HushChatCompatibilityFixtureVerificationResult result = failFixture( + HushChatCompatibilityFixtureError::NotFixtureReady); + result.preparation = std::move(preparation); + result.readiness = readiness; + return result; + } + + auto failExpectation = [&](HushChatCompatibilityFixtureError error, + HushChatDecryptInputPreparationResult&& prepared, + const HushChatDecryptFixtureReadinessResult& fixtureReadiness) { + HushChatCompatibilityFixtureVerificationResult result = failFixture(error); + result.header = header; + result.preparation = std::move(prepared); + result.readiness = fixtureReadiness; + result.local_public_key_size = localPublicKey.bytes.size(); + result.peer_public_key_size = peerPublicKey.bytes.size(); + return result; + }; + + if (readiness.stored_chat_key_size != fixture.expected_stored_chat_key_size) { + return failExpectation(HushChatCompatibilityFixtureError::ExpectedStoredChatKeyLengthMismatch, + std::move(preparation), + readiness); + } + if (readiness.seed_size != fixture.expected_seed_size) { + return failExpectation(HushChatCompatibilityFixtureError::ExpectedSeedLengthMismatch, + std::move(preparation), + readiness); + } + if (localPublicKey.bytes.size() != fixture.expected_local_public_key_size) { + return failExpectation(HushChatCompatibilityFixtureError::ExpectedLocalPublicKeyLengthMismatch, + std::move(preparation), + readiness); + } + if (readiness.peer_public_key_size != fixture.expected_peer_public_key_size) { + return failExpectation(HushChatCompatibilityFixtureError::ExpectedPeerPublicKeyLengthMismatch, + std::move(preparation), + readiness); + } + if (readiness.stream_header_size != fixture.expected_stream_header_size) { + return failExpectation(HushChatCompatibilityFixtureError::ExpectedStreamHeaderLengthMismatch, + std::move(preparation), + readiness); + } + if (readiness.ciphertext_size != fixture.expected_ciphertext_size) { + return failExpectation(HushChatCompatibilityFixtureError::ExpectedCiphertextLengthMismatch, + std::move(preparation), + readiness); + } + if (readiness.plaintext_capacity != fixture.expected_plaintext_size) { + return failExpectation(HushChatCompatibilityFixtureError::ExpectedPlaintextLengthMismatch, + std::move(preparation), + readiness); + } + if (readiness.session_key_selection != fixture.expected_session_key_selection) { + return failExpectation(HushChatCompatibilityFixtureError::ExpectedRoleMismatch, + std::move(preparation), + readiness); + } + + std::size_t plaintextHashSize = 0; + if (!fixture.expected_plaintext_hash_hex.empty()) { + if (fixture.expected_plaintext_hash_hex.size() % 2 != 0 || + !isHexString(fixture.expected_plaintext_hash_hex)) { + return failExpectation(HushChatCompatibilityFixtureError::InvalidPlaintextHash, + std::move(preparation), + readiness); + } + plaintextHashSize = fixture.expected_plaintext_hash_hex.size() / 2; + } + + HushChatCompatibilityFixtureVerificationResult result; + result.ok = true; + result.feature_enabled = true; + result.error = HushChatCompatibilityFixtureError::None; + result.error_name = hushChatCompatibilityFixtureErrorName(result.error); + result.header = header; + result.preparation = std::move(preparation); + result.readiness = readiness; + result.local_public_key_size = localPublicKey.bytes.size(); + result.peer_public_key_size = peerPublicKey.bytes.size(); + result.plaintext_hash_size = plaintextHashSize; + return result; +} + +HushChatCompatibilityFixtureFileParseResult parseHushChatCompatibilityFixtureFile( + const std::string& jsonText, + bool featureEnabled) +{ + auto failFile = [&](HushChatCompatibilityFixtureFileError error) { + HushChatCompatibilityFixtureFileParseResult result; + result.feature_enabled = featureEnabled; + result.error = error; + result.error_name = hushChatCompatibilityFixtureFileErrorName(error); + return result; + }; + + if (!featureEnabled) return failFile(HushChatCompatibilityFixtureFileError::FeatureDisabled); + + nlohmann::json object; + try { + object = nlohmann::json::parse(jsonText); + } catch (const nlohmann::json::parse_error&) { + return failFile(HushChatCompatibilityFixtureFileError::InvalidJson); + } + if (!object.is_object()) return failFile(HushChatCompatibilityFixtureFileError::JsonNotObject); + + auto schema = readJsonString(object, "schema"); + if (!schema || *schema != kHushChatCompatibilityFixtureSchema) { + return failFile(HushChatCompatibilityFixtureFileError::InvalidSchema); + } + + auto kindText = readJsonString(object, "kind"); + if (!kindText) return failFile(HushChatCompatibilityFixtureFileError::MissingKind); + auto kind = parseFixtureKind(*kindText); + if (!kind) return failFile(HushChatCompatibilityFixtureFileError::UnknownKind); + + auto statusText = readJsonString(object, "status"); + if (!statusText) return failFile(HushChatCompatibilityFixtureFileError::MissingStatus); + auto status = parseFixtureFileStatus(*statusText); + if (!status) return failFile(HushChatCompatibilityFixtureFileError::UnknownStatus); + + HushChatCompatibilityFixtureFile parsed; + parsed.schema = *schema; + parsed.kind = *kind; + parsed.status = *status; + if (auto fixtureId = readJsonString(object, "id")) parsed.fixture_id = *fixtureId; + + if (parsed.status == HushChatCompatibilityFixtureFileStatus::Pending) { + if (parsed.fixture_id.empty()) return failFile(HushChatCompatibilityFixtureFileError::MissingFixtureId); + + auto pendingReason = readJsonString(object, "pending_reason"); + if (!pendingReason || pendingReason->empty()) { + return failFile(HushChatCompatibilityFixtureFileError::MissingPendingReason); + } + parsed.pending_reason = *pendingReason; + + HushChatCompatibilityFixtureFileParseResult result; + result.ok = true; + result.feature_enabled = true; + result.pending = true; + result.error = HushChatCompatibilityFixtureFileError::None; + result.error_name = hushChatCompatibilityFixtureFileErrorName(result.error); + result.file = std::move(parsed); + return result; + } + + if (!object.contains("fixture") || !object["fixture"].is_object()) { + return failFile(HushChatCompatibilityFixtureFileError::MissingFixtureObject); + } + + const auto& fixtureObject = object["fixture"]; + const nlohmann::json expected = fixtureObject.contains("expected") ? fixtureObject["expected"] : nlohmann::json(); + if (!expected.is_object()) return failFile(HushChatCompatibilityFixtureFileError::InvalidFixtureField); + + auto readRequiredFixtureString = [&](const nlohmann::json& source, const char* key) -> std::optional { + auto value = readJsonString(source, key); + if (!value || value->empty()) return std::nullopt; + return value; + }; + + HushChatCompatibilityFixture fixture; + auto id = readRequiredFixtureString(fixtureObject, "id"); + auto storedChatKey = readRequiredFixtureString(fixtureObject, "stored_chat_key_hex"); + auto localPublicKey = readRequiredFixtureString(fixtureObject, "local_public_key_hex"); + auto peerPublicKey = readRequiredFixtureString(fixtureObject, "peer_public_key_hex"); + auto headerMemo = readRequiredFixtureString(fixtureObject, "header_memo"); + auto ciphertextMemo = readRequiredFixtureString(fixtureObject, "ciphertext_memo"); + auto directionText = readRequiredFixtureString(fixtureObject, "direction"); + auto roleText = readRequiredFixtureString(expected, "session_key_selection"); + auto storedKeySize = readJsonSize(expected, "stored_chat_key_bytes"); + auto seedSize = readJsonSize(expected, "seed_bytes"); + auto localKeySize = readJsonSize(expected, "local_public_key_bytes"); + auto peerKeySize = readJsonSize(expected, "peer_public_key_bytes"); + auto streamHeaderSize = readJsonSize(expected, "stream_header_bytes"); + auto ciphertextSize = readJsonSize(expected, "ciphertext_bytes"); + auto plaintextSize = readJsonSize(expected, "plaintext_bytes"); + if (!id || !storedChatKey || !localPublicKey || !peerPublicKey || !headerMemo || !ciphertextMemo || + !directionText || !roleText || !storedKeySize || !seedSize || !localKeySize || !peerKeySize || + !streamHeaderSize || !ciphertextSize || !plaintextSize) { + return failFile(HushChatCompatibilityFixtureFileError::InvalidFixtureField); + } + + auto direction = parseFixtureDirection(*directionText); + auto role = parseFixtureSessionKeySelection(*roleText); + if (!direction || !role) return failFile(HushChatCompatibilityFixtureFileError::InvalidFixtureField); + + fixture.fixture_id = *id; + fixture.stored_chat_key_hex = *storedChatKey; + fixture.local_public_key_hex = *localPublicKey; + fixture.peer_public_key_hex = *peerPublicKey; + fixture.header_memo = *headerMemo; + fixture.ciphertext_memo = *ciphertextMemo; + fixture.direction = *direction; + fixture.expected_session_key_selection = *role; + fixture.expected_stored_chat_key_size = *storedKeySize; + fixture.expected_seed_size = *seedSize; + fixture.expected_local_public_key_size = *localKeySize; + fixture.expected_peer_public_key_size = *peerKeySize; + fixture.expected_stream_header_size = *streamHeaderSize; + fixture.expected_ciphertext_size = *ciphertextSize; + fixture.expected_plaintext_size = *plaintextSize; + if (auto plaintextHash = readJsonString(expected, "plaintext_hash_hex")) { + fixture.expected_plaintext_hash_hex = *plaintextHash; + } + + parsed.fixture_id = fixture.fixture_id; + parsed.fixture = fixture; + + auto verification = verifyHushChatCompatibilityFixture(fixture, true); + if (parsed.kind == HushChatCompatibilityFixtureKind::ContactExclusion) { + if (verification.error != HushChatCompatibilityFixtureError::NonMemoHeader) { + HushChatCompatibilityFixtureFileParseResult result = failFile( + HushChatCompatibilityFixtureFileError::ContactFixtureNotExcluded); + result.file = std::move(parsed); + result.verification = std::move(verification); + return result; + } + + HushChatCompatibilityFixtureFileParseResult result; + result.ok = true; + result.feature_enabled = true; + result.excluded_from_decrypt = true; + result.error = HushChatCompatibilityFixtureFileError::None; + result.error_name = hushChatCompatibilityFixtureFileErrorName(result.error); + result.file = std::move(parsed); + result.verification = std::move(verification); + return result; + } + + if (!verification.ok) { + HushChatCompatibilityFixtureFileParseResult result = failFile( + HushChatCompatibilityFixtureFileError::FixtureVerificationFailed); + result.file = std::move(parsed); + result.verification = std::move(verification); + return result; + } + + HushChatCompatibilityFixtureFileParseResult result; + result.ok = true; + result.feature_enabled = true; + result.verified = true; + result.error = HushChatCompatibilityFixtureFileError::None; + result.error_name = hushChatCompatibilityFixtureFileErrorName(result.error); + result.file = std::move(parsed); + result.verification = std::move(verification); + return result; +} + +HushChatCompatibilityFixtureFileParseResult loadHushChatCompatibilityFixtureFile( + const std::string& path, + bool featureEnabled) +{ + if (!featureEnabled) { + HushChatCompatibilityFixtureFileParseResult result; + result.error = HushChatCompatibilityFixtureFileError::FeatureDisabled; + result.error_name = hushChatCompatibilityFixtureFileErrorName(result.error); + return result; + } + + std::ifstream input(path); + if (!input.good()) { + HushChatCompatibilityFixtureFileParseResult result; + result.feature_enabled = true; + result.error = HushChatCompatibilityFixtureFileError::FileReadFailed; + result.error_name = hushChatCompatibilityFixtureFileErrorName(result.error); + return result; + } + + std::ostringstream buffer; + buffer << input.rdbuf(); + return parseHushChatCompatibilityFixtureFile(buffer.str(), true); +} + +HushChatSeedPublicKeyProjectionResult verifyHushChatSeedPublicKeyProjection( + const HushChatCompatibilityFixture& fixture, + bool featureEnabled) +{ + auto failProjection = [&](HushChatSeedPublicKeyProjectionError error, + HushChatHexDecodeError hexError = HushChatHexDecodeError::None) { + HushChatSeedPublicKeyProjectionResult result; + result.feature_enabled = featureEnabled; + result.error = error; + result.error_name = hushChatSeedPublicKeyProjectionErrorName(error); + result.hex_error = hexError; + return result; + }; + + if (!featureEnabled) return failProjection(HushChatSeedPublicKeyProjectionError::FeatureDisabled); + if (fixture.fixture_id.empty()) return failProjection(HushChatSeedPublicKeyProjectionError::MissingFixtureId); + + auto storedChatKey = decodeHushChatHexBytes(fixture.stored_chat_key_hex, + kHushChatStoredChatKeyByteLength); + if (!storedChatKey.ok) { + return failProjection(HushChatSeedPublicKeyProjectionError::InvalidStoredChatKey, storedChatKey.error); + } + + auto localPublicKey = decodeHushChatHexBytes(fixture.local_public_key_hex, + kHushChatPublicKeyByteLength); + if (!localPublicKey.ok) { + return failProjection(HushChatSeedPublicKeyProjectionError::InvalidLocalPublicKey, localPublicKey.error); + } + + const std::size_t seedSize = std::min(fixture.stored_chat_key_hex.size(), kHushChatSeedByteLength); + if (storedChatKey.bytes.size() != fixture.expected_stored_chat_key_size) { + auto result = failProjection(HushChatSeedPublicKeyProjectionError::ExpectedStoredChatKeyLengthMismatch); + result.stored_chat_key_size = storedChatKey.bytes.size(); + result.seed_size = seedSize; + result.local_public_key_size = localPublicKey.bytes.size(); + return result; + } + if (seedSize != fixture.expected_seed_size) { + auto result = failProjection(HushChatSeedPublicKeyProjectionError::ExpectedSeedLengthMismatch); + result.stored_chat_key_size = storedChatKey.bytes.size(); + result.seed_size = seedSize; + result.local_public_key_size = localPublicKey.bytes.size(); + return result; + } + if (localPublicKey.bytes.size() != fixture.expected_local_public_key_size) { + auto result = failProjection(HushChatSeedPublicKeyProjectionError::ExpectedLocalPublicKeyLengthMismatch); + result.stored_chat_key_size = storedChatKey.bytes.size(); + result.seed_size = seedSize; + result.local_public_key_size = localPublicKey.bytes.size(); + return result; + } + + if (sodium_init() < 0) { + return failProjection(HushChatSeedPublicKeyProjectionError::SodiumInitializationFailed); + } + + unsigned char seed[kHushChatSeedByteLength]; + for (std::size_t index = 0; index < kHushChatSeedByteLength; ++index) { + seed[index] = static_cast(fixture.stored_chat_key_hex[index]); + } + + unsigned char projectedPublicKey[crypto_kx_PUBLICKEYBYTES]; + unsigned char projectedSecretKey[crypto_kx_SECRETKEYBYTES]; + const int projectionStatus = crypto_kx_seed_keypair(projectedPublicKey, projectedSecretKey, seed); + sodium_memzero(projectedSecretKey, sizeof(projectedSecretKey)); + sodium_memzero(seed, sizeof(seed)); + if (projectionStatus != 0) { + return failProjection(HushChatSeedPublicKeyProjectionError::KeypairProjectionFailed); + } + + HushChatSeedPublicKeyProjectionResult result; + result.feature_enabled = true; + result.stored_chat_key_size = storedChatKey.bytes.size(); + result.seed_size = seedSize; + result.local_public_key_size = localPublicKey.bytes.size(); + result.projected_public_key_size = sizeof(projectedPublicKey); + + if (result.projected_public_key_size != localPublicKey.bytes.size() || + std::memcmp(projectedPublicKey, localPublicKey.bytes.data(), localPublicKey.bytes.size()) != 0) { + sodium_memzero(projectedPublicKey, sizeof(projectedPublicKey)); + result.error = HushChatSeedPublicKeyProjectionError::ProjectedPublicKeyMismatch; + result.error_name = hushChatSeedPublicKeyProjectionErrorName(result.error); + return result; + } + + sodium_memzero(projectedPublicKey, sizeof(projectedPublicKey)); + result.ok = true; + result.error = HushChatSeedPublicKeyProjectionError::None; + result.error_name = hushChatSeedPublicKeyProjectionErrorName(result.error); + return result; +} + +HushChatCorruptedAuthFailureReadinessResult inspectHushChatCorruptedAuthFailureReadiness( + const HushChatCompatibilityFixtureFileParseResult& parsed, + const HushChatSeedPublicKeyProjectionResult& seedProjection, + bool featureEnabled) +{ + auto failReadiness = [&](HushChatCorruptedAuthFailureReadinessError error) { + HushChatCorruptedAuthFailureReadinessResult result; + result.feature_enabled = featureEnabled; + result.error = error; + result.error_name = hushChatCorruptedAuthFailureReadinessErrorName(error); + return result; + }; + + if (!featureEnabled) return failReadiness(HushChatCorruptedAuthFailureReadinessError::FeatureDisabled); + if (parsed.pending) return failReadiness(HushChatCorruptedAuthFailureReadinessError::FixturePending); + if (parsed.file.kind != HushChatCompatibilityFixtureKind::CorruptedAuthFailure) { + return failReadiness(HushChatCorruptedAuthFailureReadinessError::WrongFixtureKind); + } + if (!parsed.verified || !parsed.verification.ok) { + return failReadiness(HushChatCorruptedAuthFailureReadinessError::FixtureNotVerified); + } + if (!seedProjection.ok) { + return failReadiness(HushChatCorruptedAuthFailureReadinessError::SeedProjectionNotVerified); + } + + HushChatCorruptedAuthFailureReadinessResult result; + result.ok = true; + result.feature_enabled = true; + result.structurally_ready_for_future_auth_check = true; + result.requires_future_secretstream_auth_failure = true; + result.decrypted = false; + result.authenticated = false; + result.error = HushChatCorruptedAuthFailureReadinessError::None; + result.error_name = hushChatCorruptedAuthFailureReadinessErrorName(result.error); + return result; +} + +std::vector hushChatRequiredCompatibilityFixtureKinds() +{ + return { + HushChatCompatibilityFixtureKind::IncomingMemo, + HushChatCompatibilityFixtureKind::OutgoingMemo, + HushChatCompatibilityFixtureKind::SeedPublicKeyProjection, + HushChatCompatibilityFixtureKind::CorruptedAuthFailure, + HushChatCompatibilityFixtureKind::ContactExclusion + }; +} + +HushChatCompatibilityFixtureImportChecklistResult inspectHushChatCompatibilityFixtureImportChecklist( + const std::vector& candidates, + bool featureEnabled) +{ + HushChatCompatibilityFixtureImportChecklistResult result; + result.feature_enabled = featureEnabled; + + auto setFirstError = [&](HushChatCompatibilityFixtureImportError error) { + if (result.error == HushChatCompatibilityFixtureImportError::None) { + result.error = error; + result.error_name = hushChatCompatibilityFixtureImportErrorName(error); + } + }; + + if (!featureEnabled) { + setFirstError(HushChatCompatibilityFixtureImportError::FeatureDisabled); + return result; + } + + const auto requiredKinds = hushChatRequiredCompatibilityFixtureKinds(); + result.required_count = requiredKinds.size(); + result.items.reserve(requiredKinds.size()); + + for (const auto expectedKind : requiredKinds) { + HushChatCompatibilityFixtureImportItem item; + item.expected_kind = expectedKind; + + const HushChatCompatibilityFixtureImportCandidate* selected = nullptr; + std::size_t matchCount = 0; + for (const auto& candidate : candidates) { + if (candidate.expected_kind != expectedKind) continue; + ++matchCount; + if (!selected) selected = &candidate; + } + + if (matchCount == 0) { + item.error = HushChatCompatibilityFixtureImportError::MissingRequiredKind; + item.error_name = hushChatCompatibilityFixtureImportErrorName(item.error); + ++result.missing_count; + setFirstError(item.error); + result.items.push_back(std::move(item)); + continue; + } + + item.supplied = true; + ++result.supplied_count; + + if (matchCount > 1 || !selected) { + item.error = HushChatCompatibilityFixtureImportError::DuplicateKind; + item.error_name = hushChatCompatibilityFixtureImportErrorName(item.error); + ++result.rejected_count; + setFirstError(item.error); + result.items.push_back(std::move(item)); + continue; + } + + item.path = selected->path; + item.parsed = loadHushChatCompatibilityFixtureFile(selected->path, true); + if (!item.parsed.ok) { + if (item.parsed.error == HushChatCompatibilityFixtureFileError::FileReadFailed) { + item.error = HushChatCompatibilityFixtureImportError::FixtureLoadFailed; + } else if (item.parsed.error == HushChatCompatibilityFixtureFileError::ContactFixtureNotExcluded) { + item.error = HushChatCompatibilityFixtureImportError::ContactFixtureNotExcluded; + } else { + item.error = HushChatCompatibilityFixtureImportError::FixtureInvalid; + } + item.error_name = hushChatCompatibilityFixtureImportErrorName(item.error); + ++result.rejected_count; + setFirstError(item.error); + result.items.push_back(std::move(item)); + continue; + } + + item.loaded_kind = item.parsed.file.kind; + if (item.loaded_kind != expectedKind) { + item.error = HushChatCompatibilityFixtureImportError::FixtureKindMismatch; + item.error_name = hushChatCompatibilityFixtureImportErrorName(item.error); + ++result.rejected_count; + setFirstError(item.error); + result.items.push_back(std::move(item)); + continue; + } + + if (item.parsed.pending) { + item.pending = true; + item.error = HushChatCompatibilityFixtureImportError::FixturePending; + item.error_name = hushChatCompatibilityFixtureImportErrorName(item.error); + ++result.pending_count; + setFirstError(item.error); + result.items.push_back(std::move(item)); + continue; + } + + if (expectedKind == HushChatCompatibilityFixtureKind::ContactExclusion) { + if (!item.parsed.excluded_from_decrypt) { + item.error = HushChatCompatibilityFixtureImportError::ContactFixtureNotExcluded; + item.error_name = hushChatCompatibilityFixtureImportErrorName(item.error); + ++result.rejected_count; + setFirstError(item.error); + result.items.push_back(std::move(item)); + continue; + } + + item.replacement_eligible = true; + item.error = HushChatCompatibilityFixtureImportError::None; + item.error_name = hushChatCompatibilityFixtureImportErrorName(item.error); + ++result.excluded_count; + result.items.push_back(std::move(item)); + continue; + } + + if (!item.parsed.verified) { + item.error = HushChatCompatibilityFixtureImportError::FixtureNotVerified; + item.error_name = hushChatCompatibilityFixtureImportErrorName(item.error); + ++result.rejected_count; + setFirstError(item.error); + result.items.push_back(std::move(item)); + continue; + } + + item.seed_projection = verifyHushChatSeedPublicKeyProjection(item.parsed.file.fixture, true); + if (!item.seed_projection.ok) { + item.error = HushChatCompatibilityFixtureImportError::SeedProjectionFailed; + item.error_name = hushChatCompatibilityFixtureImportErrorName(item.error); + ++result.rejected_count; + setFirstError(item.error); + result.items.push_back(std::move(item)); + continue; + } + + if (expectedKind == HushChatCompatibilityFixtureKind::CorruptedAuthFailure) { + item.auth_failure_readiness = inspectHushChatCorruptedAuthFailureReadiness( + item.parsed, + item.seed_projection, + true); + if (!item.auth_failure_readiness.ok) { + item.error = HushChatCompatibilityFixtureImportError::AuthFailureScaffoldFailed; + item.error_name = hushChatCompatibilityFixtureImportErrorName(item.error); + ++result.rejected_count; + setFirstError(item.error); + result.items.push_back(std::move(item)); + continue; + } + + item.future_auth_failure_required = item.auth_failure_readiness.requires_future_secretstream_auth_failure; + item.structurally_ready_for_future_auth_check = + item.auth_failure_readiness.structurally_ready_for_future_auth_check; + if (item.future_auth_failure_required) ++result.future_auth_failure_required_count; + if (item.structurally_ready_for_future_auth_check) ++result.auth_failure_structural_ready_count; + } + + item.replacement_eligible = true; + item.seed_projection_verified = true; + item.error = HushChatCompatibilityFixtureImportError::None; + item.error_name = hushChatCompatibilityFixtureImportErrorName(item.error); + ++result.verified_count; + ++result.seed_projection_verified_count; + result.items.push_back(std::move(item)); + } + + result.replacement_ready = result.supplied_count == result.required_count && + result.missing_count == 0 && + result.pending_count == 0 && + result.rejected_count == 0 && + result.verified_count == result.required_count - 1 && + result.seed_projection_verified_count == result.required_count - 1 && + result.future_auth_failure_required_count == 1 && + result.auth_failure_structural_ready_count == 1 && + result.excluded_count == 1; + result.ok = result.replacement_ready; + if (result.ok) { + result.error = HushChatCompatibilityFixtureImportError::None; + result.error_name = hushChatCompatibilityFixtureImportErrorName(result.error); + } + return result; +} + +HushChatCompatibilityFixtureReplacementDryRunResult inspectHushChatCompatibilityFixtureReplacementDryRun( + const std::vector& candidates, + bool featureEnabled) +{ + const auto checklist = inspectHushChatCompatibilityFixtureImportChecklist(candidates, featureEnabled); + + HushChatCompatibilityFixtureReplacementDryRunResult result; + result.ok = checklist.replacement_ready; + result.feature_enabled = checklist.feature_enabled; + result.would_replace = checklist.replacement_ready; + result.replacement_refused = !checklist.replacement_ready; + result.error = checklist.error; + result.error_name = checklist.error_name; + result.required_count = checklist.required_count; + result.supplied_count = checklist.supplied_count; + result.missing_count = checklist.missing_count; + result.pending_count = checklist.pending_count; + result.verified_count = checklist.verified_count; + result.seed_projection_verified_count = checklist.seed_projection_verified_count; + result.future_auth_failure_required_count = checklist.future_auth_failure_required_count; + result.auth_failure_structural_ready_count = checklist.auth_failure_structural_ready_count; + result.excluded_count = checklist.excluded_count; + result.rejected_count = checklist.rejected_count; + result.report_items.reserve(checklist.items.size()); + + for (const auto& item : checklist.items) { + HushChatCompatibilityFixtureReplacementReportItem reportItem; + reportItem.expected_kind = item.expected_kind; + reportItem.loaded_kind = item.loaded_kind; + reportItem.path = item.path; + reportItem.supplied = item.supplied; + reportItem.pending = item.pending; + reportItem.replacement_eligible = item.replacement_eligible; + reportItem.refused = !item.replacement_eligible; + reportItem.seed_projection_verified = item.seed_projection_verified; + reportItem.future_auth_failure_required = item.future_auth_failure_required; + reportItem.structurally_ready_for_future_auth_check = item.structurally_ready_for_future_auth_check; + reportItem.cont_excluded = item.parsed.excluded_from_decrypt; + reportItem.decrypted = item.auth_failure_readiness.decrypted; + reportItem.authenticated = item.auth_failure_readiness.authenticated; + reportItem.error = item.error; + reportItem.error_name = item.error_name; + result.report_items.push_back(std::move(reportItem)); + } + + return result; +} + +HushChatCaptureManifestValidationResult validateHushChatCaptureManifest( + const std::string& jsonText, + bool featureEnabled) +{ + HushChatCaptureManifestValidationResult result; + result.feature_enabled = featureEnabled; + const auto requiredKinds = hushChatRequiredCompatibilityFixtureKinds(); + result.required_count = requiredKinds.size(); + result.categories.reserve(requiredKinds.size()); + for (const auto kind : requiredKinds) { + HushChatCaptureManifestCategoryReport report; + report.kind = kind; + result.categories.push_back(std::move(report)); + } + + auto failManifest = [&](HushChatCaptureManifestError error) { + result.error = error; + result.error_name = hushChatCaptureManifestErrorName(error); + return result; + }; + + if (!featureEnabled) return failManifest(HushChatCaptureManifestError::FeatureDisabled); + + nlohmann::json object; + try { + object = nlohmann::json::parse(jsonText); + } catch (const nlohmann::json::parse_error&) { + return failManifest(HushChatCaptureManifestError::InvalidJson); + } + if (!object.is_object()) return failManifest(HushChatCaptureManifestError::JsonNotObject); + + result.prohibited_field_count = countProhibitedCaptureManifestFields(object); + if (result.prohibited_field_count > 0) { + return failManifest(HushChatCaptureManifestError::ProhibitedFieldPresent); + } + + auto schema = readJsonString(object, "schema"); + if (!schema || *schema != kHushChatCaptureManifestSchema) { + return failManifest(HushChatCaptureManifestError::InvalidSchema); + } + + auto id = readJsonString(object, "id"); + if (!id || id->empty()) return failManifest(HushChatCaptureManifestError::MissingManifestId); + + auto status = readJsonString(object, "status"); + if (!status) return failManifest(HushChatCaptureManifestError::MissingStatus); + if (*status != "staged") return failManifest(HushChatCaptureManifestError::UnknownStatus); + + auto fixtureDirectory = readJsonString(object, "fixture_directory"); + if (!fixtureDirectory || fixtureDirectory->empty()) { + return failManifest(HushChatCaptureManifestError::MissingFixtureDirectory); + } + result.fixture_directory = *fixtureDirectory; + + auto dryRunCommand = readJsonString(object, "dry_run_command"); + if (!dryRunCommand || dryRunCommand->empty()) { + return failManifest(HushChatCaptureManifestError::MissingDryRunCommand); + } + result.has_dry_run_command = true; + if (dryRunCommand->find("HushChatFixtureCheck") == std::string::npos || + dryRunCommand->find("--replacement-dry-run") == std::string::npos) { + return failManifest(HushChatCaptureManifestError::InvalidDryRunCommand); + } + + auto provenance = object.find("provenance"); + if (provenance == object.end() || !provenance->is_object()) { + return failManifest(HushChatCaptureManifestError::MissingProvenance); + } + auto sourceClient = readJsonString(*provenance, "source_client"); + if (!sourceClient || sourceClient->empty()) { + return failManifest(HushChatCaptureManifestError::MissingSourceClient); + } + if (*sourceClient != "SilentDragonXLite") { + return failManifest(HushChatCaptureManifestError::InvalidSourceClient); + } + auto sourceClientVersion = readJsonString(*provenance, "source_client_version"); + if (!sourceClientVersion || sourceClientVersion->empty()) { + return failManifest(HushChatCaptureManifestError::MissingSourceClientVersion); + } + auto captureDate = readJsonString(*provenance, "capture_date"); + if (!captureDate || captureDate->empty()) return failManifest(HushChatCaptureManifestError::MissingCaptureDate); + auto network = readJsonString(*provenance, "network"); + if (!network || network->empty()) return failManifest(HushChatCaptureManifestError::MissingNetwork); + auto captureMethod = readJsonString(*provenance, "capture_method"); + if (!captureMethod || captureMethod->empty()) { + return failManifest(HushChatCaptureManifestError::MissingCaptureMethod); + } + + auto handling = object.find("handling"); + if (handling == object.end() || !handling->is_object()) { + return failManifest(HushChatCaptureManifestError::MissingHandling); + } + for (const char* flag : requiredCaptureHandlingFlags()) { + auto flagValue = handling->find(flag); + if (flagValue == handling->end()) return failManifest(HushChatCaptureManifestError::MissingHandlingFlag); + if (!flagValue->is_boolean() || !flagValue->get()) { + return failManifest(HushChatCaptureManifestError::HandlingFlagNotTrue); + } + ++result.handling_flag_count; + } + result.no_sensitive_material_declared = true; + + auto categories = object.find("categories"); + if (categories == object.end() || !categories->is_array()) { + return failManifest(HushChatCaptureManifestError::MissingCategories); + } + + auto findCategoryReport = [&](HushChatCompatibilityFixtureKind kind) -> HushChatCaptureManifestCategoryReport* { + for (auto& report : result.categories) { + if (report.kind == kind) return &report; + } + return nullptr; + }; + + for (const auto& category : *categories) { + if (!category.is_object()) return failManifest(HushChatCaptureManifestError::InvalidCategoryEntry); + + auto kindText = readJsonString(category, "kind"); + auto stagedFilename = readJsonString(category, "staged_filename"); + auto categoryStatus = readJsonString(category, "status"); + if (!kindText || kindText->empty() || !stagedFilename || stagedFilename->empty() || + !categoryStatus || *categoryStatus != "ready") { + return failManifest(HushChatCaptureManifestError::InvalidCategoryEntry); + } + + auto kind = parseFixtureKind(*kindText); + if (!kind) return failManifest(HushChatCaptureManifestError::UnknownCategory); + + auto* report = findCategoryReport(*kind); + if (!report) return failManifest(HushChatCaptureManifestError::UnknownCategory); + if (report->declared) { + ++result.duplicate_count; + return failManifest(HushChatCaptureManifestError::DuplicateCategory); + } + + report->declared = true; + report->staged_filename = *stagedFilename; + ++result.declared_count; + } + + for (const auto& report : result.categories) { + if (!report.declared) ++result.missing_count; + } + if (result.missing_count > 0) return failManifest(HushChatCaptureManifestError::MissingRequiredCategory); + + result.ok = true; + result.error = HushChatCaptureManifestError::None; + result.error_name = hushChatCaptureManifestErrorName(result.error); + return result; +} + +HushChatCaptureManifestValidationResult loadHushChatCaptureManifestFile( + const std::string& path, + bool featureEnabled) +{ + if (!featureEnabled) { + HushChatCaptureManifestValidationResult result; + result.error = HushChatCaptureManifestError::FeatureDisabled; + result.error_name = hushChatCaptureManifestErrorName(result.error); + return result; + } + + std::ifstream input(path); + if (!input.good()) { + HushChatCaptureManifestValidationResult result; + result.feature_enabled = true; + result.manifest_path = path; + result.error = HushChatCaptureManifestError::FileReadFailed; + result.error_name = hushChatCaptureManifestErrorName(result.error); + return result; + } + + std::ostringstream buffer; + buffer << input.rdbuf(); + auto result = validateHushChatCaptureManifest(buffer.str(), true); + result.manifest_path = path; + return result; +} + +} // namespace dragonx::chat \ No newline at end of file diff --git a/src/chat/chat_protocol.h b/src/chat/chat_protocol.h new file mode 100644 index 0000000..e15dd93 --- /dev/null +++ b/src/chat/chat_protocol.h @@ -0,0 +1,586 @@ +#pragma once + +#include +#include +#include + +#ifndef DRAGONX_ENABLE_CHAT +#define DRAGONX_ENABLE_CHAT 0 +#endif + +namespace dragonx::chat { + +enum class HushChatHeaderType { + Message, + ContactRequest +}; + +struct HushChatHeader { + int header_number = 0; + int version = 0; + std::string reply_zaddr; + std::string conversation_id; + HushChatHeaderType type = HushChatHeaderType::Message; + std::string secretstream_header_hex; + std::string public_key_hex; +}; + +struct HushChatHeaderParseResult { + bool ok = false; + HushChatHeader header; + std::string error; +}; + +struct HushChatMemoOutput { + std::size_t position = 0; + std::string memo; +}; + +struct HushChatMemoPair { + HushChatHeader header; + std::size_t header_position = 0; + std::size_t payload_position = 0; + std::string payload_memo; +}; + +enum class HushChatMemoGroupingIssue { + InvalidHeader, + MissingPayload, + DuplicateHeader, + OversizedMemo +}; + +struct HushChatMemoGroupingIssueInfo { + HushChatMemoGroupingIssue issue = HushChatMemoGroupingIssue::InvalidHeader; + std::size_t position = 0; + std::string detail; +}; + +struct HushChatMemoGroupingResult { + std::vector pairs; + std::vector issues; + std::size_t ignored_memo_count = 0; +}; + +struct HushChatTransactionInput { + std::string txid; + std::vector outputs; +}; + +struct HushChatTransactionMetadata { + std::string txid; + HushChatHeaderType type = HushChatHeaderType::Message; + std::string conversation_id; + std::string reply_zaddr; + std::size_t header_position = 0; + std::size_t payload_position = 0; + std::size_t payload_size = 0; +}; + +struct HushChatTransactionExtractionResult { + bool feature_enabled = false; + std::vector metadata; + std::vector issues; + std::size_t ignored_memo_count = 0; +}; + +enum class HushChatDecryptPreflightError { + None, + FeatureDisabled, + NonMessageHeader, + InvalidHeaderNumber, + UnsupportedVersion, + MissingReplyAddress, + MissingConversationId, + InvalidSecretstreamHeader, + InvalidPublicKey, + EmptyCiphertext, + OversizedCiphertext, + OddLengthCiphertext, + InvalidCiphertextHex, + TruncatedCiphertext +}; + +struct HushChatDecryptPreflightInput { + HushChatHeader header; + std::string ciphertext_hex; +}; + +struct HushChatDecryptPreflightResult { + bool ok = false; + bool feature_enabled = false; + HushChatDecryptPreflightError error = HushChatDecryptPreflightError::None; + const char* error_name = "None"; + std::size_t ciphertext_size = 0; +}; + +enum class HushChatHexDecodeError { + None, + Empty, + OddLength, + InvalidHex, + UnexpectedByteLength +}; + +struct HushChatHexDecodeResult { + bool ok = false; + HushChatHexDecodeError error = HushChatHexDecodeError::None; + const char* error_name = "None"; + std::vector bytes; +}; + +enum class HushChatDecryptDirection { + Incoming, + Outgoing +}; + +enum class HushChatSessionKeySelection { + ClientRx, + ServerTx +}; + +enum class HushChatDecryptInputError { + None, + FeatureDisabled, + InvalidStoredChatKey, + DecryptPreflightFailed, + InvalidPeerPublicKey, + InvalidStreamHeader, + InvalidCiphertext +}; + +struct HushChatDecryptInputMaterial { + std::string stored_chat_key_hex; + HushChatHeader header; + std::string ciphertext_hex; + HushChatDecryptDirection direction = HushChatDecryptDirection::Incoming; + std::string peer_public_key_hex; +}; + +struct HushChatPreparedDecryptInput { + std::vector stored_chat_key_bytes; + std::vector seed_bytes; + std::vector peer_public_key_bytes; + std::vector stream_header_bytes; + std::vector ciphertext_bytes; + HushChatDecryptDirection direction = HushChatDecryptDirection::Incoming; + HushChatSessionKeySelection session_key_selection = HushChatSessionKeySelection::ClientRx; + std::size_t plaintext_capacity = 0; +}; + +struct HushChatDecryptInputPreparationResult { + bool ok = false; + bool feature_enabled = false; + HushChatDecryptInputError error = HushChatDecryptInputError::None; + const char* error_name = "None"; + HushChatHexDecodeError hex_error = HushChatHexDecodeError::None; + HushChatDecryptPreflightError preflight_error = HushChatDecryptPreflightError::None; + HushChatPreparedDecryptInput prepared; +}; + +struct HushChatDecryptFixtureReadinessResult { + bool ready = false; + std::size_t stored_chat_key_size = 0; + std::size_t seed_size = 0; + std::size_t peer_public_key_size = 0; + std::size_t stream_header_size = 0; + std::size_t ciphertext_size = 0; + std::size_t plaintext_capacity = 0; + HushChatSessionKeySelection session_key_selection = HushChatSessionKeySelection::ClientRx; +}; + +enum class HushChatCompatibilityFixtureError { + None, + FeatureDisabled, + MissingFixtureId, + InvalidLocalPublicKey, + InvalidPeerPublicKey, + InvalidHeaderMemo, + InvalidMemoPair, + NonMemoHeader, + HeaderPublicKeyMismatch, + DecryptInputFailed, + NotFixtureReady, + ExpectedStoredChatKeyLengthMismatch, + ExpectedSeedLengthMismatch, + ExpectedLocalPublicKeyLengthMismatch, + ExpectedPeerPublicKeyLengthMismatch, + ExpectedStreamHeaderLengthMismatch, + ExpectedCiphertextLengthMismatch, + ExpectedPlaintextLengthMismatch, + ExpectedRoleMismatch, + InvalidPlaintextHash +}; + +struct HushChatCompatibilityFixture { + std::string fixture_id; + std::string stored_chat_key_hex; + std::string local_public_key_hex; + std::string peer_public_key_hex; + std::string header_memo; + std::string ciphertext_memo; + HushChatDecryptDirection direction = HushChatDecryptDirection::Incoming; + HushChatSessionKeySelection expected_session_key_selection = HushChatSessionKeySelection::ClientRx; + std::size_t expected_stored_chat_key_size = 32; + std::size_t expected_seed_size = 32; + std::size_t expected_local_public_key_size = 32; + std::size_t expected_peer_public_key_size = 32; + std::size_t expected_stream_header_size = 24; + std::size_t expected_ciphertext_size = 0; + std::size_t expected_plaintext_size = 0; + std::string expected_plaintext_hash_hex; +}; + +struct HushChatCompatibilityFixtureVerificationResult { + bool ok = false; + bool feature_enabled = false; + HushChatCompatibilityFixtureError error = HushChatCompatibilityFixtureError::None; + const char* error_name = "None"; + HushChatHexDecodeError hex_error = HushChatHexDecodeError::None; + HushChatDecryptInputError decrypt_input_error = HushChatDecryptInputError::None; + HushChatDecryptPreflightError preflight_error = HushChatDecryptPreflightError::None; + HushChatHeader header; + HushChatDecryptInputPreparationResult preparation; + HushChatDecryptFixtureReadinessResult readiness; + std::size_t local_public_key_size = 0; + std::size_t peer_public_key_size = 0; + std::size_t plaintext_hash_size = 0; +}; + +enum class HushChatCompatibilityFixtureKind { + IncomingMemo, + OutgoingMemo, + SeedPublicKeyProjection, + CorruptedAuthFailure, + ContactExclusion +}; + +enum class HushChatCompatibilityFixtureFileStatus { + Pending, + Ready +}; + +enum class HushChatCompatibilityFixtureFileError { + None, + FeatureDisabled, + InvalidJson, + JsonNotObject, + InvalidSchema, + MissingKind, + UnknownKind, + MissingStatus, + UnknownStatus, + MissingFixtureId, + MissingPendingReason, + MissingFixtureObject, + InvalidFixtureField, + FixtureVerificationFailed, + ContactFixtureNotExcluded, + FileReadFailed +}; + +struct HushChatCompatibilityFixtureFile { + std::string schema; + HushChatCompatibilityFixtureKind kind = HushChatCompatibilityFixtureKind::IncomingMemo; + HushChatCompatibilityFixtureFileStatus status = HushChatCompatibilityFixtureFileStatus::Pending; + std::string fixture_id; + std::string pending_reason; + HushChatCompatibilityFixture fixture; +}; + +struct HushChatCompatibilityFixtureFileParseResult { + bool ok = false; + bool feature_enabled = false; + bool pending = false; + bool verified = false; + bool excluded_from_decrypt = false; + HushChatCompatibilityFixtureFileError error = HushChatCompatibilityFixtureFileError::None; + const char* error_name = "None"; + HushChatCompatibilityFixtureFile file; + HushChatCompatibilityFixtureVerificationResult verification; +}; + +enum class HushChatSeedPublicKeyProjectionError { + None, + FeatureDisabled, + MissingFixtureId, + InvalidStoredChatKey, + InvalidLocalPublicKey, + ExpectedStoredChatKeyLengthMismatch, + ExpectedSeedLengthMismatch, + ExpectedLocalPublicKeyLengthMismatch, + SodiumInitializationFailed, + KeypairProjectionFailed, + ProjectedPublicKeyMismatch +}; + +struct HushChatSeedPublicKeyProjectionResult { + bool ok = false; + bool feature_enabled = false; + HushChatSeedPublicKeyProjectionError error = HushChatSeedPublicKeyProjectionError::None; + const char* error_name = "None"; + HushChatHexDecodeError hex_error = HushChatHexDecodeError::None; + std::size_t stored_chat_key_size = 0; + std::size_t seed_size = 0; + std::size_t local_public_key_size = 0; + std::size_t projected_public_key_size = 0; +}; + +enum class HushChatCorruptedAuthFailureReadinessError { + None, + FeatureDisabled, + FixturePending, + WrongFixtureKind, + FixtureNotVerified, + SeedProjectionNotVerified +}; + +struct HushChatCorruptedAuthFailureReadinessResult { + bool ok = false; + bool feature_enabled = false; + bool structurally_ready_for_future_auth_check = false; + bool requires_future_secretstream_auth_failure = false; + bool decrypted = false; + bool authenticated = false; + HushChatCorruptedAuthFailureReadinessError error = HushChatCorruptedAuthFailureReadinessError::None; + const char* error_name = "None"; +}; + +enum class HushChatCompatibilityFixtureImportError { + None, + FeatureDisabled, + MissingRequiredKind, + DuplicateKind, + FixtureLoadFailed, + FixtureKindMismatch, + FixturePending, + FixtureInvalid, + FixtureNotVerified, + SeedProjectionFailed, + AuthFailureScaffoldFailed, + ContactFixtureNotExcluded +}; + +struct HushChatCompatibilityFixtureImportCandidate { + HushChatCompatibilityFixtureKind expected_kind = HushChatCompatibilityFixtureKind::IncomingMemo; + std::string path; +}; + +struct HushChatCompatibilityFixtureImportItem { + HushChatCompatibilityFixtureKind expected_kind = HushChatCompatibilityFixtureKind::IncomingMemo; + HushChatCompatibilityFixtureKind loaded_kind = HushChatCompatibilityFixtureKind::IncomingMemo; + std::string path; + bool supplied = false; + bool pending = false; + bool replacement_eligible = false; + bool seed_projection_verified = false; + bool future_auth_failure_required = false; + bool structurally_ready_for_future_auth_check = false; + HushChatCompatibilityFixtureImportError error = HushChatCompatibilityFixtureImportError::None; + const char* error_name = "None"; + HushChatCompatibilityFixtureFileParseResult parsed; + HushChatSeedPublicKeyProjectionResult seed_projection; + HushChatCorruptedAuthFailureReadinessResult auth_failure_readiness; +}; + +struct HushChatCompatibilityFixtureImportChecklistResult { + bool ok = false; + bool feature_enabled = false; + bool replacement_ready = false; + HushChatCompatibilityFixtureImportError error = HushChatCompatibilityFixtureImportError::None; + const char* error_name = "None"; + std::size_t required_count = 0; + std::size_t supplied_count = 0; + std::size_t missing_count = 0; + std::size_t pending_count = 0; + std::size_t verified_count = 0; + std::size_t seed_projection_verified_count = 0; + std::size_t future_auth_failure_required_count = 0; + std::size_t auth_failure_structural_ready_count = 0; + std::size_t excluded_count = 0; + std::size_t rejected_count = 0; + std::vector items; +}; + +struct HushChatCompatibilityFixtureReplacementReportItem { + HushChatCompatibilityFixtureKind expected_kind = HushChatCompatibilityFixtureKind::IncomingMemo; + HushChatCompatibilityFixtureKind loaded_kind = HushChatCompatibilityFixtureKind::IncomingMemo; + std::string path; + bool supplied = false; + bool pending = false; + bool replacement_eligible = false; + bool refused = true; + bool seed_projection_verified = false; + bool future_auth_failure_required = false; + bool structurally_ready_for_future_auth_check = false; + bool cont_excluded = false; + bool decrypted = false; + bool authenticated = false; + HushChatCompatibilityFixtureImportError error = HushChatCompatibilityFixtureImportError::None; + const char* error_name = "None"; +}; + +struct HushChatCompatibilityFixtureReplacementDryRunResult { + bool ok = false; + bool feature_enabled = false; + bool dry_run_only = true; + bool redacted_report = true; + bool would_replace = false; + bool replacement_refused = true; + HushChatCompatibilityFixtureImportError error = HushChatCompatibilityFixtureImportError::None; + const char* error_name = "None"; + std::size_t required_count = 0; + std::size_t supplied_count = 0; + std::size_t missing_count = 0; + std::size_t pending_count = 0; + std::size_t verified_count = 0; + std::size_t seed_projection_verified_count = 0; + std::size_t future_auth_failure_required_count = 0; + std::size_t auth_failure_structural_ready_count = 0; + std::size_t excluded_count = 0; + std::size_t rejected_count = 0; + std::vector report_items; +}; + +enum class HushChatCaptureManifestError { + None, + FeatureDisabled, + FileReadFailed, + InvalidJson, + JsonNotObject, + InvalidSchema, + MissingManifestId, + MissingStatus, + UnknownStatus, + MissingFixtureDirectory, + MissingDryRunCommand, + InvalidDryRunCommand, + MissingProvenance, + MissingSourceClient, + InvalidSourceClient, + MissingSourceClientVersion, + MissingCaptureDate, + MissingNetwork, + MissingCaptureMethod, + MissingHandling, + MissingHandlingFlag, + HandlingFlagNotTrue, + MissingCategories, + InvalidCategoryEntry, + UnknownCategory, + DuplicateCategory, + MissingRequiredCategory, + ProhibitedFieldPresent +}; + +enum class HushChatCaptureManifestStatus { + Staged +}; + +struct HushChatCaptureManifestCategoryReport { + HushChatCompatibilityFixtureKind kind = HushChatCompatibilityFixtureKind::IncomingMemo; + std::string staged_filename; + bool declared = false; +}; + +struct HushChatCaptureManifestValidationResult { + bool ok = false; + bool feature_enabled = false; + bool redacted_report = true; + bool validates_provenance_only = true; + bool no_sensitive_material_declared = false; + bool has_dry_run_command = false; + HushChatCaptureManifestError error = HushChatCaptureManifestError::None; + const char* error_name = "None"; + HushChatCaptureManifestStatus status = HushChatCaptureManifestStatus::Staged; + std::string manifest_path; + std::string fixture_directory; + std::size_t required_count = 0; + std::size_t declared_count = 0; + std::size_t missing_count = 0; + std::size_t duplicate_count = 0; + std::size_t prohibited_field_count = 0; + std::size_t handling_flag_count = 0; + std::vector categories; +}; + +constexpr int kHushChatSupportedVersion = 0; +constexpr std::size_t kHushChatMemoByteLimit = 512; +constexpr std::size_t kHushChatPublicKeyHexLength = 64; +constexpr std::size_t kHushChatSecretstreamHeaderHexLength = 48; +constexpr std::size_t kHushChatSecretstreamABytes = 17; +constexpr std::size_t kHushChatStoredChatKeyByteLength = 32; +constexpr std::size_t kHushChatStoredChatKeyHexLength = kHushChatStoredChatKeyByteLength * 2; +constexpr std::size_t kHushChatSeedByteLength = 32; +constexpr std::size_t kHushChatPublicKeyByteLength = kHushChatPublicKeyHexLength / 2; +constexpr std::size_t kHushChatSecretstreamHeaderByteLength = kHushChatSecretstreamHeaderHexLength / 2; +constexpr const char* kHushChatCompatibilityFixtureSchema = "dragonx.hushchat.compat-fixture.v1"; +constexpr const char* kHushChatCaptureManifestSchema = "dragonx.hushchat.capture-manifest.v1"; + +constexpr bool hushChatFeatureEnabledAtBuild() +{ + return DRAGONX_ENABLE_CHAT != 0; +} + +HushChatHeaderParseResult parseHushChatHeaderMemo(const std::string& memo); +HushChatMemoGroupingResult groupHushChatMemoOutputs(const std::vector& outputs); +HushChatTransactionExtractionResult extractHushChatTransactionMetadata( + const HushChatTransactionInput& transaction, + bool featureEnabled = hushChatFeatureEnabledAtBuild()); +HushChatDecryptPreflightResult validateHushChatMemoDecryptPreflight( + const HushChatDecryptPreflightInput& input, + bool featureEnabled = hushChatFeatureEnabledAtBuild()); +HushChatHexDecodeResult decodeHushChatHexBytes(const std::string& hex, + std::size_t expectedByteLength); +HushChatDecryptInputPreparationResult prepareHushChatDecryptInput( + const HushChatDecryptInputMaterial& material, + bool featureEnabled = hushChatFeatureEnabledAtBuild()); +HushChatDecryptFixtureReadinessResult inspectHushChatDecryptFixtureReadiness( + const HushChatPreparedDecryptInput& prepared); +HushChatSessionKeySelection hushChatSessionKeySelectionForDirection(HushChatDecryptDirection direction); +HushChatCompatibilityFixtureVerificationResult verifyHushChatCompatibilityFixture( + const HushChatCompatibilityFixture& fixture, + bool featureEnabled = hushChatFeatureEnabledAtBuild()); +HushChatCompatibilityFixtureFileParseResult parseHushChatCompatibilityFixtureFile( + const std::string& jsonText, + bool featureEnabled = hushChatFeatureEnabledAtBuild()); +HushChatCompatibilityFixtureFileParseResult loadHushChatCompatibilityFixtureFile( + const std::string& path, + bool featureEnabled = hushChatFeatureEnabledAtBuild()); +HushChatSeedPublicKeyProjectionResult verifyHushChatSeedPublicKeyProjection( + const HushChatCompatibilityFixture& fixture, + bool featureEnabled = hushChatFeatureEnabledAtBuild()); +HushChatCorruptedAuthFailureReadinessResult inspectHushChatCorruptedAuthFailureReadiness( + const HushChatCompatibilityFixtureFileParseResult& parsed, + const HushChatSeedPublicKeyProjectionResult& seedProjection, + bool featureEnabled = hushChatFeatureEnabledAtBuild()); +std::vector hushChatRequiredCompatibilityFixtureKinds(); +HushChatCompatibilityFixtureImportChecklistResult inspectHushChatCompatibilityFixtureImportChecklist( + const std::vector& candidates, + bool featureEnabled = hushChatFeatureEnabledAtBuild()); +HushChatCompatibilityFixtureReplacementDryRunResult inspectHushChatCompatibilityFixtureReplacementDryRun( + const std::vector& candidates, + bool featureEnabled = hushChatFeatureEnabledAtBuild()); +HushChatCaptureManifestValidationResult validateHushChatCaptureManifest( + const std::string& jsonText, + bool featureEnabled = hushChatFeatureEnabledAtBuild()); +HushChatCaptureManifestValidationResult loadHushChatCaptureManifestFile( + const std::string& path, + bool featureEnabled = hushChatFeatureEnabledAtBuild()); +const char* hushChatHeaderTypeName(HushChatHeaderType type); +const char* hushChatMemoGroupingIssueName(HushChatMemoGroupingIssue issue); +const char* hushChatDecryptPreflightErrorName(HushChatDecryptPreflightError error); +const char* hushChatHexDecodeErrorName(HushChatHexDecodeError error); +const char* hushChatDecryptDirectionName(HushChatDecryptDirection direction); +const char* hushChatSessionKeySelectionName(HushChatSessionKeySelection selection); +const char* hushChatDecryptInputErrorName(HushChatDecryptInputError error); +const char* hushChatCompatibilityFixtureErrorName(HushChatCompatibilityFixtureError error); +const char* hushChatCompatibilityFixtureKindName(HushChatCompatibilityFixtureKind kind); +const char* hushChatCompatibilityFixtureFileStatusName(HushChatCompatibilityFixtureFileStatus status); +const char* hushChatCompatibilityFixtureFileErrorName(HushChatCompatibilityFixtureFileError error); +const char* hushChatSeedPublicKeyProjectionErrorName(HushChatSeedPublicKeyProjectionError error); +const char* hushChatCorruptedAuthFailureReadinessErrorName(HushChatCorruptedAuthFailureReadinessError error); +const char* hushChatCompatibilityFixtureImportErrorName(HushChatCompatibilityFixtureImportError error); +const char* hushChatCaptureManifestErrorName(HushChatCaptureManifestError error); + +} // namespace dragonx::chat \ No newline at end of file diff --git a/src/config/version.h b/src/config/version.h index c1d5512..524c38f 100644 --- a/src/config/version.h +++ b/src/config/version.h @@ -1,31 +1,3 @@ -// DragonX Wallet - ImGui Edition -// Copyright 2024-2026 The Hush Developers -// Released under the GPLv3 - #pragma once -// !! DO NOT EDIT version.h — it is generated from version.h.in by CMake. -// !! Change the version in CMakeLists.txt: project(... VERSION x.y.z ...) - -#define DRAGONX_VERSION "1.2.0-rc1" -#define DRAGONX_VERSION_MAJOR 1 -#define DRAGONX_VERSION_MINOR 2 -#define DRAGONX_VERSION_PATCH 0 - -#define DRAGONX_APP_NAME "ObsidianDragonLite" -#define DRAGONX_ORG_NAME "Hush" - -// Default RPC settings -#define DRAGONX_DEFAULT_RPC_HOST "127.0.0.1" -#define DRAGONX_DEFAULT_RPC_PORT "21769" - -// Coin parameters -#define DRAGONX_TICKER "DRGX" -#define DRAGONX_COIN_NAME "DragonX" -#define DRAGONX_URI_SCHEME "drgx" -#define DRAGONX_ZATOSHI_PER_COIN 100000000 -#define DRAGONX_DEFAULT_FEE 0.0001 - -// Config file names -#define DRAGONX_CONF_FILENAME "DRAGONX.conf" -#define DRAGONX_WALLET_FILENAME "wallet.dat" +#include "dragonx_generated_version.h" diff --git a/src/config/version.h.in b/src/config/version.h.in index c6a2097..87d46ec 100644 --- a/src/config/version.h.in +++ b/src/config/version.h.in @@ -4,7 +4,7 @@ #pragma once -// !! DO NOT EDIT version.h — it is generated from version.h.in by CMake. +// !! DO NOT EDIT generated version output — it is generated from version.h.in by CMake. // !! Change the version in CMakeLists.txt: project(... VERSION x.y.z ...) #define DRAGONX_VERSION "@PROJECT_VERSION@@DRAGONX_VERSION_SUFFIX@" diff --git a/src/services/network_refresh_service.cpp b/src/services/network_refresh_service.cpp index da8806a..2d243a0 100644 --- a/src/services/network_refresh_service.cpp +++ b/src/services/network_refresh_service.cpp @@ -6,6 +6,7 @@ #include #include #include +#include using json = nlohmann::json; @@ -136,6 +137,60 @@ void appendMissingPreviousTransactions(std::vector& transaction } } +using HushChatMemoOutputMap = std::unordered_map>; + +std::size_t readMemoPosition(const json& source, std::size_t fallback) +{ + for (const char* key : {"position", "outputIndex", "outindex"}) { + auto value = readOptional(source, key); + if (value && *value >= 0) return static_cast(*value); + } + return fallback; +} + +void recordHushChatMemoOutput(HushChatMemoOutputMap* outputs, + const std::string& txid, + const std::string& memo, + std::size_t position) +{ + if (!outputs || txid.empty() || memo.empty()) return; + (*outputs)[txid].push_back(chat::HushChatMemoOutput{position, memo}); +} + +void appendExtractedHushChatMetadata(std::vector& destination, + const std::string& txid, + const std::vector& outputs) +{ + auto extracted = chat::extractHushChatTransactionMetadata(chat::HushChatTransactionInput{txid, outputs}); + for (auto& metadata : extracted.metadata) { + destination.push_back(std::move(metadata)); + } +} + +void appendExtractedHushChatMetadata(std::vector& destination, + const std::string& txid, + const NetworkRefreshService::TransactionViewCacheEntry& entry) +{ + if (!chat::hushChatFeatureEnabledAtBuild()) return; + + std::vector outputs; + outputs.reserve(entry.outgoing_outputs.size()); + for (const auto& output : entry.outgoing_outputs) { + if (!output.memo.empty()) outputs.push_back(chat::HushChatMemoOutput{output.position, output.memo}); + } + appendExtractedHushChatMetadata(destination, txid, outputs); +} + +void appendExtractedHushChatMetadata(std::vector& destination, + const HushChatMemoOutputMap& outputsByTxid) +{ + if (!chat::hushChatFeatureEnabledAtBuild()) return; + + for (const auto& [txid, outputs] : outputsByTxid) { + appendExtractedHushChatMetadata(destination, txid, outputs); + } +} + } // namespace NetworkRefreshService::ConnectionInfoResult NetworkRefreshService::parseConnectionInfoResult(const json& info) @@ -614,17 +669,23 @@ void NetworkRefreshService::appendShieldedReceivedTransactions(std::vector& knownTxids, const std::string& address, const json& received, - const std::set& miningAddresses) + const std::set& miningAddresses, + HushChatMemoOutputMap* chatMemoOutputs) { if (received.is_null() || !received.is_array()) return; + std::size_t fallbackPosition = 0; for (const auto& note : received) { + const std::size_t notePosition = readMemoPosition(note, fallbackPosition++); auto txid = readOptional(note, "txid"); if (!txid || txid->empty()) continue; auto change = readOptional(note, "change"); if (change && *change) continue; + auto memoValue = readOptional(note, "memoStr"); + if (memoValue) recordHushChatMemoOutput(chatMemoOutputs, *txid, *memoValue, notePosition); + bool dominated = false; for (const auto& existing : transactions) { if (existing.txid == *txid && existing.type == "receive") { @@ -641,7 +702,7 @@ void NetworkRefreshService::appendShieldedReceivedTransactions(std::vector(note, "amount")) info.amount = *value; if (auto value = readOptional(note, "confirmations")) info.confirmations = *value; if (auto value = readOptional(note, "time")) info.timestamp = *value; - if (auto value = readOptional(note, "memoStr")) info.memo = *value; + if (memoValue) info.memo = *memoValue; knownTxids.insert(*txid); transactions.push_back(std::move(info)); } @@ -663,7 +724,9 @@ NetworkRefreshService::TransactionViewCacheEntry NetworkRefreshService::parseVie } if (viewTransaction.contains("outputs") && viewTransaction["outputs"].is_array()) { + std::size_t fallbackPosition = 0; for (const auto& output : viewTransaction["outputs"]) { + const std::size_t outputPosition = readMemoPosition(output, fallbackPosition++); bool outgoing = false; if (auto value = readOptional(output, "outgoing")) outgoing = *value; if (!outgoing) continue; @@ -672,6 +735,7 @@ NetworkRefreshService::TransactionViewCacheEntry NetworkRefreshService::parseVie if (auto value = readOptional(output, "address")) out.address = *value; if (auto value = readOptional(output, "value")) out.value = *value; if (auto value = readOptional(output, "memoStr")) out.memo = *value; + out.position = outputPosition; entry.outgoing_outputs.push_back(std::move(out)); } } @@ -738,6 +802,10 @@ NetworkRefreshService::TransactionRefreshResult NetworkRefreshService::collectTr result.shieldedScanHeights = snapshot.shieldedScanHeights; std::set knownTxids; + HushChatMemoOutputMap hushChatReceivedOutputs; + HushChatMemoOutputMap* hushChatReceivedOutputsPtr = chat::hushChatFeatureEnabledAtBuild() + ? &hushChatReceivedOutputs + : nullptr; bool transactionRpcError = false; try { @@ -779,7 +847,12 @@ NetworkRefreshService::TransactionRefreshResult NetworkRefreshService::collectTr nextSearchIndex = index + 1; try { json received = rpc.call("z_listreceivedbyaddress", json::array({address, 0})); - appendShieldedReceivedTransactions(result.transactions, knownTxids, address, received, snapshot.miningAddresses); + appendShieldedReceivedTransactions(result.transactions, + knownTxids, + address, + received, + snapshot.miningAddresses, + hushChatReceivedOutputsPtr); if (currentBlockHeight >= 0) result.shieldedScanHeights[address] = currentBlockHeight; } catch (const std::exception& e) { transactionRpcError = true; @@ -817,6 +890,7 @@ NetworkRefreshService::TransactionRefreshResult NetworkRefreshService::collectTr if (cached != snapshot.viewTxCache.end()) { if (!trackedSend || !cached->second.outgoing_outputs.empty()) { appendViewTransactionOutputs(result.transactions, txid, cached->second); + appendExtractedHushChatMetadata(result.hushChatMetadata, txid, cached->second); continue; } } @@ -841,6 +915,7 @@ NetworkRefreshService::TransactionRefreshResult NetworkRefreshService::collectTr auto entry = parseViewTransactionCacheEntry(viewTransaction); appendViewTransactionOutputs(result.transactions, txid, entry); + appendExtractedHushChatMetadata(result.hushChatMetadata, txid, entry); json rawTransaction; bool hasRawTransaction = false; @@ -885,6 +960,8 @@ NetworkRefreshService::TransactionRefreshResult NetworkRefreshService::collectTr } } + appendExtractedHushChatMetadata(result.hushChatMetadata, hushChatReceivedOutputs); + if (!snapshot.previousTransactions.empty()) { if (transactionRpcError) { appendMissingPreviousTransactions(result.transactions, snapshot.previousTransactions, true, snapshot.pendingOpids); @@ -909,6 +986,10 @@ NetworkRefreshService::TransactionRefreshResult NetworkRefreshService::collectRe result.transactions = snapshot.previousTransactions; result.shieldedAddressCount = snapshot.shieldedAddresses.size(); result.shieldedScanHeights = snapshot.shieldedScanHeights; + HushChatMemoOutputMap hushChatReceivedOutputs; + HushChatMemoOutputMap* hushChatReceivedOutputsPtr = chat::hushChatFeatureEnabledAtBuild() + ? &hushChatReceivedOutputs + : nullptr; try { std::set recentTxids; @@ -944,7 +1025,12 @@ NetworkRefreshService::TransactionRefreshResult NetworkRefreshService::collectRe std::vector scannedTransactions; std::set scannedTxids; json received = rpc.call("z_listreceivedbyaddress", json::array({address, 0})); - appendShieldedReceivedTransactions(scannedTransactions, scannedTxids, address, received, snapshot.miningAddresses); + appendShieldedReceivedTransactions(scannedTransactions, + scannedTxids, + address, + received, + snapshot.miningAddresses, + hushChatReceivedOutputsPtr); for (auto& scanned : scannedTransactions) { bool replaced = false; for (auto& existing : result.transactions) { @@ -967,6 +1053,8 @@ NetworkRefreshService::TransactionRefreshResult NetworkRefreshService::collectRe (shieldedStart + shieldedLimit >= snapshot.shieldedAddresses.size()) ? 0 : shieldedStart + shieldedLimit; result.shieldedScanComplete = true; + appendExtractedHushChatMetadata(result.hushChatMetadata, hushChatReceivedOutputs); + sortTransactionsNewestFirst(result.transactions); return result; } diff --git a/src/services/network_refresh_service.h b/src/services/network_refresh_service.h index 38d7337..a8f57ff 100644 --- a/src/services/network_refresh_service.h +++ b/src/services/network_refresh_service.h @@ -1,5 +1,6 @@ #pragma once +#include "chat/chat_protocol.h" #include "data/wallet_state.h" #include "refresh_scheduler.h" #include "rpc/rpc_worker.h" @@ -159,6 +160,7 @@ public: std::string address; double value = 0.0; std::string memo; + std::size_t position = 0; }; std::vector outgoing_outputs; }; @@ -180,6 +182,7 @@ public: struct TransactionRefreshResult { std::vector transactions; + std::vector hushChatMetadata; int blockHeight = -1; TransactionViewCache newViewTxEntries; std::size_t nextShieldedScanStartIndex = 0; @@ -260,7 +263,8 @@ public: std::set& knownTxids, const std::string& address, const nlohmann::json& received, - const std::set& miningAddresses = {}); + const std::set& miningAddresses = {}, + std::unordered_map>* chatMemoOutputs = nullptr); static TransactionViewCacheEntry parseViewTransactionCacheEntry(const nlohmann::json& viewTransaction); static void appendViewTransactionOutputs(std::vector& transactions, const std::string& txid, diff --git a/src/ui/sidebar.h b/src/ui/sidebar.h index f9a988e..9381934 100644 --- a/src/ui/sidebar.h +++ b/src/ui/sidebar.h @@ -12,6 +12,7 @@ #include "schema/ui_schema.h" #include "../embedded/IconsMaterialDesign.h" #include "../util/i18n.h" +#include "../wallet/wallet_capabilities.h" #include #include @@ -66,14 +67,26 @@ inline const char* NavSectionLabel(const NavItem& item) { return item.section_tr_key ? TR(item.section_tr_key) : item.section_label; } +inline wallet::WalletUiSurface NavPageSurface(NavPage page) +{ + switch (page) { + case NavPage::Overview: return wallet::WalletUiSurface::Overview; + case NavPage::Send: return wallet::WalletUiSurface::Send; + case NavPage::Receive: return wallet::WalletUiSurface::Receive; + case NavPage::History: return wallet::WalletUiSurface::History; + case NavPage::Mining: return wallet::WalletUiSurface::Mining; + case NavPage::Market: return wallet::WalletUiSurface::Market; + case NavPage::Console: return wallet::WalletUiSurface::Console; + case NavPage::Peers: return wallet::WalletUiSurface::Peers; + case NavPage::Explorer: return wallet::WalletUiSurface::Explorer; + case NavPage::Settings: return wallet::WalletUiSurface::Settings; + default: return wallet::WalletUiSurface::Overview; + } +} + inline bool IsNavPageVisible(NavPage page) { -#if DRAGONX_LITE_BUILD - return page != NavPage::Console && page != NavPage::Peers && page != NavPage::Explorer; -#else - (void)page; - return true; -#endif + return wallet::isUiSurfaceAvailable(wallet::currentWalletCapabilities(), NavPageSurface(page)); } // Get the Material Design icon string for a navigation page. diff --git a/src/ui/windows/bootstrap_download_dialog.h b/src/ui/windows/bootstrap_download_dialog.h index cb6a2be..0dca1bb 100644 --- a/src/ui/windows/bootstrap_download_dialog.h +++ b/src/ui/windows/bootstrap_download_dialog.h @@ -29,6 +29,7 @@ namespace ui { class BootstrapDownloadDialog { public: static void show(App* app) { + if (!app || !app->supportsFullNodeLifecycleActions()) return; s_open = true; s_app = app; s_state = State::Confirm; @@ -285,6 +286,7 @@ private: // ---- Shared: kick off download ---- static void startDownload(const std::string& url) { + if (!s_app || !s_app->supportsFullNodeLifecycleActions()) return; s_wasDaemonRunning = s_app->stopDaemonForBootstrap(); s_app->setBootstrapDownloading(true); s_bootstrap = std::make_unique(); diff --git a/src/ui/windows/mining_tab.cpp b/src/ui/windows/mining_tab.cpp index 32fd637..3c5df51 100644 --- a/src/ui/windows/mining_tab.cpp +++ b/src/ui/windows/mining_tab.cpp @@ -151,13 +151,11 @@ static void RenderMiningTabContent(App* app) strncpy(s_pool_worker, app->settings()->getPoolWorker().c_str(), sizeof(s_pool_worker) - 1); s_pool_state_loaded = true; } -#if DRAGONX_LITE_BUILD - if (!s_pool_mode) { + if (!app->supportsSoloMining() && !s_pool_mode) { s_pool_mode = true; app->settings()->setPoolMode(true); app->settings()->save(); } -#endif // Default pool worker to user's first shielded (z) address once available. // For new wallets without a z-address, leave the field blank so the user @@ -242,11 +240,11 @@ static void RenderMiningTabContent(App* app) // MODE TOGGLE — SOLO | POOL segmented control // ================================================================ { - const bool liteBuild = app->isLiteBuild(); + const bool soloMiningAvailable = app->supportsSoloMining(); float toggleW = schema::UI().drawElement("tabs.mining", "mode-toggle-width").size * hs; float toggleH = schema::UI().drawElement("tabs.mining", "mode-toggle-height").size; float toggleRnd = schema::UI().drawElement("tabs.mining", "mode-toggle-rounding").size; - float totalW = liteBuild ? toggleW : (toggleW * 2); + float totalW = soloMiningAvailable ? (toggleW * 2) : toggleW; ImVec2 tMin = ImGui::GetCursorScreenPos(); ImVec2 tMax(tMin.x + totalW, tMin.y + toggleH); @@ -258,7 +256,7 @@ static void RenderMiningTabContent(App* app) ImVec2 soloMin = tMin; ImVec2 soloMax(tMin.x + toggleW, tMax.y); bool soloHov = material::IsRectHovered(soloMin, soloMax); - if (!liteBuild) { + if (soloMiningAvailable) { // SOLO button (left half) if (!s_pool_mode) { dl->AddRectFilled(soloMin, soloMax, WithAlpha(Primary(), 180), toggleRnd); @@ -275,7 +273,7 @@ static void RenderMiningTabContent(App* app) // POOL button (right half) — disabled when solo mining is active bool soloMiningActive = mining.generate; - ImVec2 poolMin(tMin.x + (liteBuild ? 0.0f : toggleW), tMin.y); + ImVec2 poolMin(tMin.x + (soloMiningAvailable ? toggleW : 0.0f), tMin.y); ImVec2 poolMax = tMax; bool poolHov = material::IsRectHovered(poolMin, poolMax); if (s_pool_mode) { @@ -296,7 +294,7 @@ static void RenderMiningTabContent(App* app) } // Invisible buttons for click targets - if (!liteBuild) { + if (soloMiningAvailable) { ImGui::SetCursorScreenPos(soloMin); ImGui::InvisibleButton("##SoloMode", ImVec2(toggleW, toggleH)); if (ImGui::IsItemClicked() && s_pool_mode) { @@ -310,7 +308,7 @@ static void RenderMiningTabContent(App* app) ImGui::SetCursorScreenPos(poolMin); ImGui::InvisibleButton("##PoolMode", ImVec2(toggleW, toggleH)); - if (!liteBuild && ImGui::IsItemClicked() && !s_pool_mode && !soloMiningActive) { + if (soloMiningAvailable && ImGui::IsItemClicked() && !s_pool_mode && !soloMiningActive) { s_pool_mode = true; app->settings()->setPoolMode(true); app->settings()->save(); @@ -318,7 +316,7 @@ static void RenderMiningTabContent(App* app) // so no need to call stopMining() — it would just set the // toggle-in-progress flag and make the button show "STARTING". } - if (!liteBuild && poolHov && !soloMiningActive) ImGui::SetMouseCursor(ImGuiMouseCursor_Hand); + if (soloMiningAvailable && poolHov && !soloMiningActive) ImGui::SetMouseCursor(ImGuiMouseCursor_Hand); if (poolHov && soloMiningActive && !s_pool_mode) { ImGui::SetTooltip("%s", TR("mining_stop_solo_for_pool")); } @@ -1935,7 +1933,7 @@ static void RenderMiningTabContent(App* app) && tx.memo.find("Mining Pool payout") != std::string::npos); if (isSoloMined || isPoolPayout) { // Apply earnings filter - if (app->isLiteBuild()) { + if (!app->supportsSoloMining()) { if (s_earnings_filter == 1 && !isPoolPayout) continue; } else { if (s_earnings_filter == 1 && !isSoloMined) continue; @@ -1984,10 +1982,10 @@ static void RenderMiningTabContent(App* app) // === Earnings filter toggle button (top-right of card) === { - const bool liteBuild = app->isLiteBuild(); - const char* filterLabels[] = { TR("mining_filter_all"), liteBuild ? TR("mining_pool") : TR("mining_solo"), TR("mining_pool") }; - const char* filterIcons[] = { ICON_MD_FUNCTIONS, liteBuild ? ICON_MD_CLOUD : ICON_MD_MEMORY, ICON_MD_CLOUD }; - const int filterCount = liteBuild ? 2 : 3; + const bool soloMiningAvailable = app->supportsSoloMining(); + const char* filterLabels[] = { TR("mining_filter_all"), soloMiningAvailable ? TR("mining_solo") : TR("mining_pool"), TR("mining_pool") }; + const char* filterIcons[] = { ICON_MD_FUNCTIONS, soloMiningAvailable ? ICON_MD_MEMORY : ICON_MD_CLOUD, ICON_MD_CLOUD }; + const int filterCount = soloMiningAvailable ? 3 : 2; const char* curIcon = filterIcons[s_earnings_filter]; const char* curLabel = filterLabels[s_earnings_filter]; @@ -2033,7 +2031,7 @@ static void RenderMiningTabContent(App* app) ImGui::SetMouseCursor(ImGuiMouseCursor_Hand); const char* tips[] = { TR("mining_filter_tip_all"), - liteBuild ? TR("mining_filter_tip_pool") : TR("mining_filter_tip_solo"), + soloMiningAvailable ? TR("mining_filter_tip_solo") : TR("mining_filter_tip_pool"), TR("mining_filter_tip_pool") }; ImGui::SetTooltip("%s", tips[s_earnings_filter]); diff --git a/src/wallet/lite_backend_artifact_contract.cpp b/src/wallet/lite_backend_artifact_contract.cpp new file mode 100644 index 0000000..e7e2fa1 --- /dev/null +++ b/src/wallet/lite_backend_artifact_contract.cpp @@ -0,0 +1,419 @@ +#include "wallet/lite_backend_artifact_contract.h" + +#include +#include +#include +#include + +namespace dragonx::wallet { +namespace { + +constexpr const char* kSupportedAbiVersion = "sdxl-c-v1"; + +using Issue = LiteBackendArtifactContractIssue; +using Status = LiteBackendArtifactContractStatus; + +void addIssue(LiteBackendArtifactContractResult& result, Issue issue, std::string message) +{ + result.issues.push_back({issue, std::move(message)}); + if (result.error.empty()) result.error = result.issues.back().message; +} + +LiteBackendArtifactContractResult stoppedResult( + LiteBackendArtifactContractResult result, + Status status, + Issue issue, + std::string message) +{ + result.status = status; + addIssue(result, issue, std::move(message)); + return result; +} + +std::string trimCopy(const std::string& value) +{ + auto begin = value.begin(); + while (begin != value.end() && std::isspace(static_cast(*begin))) ++begin; + + auto end = value.end(); + while (end != begin && std::isspace(static_cast(*(end - 1)))) --end; + + return std::string(begin, end); +} + +bool containsSymbol(const std::vector& exportedSymbols, const char* abiName) +{ + return std::find(exportedSymbols.begin(), exportedSymbols.end(), abiName) != exportedSymbols.end(); +} + +bool importedArtifactKindLinkable(LiteBackendArtifactKind kind) +{ + return kind == LiteBackendArtifactKind::StaticLibrary || kind == LiteBackendArtifactKind::SharedLibrary; +} + +bool signatureTrustMetadataProvided(const LiteBackendArtifactSignatureVerificationMetadata& signature) +{ + return !trimCopy(signature.keyFingerprint).empty() || !trimCopy(signature.certificateIdentity).empty(); +} + +LiteBackendArtifactContractResult validateSignatureMetadata( + LiteBackendArtifactContractResult result, + const LiteBackendArtifactContractInput& input, + LiteBackendArtifactContractOptions options) +{ + const auto& signature = input.signatureVerification; + result.signatureRequiredForRelease = signature.requiredForRelease; + const bool shouldValidate = signature.requiredForRelease || + (options.validateOptionalSignatureMetadata && signature.metadataProvided); + + if (!shouldValidate) { + result.signatureMetadataAccepted = true; + result.signatureVerificationForwarded = signature.metadataProvided; + result.signatureVerified = signature.verified; + return result; + } + + if (options.requireSignatureMetadataWhenRequired && !signature.policyDefined) { + return stoppedResult(std::move(result), Status::WaitingForSignatureMetadata, Issue::SignaturePolicyMissing, + "lite backend artifact signature policy is not defined"); + } + if (!signature.metadataProvided) { + return stoppedResult(std::move(result), Status::WaitingForSignatureMetadata, Issue::SignatureMetadataMissing, + "lite backend artifact signature metadata is required but missing"); + } + if (trimCopy(signature.signatureFormat).empty() || + trimCopy(signature.signaturePath).empty() || + trimCopy(signature.verificationTool).empty() || + trimCopy(signature.verifiedArtifactSha256).empty()) { + return stoppedResult(std::move(result), Status::WaitingForSignatureMetadata, Issue::SignatureMetadataIncomplete, + "lite backend artifact signature metadata is incomplete"); + } + if (!signatureTrustMetadataProvided(signature)) { + return stoppedResult(std::move(result), Status::WaitingForSignatureMetadata, Issue::SignatureTrustMetadataMissing, + "lite backend artifact signature metadata is missing a reviewed trust identity"); + } + if (!signature.verificationPerformed) { + return stoppedResult(std::move(result), Status::WaitingForSignatureMetadata, Issue::SignatureVerificationMissing, + "lite backend artifact signature verification has not been performed"); + } + if (!signature.verified) { + return stoppedResult(std::move(result), Status::WaitingForSignatureMetadata, Issue::SignatureVerificationFailed, + "lite backend artifact signature verification did not pass"); + } + if (!trimCopy(input.artifactSha256).empty() && signature.verifiedArtifactSha256 != input.artifactSha256) { + return stoppedResult(std::move(result), Status::WaitingForSignatureMetadata, Issue::SignatureVerifiedArtifactShaMismatch, + "lite backend artifact signature metadata does not match the artifact SHA-256"); + } + + result.signatureMetadataAccepted = true; + result.signatureVerificationForwarded = true; + result.signatureVerified = true; + return result; +} + +LiteBackendArtifactContractResult rejectRuntimeActions( + LiteBackendArtifactContractResult result, + const LiteBackendArtifactContractInput& input, + LiteBackendArtifactContractOptions options) +{ + if (!options.rejectRuntimeActions) return result; + if (input.artifactMutationRequested) { + return stoppedResult(std::move(result), Status::RuntimeActionDisabled, Issue::ArtifactMutationRequested, + "lite backend artifact contract cannot mutate artifacts"); + } + if (input.dynamicLibraryLoadRequested) { + return stoppedResult(std::move(result), Status::RuntimeActionDisabled, Issue::DynamicLibraryLoadRequested, + "lite backend artifact contract cannot load dynamic libraries"); + } + if (input.dynamicLibraryUnloadRequested) { + return stoppedResult(std::move(result), Status::RuntimeActionDisabled, Issue::DynamicLibraryUnloadRequested, + "lite backend artifact contract cannot unload dynamic libraries"); + } + if (input.symbolResolutionRequested) { + return stoppedResult(std::move(result), Status::RuntimeActionDisabled, Issue::SymbolResolutionRequested, + "lite backend artifact contract cannot resolve runtime symbols"); + } + if (input.sdxlApiRequested) { + return stoppedResult(std::move(result), Status::RuntimeActionDisabled, Issue::SdxlApiRequested, + "lite backend artifact contract cannot call SDXL APIs"); + } + if (input.bridgeCallRequested) { + return stoppedResult(std::move(result), Status::RuntimeActionDisabled, Issue::BridgeCallRequested, + "lite backend artifact contract cannot call the bridge"); + } + if (input.serverConnectivityCheckRequested) { + return stoppedResult(std::move(result), Status::RuntimeActionDisabled, Issue::ServerConnectivityCheckRequested, + "lite backend artifact contract cannot check server connectivity"); + } + if (input.walletLifecycleRequested) { + return stoppedResult(std::move(result), Status::RuntimeActionDisabled, Issue::WalletLifecycleRequested, + "lite backend artifact contract cannot execute wallet lifecycle flows"); + } + if (input.syncRequested) { + return stoppedResult(std::move(result), Status::RuntimeActionDisabled, Issue::SyncRequested, + "lite backend artifact contract cannot start sync"); + } + if (input.syncStatusPollingRequested) { + return stoppedResult(std::move(result), Status::RuntimeActionDisabled, Issue::SyncStatusPollingRequested, + "lite backend artifact contract cannot poll syncstatus"); + } + if (input.workerQueueRequested) { + return stoppedResult(std::move(result), Status::RuntimeActionDisabled, Issue::WorkerQueueRequested, + "lite backend artifact contract cannot enqueue workers"); + } + if (input.walletStateMutationRequested) { + return stoppedResult(std::move(result), Status::RuntimeActionDisabled, Issue::WalletStateMutationRequested, + "lite backend artifact contract cannot mutate WalletState"); + } + if (input.walletPersistenceRequested) { + return stoppedResult(std::move(result), Status::RuntimeActionDisabled, Issue::WalletPersistenceRequested, + "lite backend artifact contract cannot persist wallet files"); + } + if (input.uploadRequested) { + return stoppedResult(std::move(result), Status::RuntimeActionDisabled, Issue::UploadRequested, + "lite backend artifact contract cannot upload artifacts"); + } + if (input.signingRequested) { + return stoppedResult(std::move(result), Status::RuntimeActionDisabled, Issue::SigningRequested, + "lite backend artifact contract cannot sign artifacts"); + } + if (input.publicationRequested) { + return stoppedResult(std::move(result), Status::RuntimeActionDisabled, Issue::PublicationRequested, + "lite backend artifact contract cannot publish artifacts"); + } + return result; +} + +} // namespace + +const char* liteBackendArtifactContractSupportedAbiVersion() +{ + return kSupportedAbiVersion; +} + +const char* liteBackendArtifactContractLinkModeName(LiteBackendArtifactContractLinkMode linkMode) +{ + switch (linkMode) { + case LiteBackendArtifactContractLinkMode::ImportedLibrary: return "ImportedLibrary"; + case LiteBackendArtifactContractLinkMode::RuntimeDynamicLibrary: return "RuntimeDynamicLibrary"; + case LiteBackendArtifactContractLinkMode::ExternalExecutable: return "ExternalExecutable"; + } + return "Unknown"; +} + +const char* liteBackendArtifactContractStatusName(LiteBackendArtifactContractStatus status) +{ + switch (status) { + case LiteBackendArtifactContractStatus::ReadyForResolver: return "ReadyForResolver"; + case LiteBackendArtifactContractStatus::WaitingForContractOwner: return "WaitingForContractOwner"; + case LiteBackendArtifactContractStatus::WaitingForReadOnlyGate: return "WaitingForReadOnlyGate"; + case LiteBackendArtifactContractStatus::WaitingForLinkMode: return "WaitingForLinkMode"; + case LiteBackendArtifactContractStatus::WaitingForArtifactPath: return "WaitingForArtifactPath"; + case LiteBackendArtifactContractStatus::WaitingForArtifactKind: return "WaitingForArtifactKind"; + case LiteBackendArtifactContractStatus::WaitingForAbiVersion: return "WaitingForAbiVersion"; + case LiteBackendArtifactContractStatus::WaitingForSymbolInventory: return "WaitingForSymbolInventory"; + case LiteBackendArtifactContractStatus::WaitingForRequiredSymbols: return "WaitingForRequiredSymbols"; + case LiteBackendArtifactContractStatus::WaitingForSignatureMetadata: return "WaitingForSignatureMetadata"; + case LiteBackendArtifactContractStatus::RuntimeActionDisabled: return "RuntimeActionDisabled"; + } + return "Unknown"; +} + +const char* liteBackendArtifactContractIssueName(LiteBackendArtifactContractIssue issue) +{ + switch (issue) { +#define DRAGONX_CASE(value) case LiteBackendArtifactContractIssue::value: return #value + DRAGONX_CASE(ContractOwnerMissing); + DRAGONX_CASE(ReadOnlyGateMissing); + DRAGONX_CASE(RuntimeDynamicLinkDeferred); + DRAGONX_CASE(ExternalExecutableDeferred); + DRAGONX_CASE(ArtifactPathMissing); + DRAGONX_CASE(ArtifactKindNotLinkable); + DRAGONX_CASE(AbiVersionMissing); + DRAGONX_CASE(AbiVersionUnsupported); + DRAGONX_CASE(SymbolInventoryOwnerMissing); + DRAGONX_CASE(SymbolInventoryMissing); + DRAGONX_CASE(RequiredSymbolMissing); + DRAGONX_CASE(SignaturePolicyMissing); + DRAGONX_CASE(SignatureMetadataMissing); + DRAGONX_CASE(SignatureMetadataIncomplete); + DRAGONX_CASE(SignatureVerificationMissing); + DRAGONX_CASE(SignatureVerificationFailed); + DRAGONX_CASE(SignatureVerifiedArtifactShaMismatch); + DRAGONX_CASE(SignatureTrustMetadataMissing); + DRAGONX_CASE(ArtifactMutationRequested); + DRAGONX_CASE(DynamicLibraryLoadRequested); + DRAGONX_CASE(DynamicLibraryUnloadRequested); + DRAGONX_CASE(SymbolResolutionRequested); + DRAGONX_CASE(SdxlApiRequested); + DRAGONX_CASE(BridgeCallRequested); + DRAGONX_CASE(ServerConnectivityCheckRequested); + DRAGONX_CASE(WalletLifecycleRequested); + DRAGONX_CASE(SyncRequested); + DRAGONX_CASE(SyncStatusPollingRequested); + DRAGONX_CASE(WorkerQueueRequested); + DRAGONX_CASE(WalletStateMutationRequested); + DRAGONX_CASE(WalletPersistenceRequested); + DRAGONX_CASE(UploadRequested); + DRAGONX_CASE(SigningRequested); + DRAGONX_CASE(PublicationRequested); +#undef DRAGONX_CASE + } + return "Unknown"; +} + +std::vector liteBackendArtifactContractRequiredSymbols() +{ + return { + {"walletExists", "litelib_wallet_exists", false, false, true, false, false, false}, + {"initializeNew", "litelib_initialize_new", true, false, true, false, false, false}, + {"initializeNewFromPhrase", "litelib_initialize_new_from_phrase", true, false, true, false, false, false}, + {"initializeExisting", "litelib_initialize_existing", true, false, true, false, false, false}, + {"execute", "litelib_execute", true, false, false, true, false, false}, + {"freeString", "litelib_rust_free_string", false, true, true, true, false, false}, + {"checkServerOnline", "litelib_check_server_online", false, false, false, false, true, false}, + {"shutdown", "litelib_shutdown", false, false, true, true, true, true}, + }; +} + +LiteWalletSdxlArtifactSymbolsInput liteBackendArtifactSymbolsFromExportedNames( + const std::vector& exportedSymbols) +{ + LiteWalletSdxlArtifactSymbolsInput symbols; + symbols.walletExists = containsSymbol(exportedSymbols, "litelib_wallet_exists"); + symbols.initializeNew = containsSymbol(exportedSymbols, "litelib_initialize_new"); + symbols.initializeNewFromPhrase = containsSymbol(exportedSymbols, "litelib_initialize_new_from_phrase"); + symbols.initializeExisting = containsSymbol(exportedSymbols, "litelib_initialize_existing"); + symbols.execute = containsSymbol(exportedSymbols, "litelib_execute"); + symbols.freeString = containsSymbol(exportedSymbols, "litelib_rust_free_string"); + symbols.checkServerOnline = containsSymbol(exportedSymbols, "litelib_check_server_online"); + symbols.shutdown = containsSymbol(exportedSymbols, "litelib_shutdown"); + return symbols; +} + +LiteBackendArtifactContractResult evaluateLiteBackendArtifactContract( + const LiteBackendArtifactContractInput& input, + LiteBackendArtifactContractOptions options) +{ + LiteBackendArtifactContractResult result; + result.requiredSymbolCount = liteBackendArtifactContractRequiredSymbols().size(); + result.exportedSymbolCount = input.exportedSymbols.size(); + + result = rejectRuntimeActions(std::move(result), input, options); + if (!result.issues.empty()) return result; + + if (options.requireContractOwner && !input.contractOwnerReady) { + return stoppedResult(std::move(result), Status::WaitingForContractOwner, Issue::ContractOwnerMissing, + "lite backend artifact contract owner is not ready"); + } + result.contractOwnerAccepted = true; + + if (options.requireReadOnlyGate && !input.readOnlyGateReady) { + return stoppedResult(std::move(result), Status::WaitingForReadOnlyGate, Issue::ReadOnlyGateMissing, + "lite backend artifact contract read-only gate is not ready"); + } + result.readOnlyGateAccepted = true; + + if (options.requireImportedLibraryLinkMode && input.linkMode == LiteBackendArtifactContractLinkMode::RuntimeDynamicLibrary) { + return stoppedResult(std::move(result), Status::WaitingForLinkMode, Issue::RuntimeDynamicLinkDeferred, + "runtime dynamic loading is deferred to the bridge runtime owner phase"); + } + if (options.requireImportedLibraryLinkMode && input.linkMode == LiteBackendArtifactContractLinkMode::ExternalExecutable) { + return stoppedResult(std::move(result), Status::WaitingForLinkMode, Issue::ExternalExecutableDeferred, + "external executable bridge mode is not the Phase 1 production link contract"); + } + result.importedLinkModeAccepted = input.linkMode == LiteBackendArtifactContractLinkMode::ImportedLibrary; + + if (trimCopy(input.artifactPath).empty()) { + return stoppedResult(std::move(result), Status::WaitingForArtifactPath, Issue::ArtifactPathMissing, + "lite backend artifact contract requires an artifact path"); + } + result.artifactPathAccepted = true; + + if (!importedArtifactKindLinkable(input.artifactKind)) { + return stoppedResult(std::move(result), Status::WaitingForArtifactKind, Issue::ArtifactKindNotLinkable, + "Phase 1 imported link mode requires a static or shared library artifact"); + } + result.artifactKindAccepted = true; + + if (options.requireAbiVersion && trimCopy(input.abiVersion).empty()) { + return stoppedResult(std::move(result), Status::WaitingForAbiVersion, Issue::AbiVersionMissing, + "lite backend artifact ABI version is missing"); + } + if (options.requireAbiVersion && input.abiVersion != kSupportedAbiVersion) { + return stoppedResult(std::move(result), Status::WaitingForAbiVersion, Issue::AbiVersionUnsupported, + "lite backend artifact ABI version is unsupported"); + } + result.abiVersionAccepted = true; + + result = validateSignatureMetadata(std::move(result), input, options); + if (!result.issues.empty()) return result; + + if (options.requireSymbolInventory && !input.symbolInventoryOwnerReady) { + return stoppedResult(std::move(result), Status::WaitingForSymbolInventory, Issue::SymbolInventoryOwnerMissing, + "lite backend artifact symbol inventory owner is not ready"); + } + if (options.requireSymbolInventory && input.exportedSymbols.empty()) { + return stoppedResult(std::move(result), Status::WaitingForSymbolInventory, Issue::SymbolInventoryMissing, + "lite backend artifact exported symbol inventory is missing"); + } + result.symbolInventoryAccepted = true; + + result.symbols = liteBackendArtifactSymbolsFromExportedNames(input.exportedSymbols); + for (const auto& symbol : liteBackendArtifactContractRequiredSymbols()) { + if (!containsSymbol(input.exportedSymbols, symbol.abiName.c_str())) { + result.missingSymbols.push_back(symbol.abiName); + } + } + if (options.requireAllRequiredSymbols && !result.missingSymbols.empty()) { + return stoppedResult(std::move(result), Status::WaitingForRequiredSymbols, Issue::RequiredSymbolMissing, + "lite backend artifact is missing required C ABI symbols"); + } + result.requiredSymbolsAccepted = true; + + result.resolverCandidate.configured = true; + result.resolverCandidate.artifactPath = input.artifactPath; + result.resolverCandidate.platform = input.platform; + result.resolverCandidate.kind = input.artifactKind; + result.resolverCandidate.versionLabel = input.abiVersion; + result.resolverCandidate.provenance = input.provenance; + result.resolverCandidate.signatureVerification = input.signatureVerification; + result.resolverCandidate.sdxlCompatible = input.sdxlCompatible; + result.resolverCandidate.symbols = result.symbols; + result.resolverCandidate.executableMetadataRequired = false; + + result.resolverInput.resolverOwnerReady = true; + result.resolverInput.readOnlyGateReady = true; + result.resolverInput.projectRoot = input.projectRoot; + result.resolverInput.expectedPlatform = input.platform; + result.resolverInput.candidates.push_back(result.resolverCandidate); + result.resolverInputProduced = true; + result.provenanceForwarded = input.provenance.ownerReady && input.provenance.metadataProvided; + result.signatureVerificationForwarded = input.signatureVerification.metadataProvided; + result.sdxlCompatibilityForwarded = input.sdxlCompatible; + result.dynamicLibraryLoadAllowed = false; + result.symbolResolutionAllowed = false; + result.runtimeActivationAllowed = false; + result.ok = true; + result.status = Status::ReadyForResolver; + + std::ostringstream summary; + summary << "lite_backend_artifact_contract=ready" + << ";abi=" << input.abiVersion + << ";link_mode=" << liteBackendArtifactContractLinkModeName(input.linkMode) + << ";kind=" << liteBackendArtifactKindName(input.artifactKind) + << ";symbols=" << result.requiredSymbolCount + << ";signature_required=" << (result.signatureRequiredForRelease ? "true" : "false") + << ";signature_verified=" << (result.signatureVerified ? "true" : "false") + << ";dynamic_loading=false;runtime_activation=false"; + result.summary = summary.str(); + return result; +} + +LiteBackendArtifactResolverInput liteBackendArtifactResolverInputFromContractResult( + const LiteBackendArtifactContractResult& result) +{ + return result.resolverInput; +} + +} // namespace dragonx::wallet \ No newline at end of file diff --git a/src/wallet/lite_backend_artifact_contract.h b/src/wallet/lite_backend_artifact_contract.h new file mode 100644 index 0000000..33be85a --- /dev/null +++ b/src/wallet/lite_backend_artifact_contract.h @@ -0,0 +1,195 @@ +#pragma once + +#include "lite_backend_artifact_resolver.h" + +#include +#include +#include + +namespace dragonx::wallet { + +enum class LiteBackendArtifactContractLinkMode { + ImportedLibrary, + RuntimeDynamicLibrary, + ExternalExecutable, +}; + +enum class LiteBackendArtifactContractStatus { + ReadyForResolver, + WaitingForContractOwner, + WaitingForReadOnlyGate, + WaitingForLinkMode, + WaitingForArtifactPath, + WaitingForArtifactKind, + WaitingForAbiVersion, + WaitingForSymbolInventory, + WaitingForRequiredSymbols, + WaitingForSignatureMetadata, + RuntimeActionDisabled, +}; + +enum class LiteBackendArtifactContractIssue { + ContractOwnerMissing, + ReadOnlyGateMissing, + RuntimeDynamicLinkDeferred, + ExternalExecutableDeferred, + ArtifactPathMissing, + ArtifactKindNotLinkable, + AbiVersionMissing, + AbiVersionUnsupported, + SymbolInventoryOwnerMissing, + SymbolInventoryMissing, + RequiredSymbolMissing, + SignaturePolicyMissing, + SignatureMetadataMissing, + SignatureMetadataIncomplete, + SignatureVerificationMissing, + SignatureVerificationFailed, + SignatureVerifiedArtifactShaMismatch, + SignatureTrustMetadataMissing, + ArtifactMutationRequested, + DynamicLibraryLoadRequested, + DynamicLibraryUnloadRequested, + SymbolResolutionRequested, + SdxlApiRequested, + BridgeCallRequested, + ServerConnectivityCheckRequested, + WalletLifecycleRequested, + SyncRequested, + SyncStatusPollingRequested, + WorkerQueueRequested, + WalletStateMutationRequested, + WalletPersistenceRequested, + UploadRequested, + SigningRequested, + PublicationRequested, +}; + +struct LiteBackendArtifactContractSymbol { + std::string logicalName; + std::string abiName; + bool returnsOwnedString = false; + bool cleanupFunction = false; + bool requiredForLifecycle = false; + bool requiredForSync = false; + bool requiredForServerCheck = false; + bool requiredForShutdown = false; +}; + +struct LiteBackendArtifactContractInput { + bool contractOwnerReady = false; + bool readOnlyGateReady = false; + std::string projectRoot; + std::string artifactPath; + LiteBackendArtifactPlatform platform = LiteBackendArtifactPlatform::Current; + LiteBackendArtifactKind artifactKind = LiteBackendArtifactKind::Unknown; + LiteBackendArtifactContractLinkMode linkMode = LiteBackendArtifactContractLinkMode::ImportedLibrary; + std::string abiVersion; + std::string artifactSha256; + LiteBackendArtifactProvenanceMetadata provenance; + LiteBackendArtifactSignatureVerificationMetadata signatureVerification; + bool sdxlCompatible = false; + bool symbolInventoryOwnerReady = false; + std::vector exportedSymbols; + + bool artifactMutationRequested = false; + bool dynamicLibraryLoadRequested = false; + bool dynamicLibraryUnloadRequested = false; + bool symbolResolutionRequested = false; + bool sdxlApiRequested = false; + bool bridgeCallRequested = false; + bool serverConnectivityCheckRequested = false; + bool walletLifecycleRequested = false; + bool syncRequested = false; + bool syncStatusPollingRequested = false; + bool workerQueueRequested = false; + bool walletStateMutationRequested = false; + bool walletPersistenceRequested = false; + bool uploadRequested = false; + bool signingRequested = false; + bool publicationRequested = false; +}; + +struct LiteBackendArtifactContractOptions { + bool requireContractOwner = true; + bool requireReadOnlyGate = true; + bool requireImportedLibraryLinkMode = true; + bool requireAbiVersion = true; + bool requireSymbolInventory = true; + bool requireAllRequiredSymbols = true; + bool requireSignatureMetadataWhenRequired = true; + bool validateOptionalSignatureMetadata = true; + bool rejectRuntimeActions = true; +}; + +struct LiteBackendArtifactContractIssueInfo { + LiteBackendArtifactContractIssue issue = LiteBackendArtifactContractIssue::ContractOwnerMissing; + std::string message; +}; + +struct LiteBackendArtifactContractResult { + bool ok = false; + bool readOnlyContract = true; + bool noArtifactMutation = true; + bool noDynamicLibraryLoaded = true; + bool noDynamicLibraryUnloaded = true; + bool noSymbolResolutionPerformed = true; + bool noSdxlCalls = true; + bool noBridgeCalls = true; + bool noServerConnectivityChecked = true; + bool noWalletLifecycle = true; + bool noSyncStarted = true; + bool noSyncStatusPolled = true; + bool noWorkerQueueEnqueue = true; + bool noWalletStateMutation = true; + bool noWalletPersistence = true; + bool noUpload = true; + bool noSigning = true; + bool noPublication = true; + + bool contractOwnerAccepted = false; + bool readOnlyGateAccepted = false; + bool importedLinkModeAccepted = false; + bool artifactPathAccepted = false; + bool artifactKindAccepted = false; + bool abiVersionAccepted = false; + bool provenanceForwarded = false; + bool signatureMetadataAccepted = false; + bool signatureVerificationForwarded = false; + bool signatureRequiredForRelease = false; + bool signatureVerified = false; + bool sdxlCompatibilityForwarded = false; + bool symbolInventoryAccepted = false; + bool requiredSymbolsAccepted = false; + bool resolverInputProduced = false; + bool dynamicLibraryLoadAllowed = false; + bool symbolResolutionAllowed = false; + bool runtimeActivationAllowed = false; + + std::size_t requiredSymbolCount = 0; + std::size_t exportedSymbolCount = 0; + LiteBackendArtifactContractStatus status = LiteBackendArtifactContractStatus::WaitingForContractOwner; + LiteWalletSdxlArtifactSymbolsInput symbols; + LiteBackendArtifactCandidate resolverCandidate; + LiteBackendArtifactResolverInput resolverInput; + std::vector missingSymbols; + std::vector issues; + std::string error; + std::string summary; +}; + +const char* liteBackendArtifactContractSupportedAbiVersion(); +const char* liteBackendArtifactContractLinkModeName(LiteBackendArtifactContractLinkMode linkMode); +const char* liteBackendArtifactContractStatusName(LiteBackendArtifactContractStatus status); +const char* liteBackendArtifactContractIssueName(LiteBackendArtifactContractIssue issue); + +std::vector liteBackendArtifactContractRequiredSymbols(); +LiteWalletSdxlArtifactSymbolsInput liteBackendArtifactSymbolsFromExportedNames( + const std::vector& exportedSymbols); +LiteBackendArtifactContractResult evaluateLiteBackendArtifactContract( + const LiteBackendArtifactContractInput& input, + LiteBackendArtifactContractOptions options = {}); +LiteBackendArtifactResolverInput liteBackendArtifactResolverInputFromContractResult( + const LiteBackendArtifactContractResult& result); + +} // namespace dragonx::wallet \ No newline at end of file diff --git a/src/wallet/lite_backend_artifact_resolver.cpp b/src/wallet/lite_backend_artifact_resolver.cpp new file mode 100644 index 0000000..05f4f6f --- /dev/null +++ b/src/wallet/lite_backend_artifact_resolver.cpp @@ -0,0 +1,925 @@ +#include "wallet/lite_backend_artifact_resolver.h" + +#include +#include +#include +#include +#include +#include + +namespace dragonx::wallet { +namespace { + +namespace fs = std::filesystem; + +struct CandidateInspectionResult { + bool ok = false; + LiteBackendArtifactResolverStatus status = LiteBackendArtifactResolverStatus::WaitingForArtifactCandidate; + LiteBackendArtifactResolverIssue issue = LiteBackendArtifactResolverIssue::ArtifactMissing; + std::string message; + LiteBackendResolvedArtifact artifact; + LiteWalletSdxlArtifactInput syncArtifactInput; +}; + +void addIssue(LiteBackendArtifactResolverResult& result, + LiteBackendArtifactResolverIssue issue, + std::string message) +{ + result.issues.push_back(LiteBackendArtifactResolverIssueInfo{issue, std::move(message)}); +} + +void addIssue(LiteBackendActivationReadinessResult& result, + LiteBackendActivationReadinessIssue issue, + std::string message) +{ + result.issues.push_back(LiteBackendActivationReadinessIssueInfo{issue, std::move(message)}); +} + +LiteBackendArtifactResolverResult stoppedResolverResult( + LiteBackendArtifactResolverResult result, + LiteBackendArtifactResolverStatus status, + LiteBackendArtifactResolverIssue issue, + std::string message) +{ + result.status = status; + addIssue(result, issue, std::move(message)); + result.error = result.issues.back().message; + return result; +} + +LiteBackendActivationReadinessResult stoppedActivationResult( + LiteBackendActivationReadinessResult result, + LiteBackendActivationReadinessStatus status, + LiteBackendActivationReadinessIssue issue, + std::string message, + WalletBackendState backendState = WalletBackendState::Unavailable) +{ + result.status = status; + addIssue(result, issue, std::move(message)); + result.error = result.issues.back().message; + result.connectionStatus = WalletBackendStatus{backendState, result.error, {}, {}, 0.0}; + return result; +} + +std::string lowerCopy(const std::string& value) +{ + std::string lowered; + lowered.reserve(value.size()); + for (const unsigned char character : value) { + lowered.push_back(static_cast(std::tolower(character))); + } + return lowered; +} + +std::string trimCopy(const std::string& value) +{ + auto begin = value.begin(); + while (begin != value.end() && std::isspace(static_cast(*begin))) ++begin; + + auto end = value.end(); + while (end != begin && std::isspace(static_cast(*(end - 1)))) --end; + + return std::string(begin, end); +} + +std::string baseNameLower(const std::string& path) +{ + const auto slash = path.find_last_of("/\\"); + const std::string name = slash == std::string::npos ? path : path.substr(slash + 1); + return lowerCopy(name); +} + +bool endsWith(const std::string& value, const char* suffix) +{ + const std::string suffixValue(suffix); + return value.size() >= suffixValue.size() && + value.compare(value.size() - suffixValue.size(), suffixValue.size(), suffixValue) == 0; +} + +LiteBackendArtifactPlatform normalizePlatform(LiteBackendArtifactPlatform platform) +{ + return platform == LiteBackendArtifactPlatform::Current + ? currentLiteBackendArtifactPlatform() + : platform; +} + +LiteBackendArtifactKind inferArtifactKind(const std::string& path) +{ + const std::string name = baseNameLower(path); + if (endsWith(name, ".a") || endsWith(name, ".lib")) return LiteBackendArtifactKind::StaticLibrary; + if (endsWith(name, ".so") || endsWith(name, ".dll") || endsWith(name, ".dylib")) { + return LiteBackendArtifactKind::SharedLibrary; + } + if (endsWith(name, ".exe") || name == "silentdragonxlite" || name == "silentdragonx-lite") { + return LiteBackendArtifactKind::Executable; + } + return LiteBackendArtifactKind::Unknown; +} + +bool artifactKindSupported(LiteBackendArtifactKind kind) +{ + return kind == LiteBackendArtifactKind::StaticLibrary || + kind == LiteBackendArtifactKind::SharedLibrary || + kind == LiteBackendArtifactKind::Executable; +} + +std::vector defaultArtifactNames(LiteBackendArtifactPlatform platform, + LiteBackendArtifactKind kind) +{ + const auto normalizedPlatform = normalizePlatform(platform); + std::vector names; + + const auto addNamesForKind = [&](LiteBackendArtifactKind artifactKind) { + switch (normalizedPlatform) { + case LiteBackendArtifactPlatform::Windows: + if (artifactKind == LiteBackendArtifactKind::StaticLibrary) { + names.push_back("silentdragonxlite.lib"); + names.push_back("libsilentdragonxlite.a"); + } else if (artifactKind == LiteBackendArtifactKind::SharedLibrary) { + names.push_back("silentdragonxlite.dll"); + } else if (artifactKind == LiteBackendArtifactKind::Executable) { + names.push_back("silentdragonxlite.exe"); + names.push_back("silentdragonx-lite.exe"); + } + break; + case LiteBackendArtifactPlatform::MacOS: + if (artifactKind == LiteBackendArtifactKind::StaticLibrary) { + names.push_back("libsilentdragonxlite.a"); + names.push_back("silentdragonxlite.a"); + } else if (artifactKind == LiteBackendArtifactKind::SharedLibrary) { + names.push_back("libsilentdragonxlite.dylib"); + names.push_back("silentdragonxlite.dylib"); + } else if (artifactKind == LiteBackendArtifactKind::Executable) { + names.push_back("silentdragonxlite"); + names.push_back("silentdragonx-lite"); + } + break; + case LiteBackendArtifactPlatform::Linux: + case LiteBackendArtifactPlatform::Current: + case LiteBackendArtifactPlatform::Unknown: + if (artifactKind == LiteBackendArtifactKind::StaticLibrary) { + names.push_back("silentdragonxlite.a"); + names.push_back("libsilentdragonxlite.a"); + } else if (artifactKind == LiteBackendArtifactKind::SharedLibrary) { + names.push_back("libsilentdragonxlite.so"); + names.push_back("silentdragonxlite.so"); + } else if (artifactKind == LiteBackendArtifactKind::Executable) { + names.push_back("silentdragonxlite"); + names.push_back("silentdragonx-lite"); + } + break; + } + }; + + if (kind == LiteBackendArtifactKind::Unknown) { + addNamesForKind(LiteBackendArtifactKind::StaticLibrary); + addNamesForKind(LiteBackendArtifactKind::SharedLibrary); + addNamesForKind(LiteBackendArtifactKind::Executable); + } else { + addNamesForKind(kind); + } + return names; +} + +fs::path resolvePath(const std::string& projectRoot, const std::string& path) +{ + const fs::path value(path); + if (value.is_absolute()) return value; + const fs::path root = projectRoot.empty() ? fs::path(".") : fs::path(projectRoot); + return root / value; +} + +std::vector expandSearchRoots( + const LiteBackendArtifactResolverInput& input, + LiteBackendArtifactResolverResult& result, + LiteBackendArtifactResolverOptions options) +{ + std::vector candidates; + result.searchRootCount = input.searchRoots.size(); + + for (const auto& root : input.searchRoots) { + if (options.requireArtifactCandidates && !root.configured) { + result = stoppedResolverResult( + std::move(result), + LiteBackendArtifactResolverStatus::WaitingForArtifactSearchRoot, + LiteBackendArtifactResolverIssue::ArtifactSearchRootNotConfigured, + "lite backend artifact search root is not configured"); + return {}; + } + if (trimCopy(root.rootPath).empty()) { + result = stoppedResolverResult( + std::move(result), + LiteBackendArtifactResolverStatus::WaitingForArtifactSearchRoot, + LiteBackendArtifactResolverIssue::ArtifactSearchRootMissing, + "lite backend artifact search root path is missing"); + return {}; + } + + const fs::path rootPath = resolvePath(input.projectRoot, root.rootPath); + std::error_code error; + if (!fs::exists(rootPath, error) || error) { + result = stoppedResolverResult( + std::move(result), + LiteBackendArtifactResolverStatus::WaitingForArtifactSearchRoot, + LiteBackendArtifactResolverIssue::ArtifactSearchRootMissing, + "lite backend artifact search root does not exist"); + return {}; + } + if (!fs::is_directory(rootPath, error) || error) { + result = stoppedResolverResult( + std::move(result), + LiteBackendArtifactResolverStatus::WaitingForArtifactSearchRoot, + LiteBackendArtifactResolverIssue::ArtifactSearchRootNotDirectory, + "lite backend artifact search root is not a directory"); + return {}; + } + + const auto names = root.expectedArtifactNames.empty() + ? defaultArtifactNames(root.platform, root.kind) + : root.expectedArtifactNames; + for (const auto& artifactName : names) { + LiteBackendArtifactCandidate candidate; + candidate.configured = true; + candidate.artifactPath = (rootPath / artifactName).string(); + candidate.platform = root.platform; + candidate.kind = root.kind; + candidate.versionLabel = root.versionLabel; + candidate.provenance = root.provenance; + candidate.signatureVerification = root.signatureVerification; + candidate.sdxlCompatible = root.sdxlCompatible; + candidate.symbols = root.symbols; + candidate.executableMetadataRequired = root.executableMetadataRequired; + candidates.push_back(std::move(candidate)); + } + } + result.artifactSearchRootsAccepted = true; + return candidates; +} + +bool coreSymbolsReady(const LiteWalletSdxlArtifactSymbolsInput& symbols) +{ + return symbols.walletExists && + symbols.initializeNew && + symbols.initializeNewFromPhrase && + symbols.initializeExisting && + symbols.execute && + symbols.checkServerOnline; +} + +bool fileReadable(const fs::path& path) +{ + std::ifstream input(path, std::ios::binary); + return input.good(); +} + +bool fileExecutable(const fs::path& path, LiteBackendArtifactPlatform platform) +{ + const std::string name = baseNameLower(path.string()); + if (normalizePlatform(platform) == LiteBackendArtifactPlatform::Windows && endsWith(name, ".exe")) return true; + + std::error_code error; + const auto permissions = fs::status(path, error).permissions(); + if (error) return false; + return (permissions & fs::perms::owner_exec) != fs::perms::none || + (permissions & fs::perms::group_exec) != fs::perms::none || + (permissions & fs::perms::others_exec) != fs::perms::none; +} + +bool provenanceComplete(const LiteBackendArtifactProvenanceMetadata& provenance) +{ + return provenance.metadataProvided && + !trimCopy(provenance.source).empty() && + !trimCopy(provenance.builder).empty() && + !trimCopy(provenance.sourceRevision).empty() && + !trimCopy(provenance.artifactSetId).empty(); +} + +CandidateInspectionResult inspectCandidate(const LiteBackendArtifactResolverInput& input, + const LiteBackendArtifactCandidate& candidate, + LiteBackendArtifactResolverOptions options) +{ + CandidateInspectionResult inspection; + if (options.requireArtifactCandidates && !candidate.configured) { + inspection.issue = LiteBackendArtifactResolverIssue::ArtifactCandidateNotConfigured; + inspection.message = "lite backend artifact candidate is not configured"; + return inspection; + } + if (trimCopy(candidate.artifactPath).empty()) { + inspection.issue = LiteBackendArtifactResolverIssue::ArtifactPathMissing; + inspection.message = "lite backend artifact candidate path is missing"; + return inspection; + } + + const fs::path artifactPath = resolvePath(input.projectRoot, candidate.artifactPath); + std::error_code error; + if (!fs::exists(artifactPath, error) || error) { + inspection.issue = LiteBackendArtifactResolverIssue::ArtifactMissing; + inspection.message = "lite backend artifact candidate does not exist"; + return inspection; + } + if (!fs::is_regular_file(artifactPath, error) || error) { + inspection.issue = LiteBackendArtifactResolverIssue::ArtifactNotRegularFile; + inspection.message = "lite backend artifact candidate is not a regular file"; + return inspection; + } + if (!fileReadable(artifactPath)) { + inspection.issue = LiteBackendArtifactResolverIssue::ArtifactUnreadable; + inspection.message = "lite backend artifact candidate is not readable"; + return inspection; + } + + const auto candidatePlatform = normalizePlatform(candidate.platform); + const auto expectedPlatform = normalizePlatform(input.expectedPlatform); + if (candidatePlatform == LiteBackendArtifactPlatform::Unknown || candidatePlatform != expectedPlatform) { + inspection.status = LiteBackendArtifactResolverStatus::WaitingForArtifactMetadata; + inspection.issue = LiteBackendArtifactResolverIssue::PlatformMismatch; + inspection.message = "lite backend artifact platform metadata does not match the expected platform"; + return inspection; + } + + const auto kind = candidate.kind == LiteBackendArtifactKind::Unknown + ? inferArtifactKind(candidate.artifactPath) + : candidate.kind; + if (!artifactKindSupported(kind)) { + inspection.status = LiteBackendArtifactResolverStatus::WaitingForArtifactMetadata; + inspection.issue = LiteBackendArtifactResolverIssue::UnsupportedArtifactKind; + inspection.message = "lite backend artifact kind is unsupported or unknown"; + return inspection; + } + + if (options.requireVersionMetadata && trimCopy(candidate.versionLabel).empty()) { + inspection.status = LiteBackendArtifactResolverStatus::WaitingForArtifactMetadata; + inspection.issue = LiteBackendArtifactResolverIssue::VersionMissing; + inspection.message = "lite backend artifact version metadata is missing"; + return inspection; + } + + if (options.requireProvenanceMetadata) { + if (!candidate.provenance.ownerReady) { + inspection.status = LiteBackendArtifactResolverStatus::WaitingForArtifactMetadata; + inspection.issue = LiteBackendArtifactResolverIssue::ProvenanceOwnerMissing; + inspection.message = "lite backend artifact provenance owner is not ready"; + return inspection; + } + if (!provenanceComplete(candidate.provenance)) { + inspection.status = LiteBackendArtifactResolverStatus::WaitingForArtifactMetadata; + inspection.issue = LiteBackendArtifactResolverIssue::ProvenanceMetadataMissing; + inspection.message = "lite backend artifact provenance metadata is incomplete"; + return inspection; + } + } + + if (options.requireSdxlCompatibility && !candidate.sdxlCompatible) { + inspection.status = LiteBackendArtifactResolverStatus::WaitingForArtifactMetadata; + inspection.issue = LiteBackendArtifactResolverIssue::ArtifactNotSdxlCompatible; + inspection.message = "lite backend artifact is not marked SDXL-compatible"; + return inspection; + } + + if (options.requireSdxlSymbols) { + if (!coreSymbolsReady(candidate.symbols)) { + inspection.status = LiteBackendArtifactResolverStatus::WaitingForArtifactMetadata; + inspection.issue = LiteBackendArtifactResolverIssue::ArtifactSymbolsMissing; + inspection.message = "lite backend artifact is missing required SDXL bridge symbol metadata"; + return inspection; + } + if (!candidate.symbols.freeString) { + inspection.status = LiteBackendArtifactResolverStatus::WaitingForArtifactMetadata; + inspection.issue = LiteBackendArtifactResolverIssue::ArtifactStringOwnershipUnverified; + inspection.message = "lite backend artifact string cleanup symbol metadata is missing"; + return inspection; + } + if (!candidate.symbols.shutdown) { + inspection.status = LiteBackendArtifactResolverStatus::WaitingForArtifactMetadata; + inspection.issue = LiteBackendArtifactResolverIssue::ArtifactShutdownUnavailable; + inspection.message = "lite backend artifact shutdown symbol metadata is missing"; + return inspection; + } + } + + const bool executable = fileExecutable(artifactPath, candidatePlatform); + if ((kind == LiteBackendArtifactKind::Executable || candidate.executableMetadataRequired) && !executable) { + inspection.status = LiteBackendArtifactResolverStatus::WaitingForArtifactMetadata; + inspection.issue = LiteBackendArtifactResolverIssue::ExecutableMetadataMissing; + inspection.message = "lite backend executable artifact is not marked executable"; + return inspection; + } + + std::size_t artifactSizeBytes = 0; + const auto fileSize = fs::file_size(artifactPath, error); + if (!error) artifactSizeBytes = static_cast(fileSize); + + inspection.ok = true; + inspection.artifact.found = true; + inspection.artifact.artifactPath = artifactPath.string(); + inspection.artifact.platform = candidatePlatform; + inspection.artifact.kind = kind; + inspection.artifact.versionLabel = candidate.versionLabel; + inspection.artifact.provenance = candidate.provenance; + inspection.artifact.signatureVerification = candidate.signatureVerification; + inspection.artifact.exists = true; + inspection.artifact.regularFile = true; + inspection.artifact.readable = true; + inspection.artifact.executable = executable; + inspection.artifact.sdxlCompatible = candidate.sdxlCompatible; + inspection.artifact.symbols = candidate.symbols; + inspection.artifact.artifactSizeBytes = artifactSizeBytes; + + inspection.syncArtifactInput.pathConfigured = true; + inspection.syncArtifactInput.exists = true; + inspection.syncArtifactInput.readable = true; + inspection.syncArtifactInput.sdxlCompatible = candidate.sdxlCompatible; + inspection.syncArtifactInput.artifactPath = artifactPath.string(); + inspection.syncArtifactInput.versionLabel = candidate.versionLabel; + inspection.syncArtifactInput.symbols = candidate.symbols; + return inspection; +} + +LiteBackendArtifactResolverResult rejectResolverRuntimeAction( + LiteBackendArtifactResolverResult result, + const LiteBackendArtifactResolverInput& input, + LiteBackendArtifactResolverOptions options) +{ + if (options.rejectArtifactMutation && input.artifactMutationRequested) { + return stoppedResolverResult(std::move(result), LiteBackendArtifactResolverStatus::RuntimeActionDisabled, + LiteBackendArtifactResolverIssue::ArtifactMutationRequested, + "lite backend artifact mutation is disabled for artifact resolution"); + } + if (options.rejectSdxlApiCalls && input.sdxlApiRequested) { + return stoppedResolverResult(std::move(result), LiteBackendArtifactResolverStatus::RuntimeActionDisabled, + LiteBackendArtifactResolverIssue::SdxlApiRequested, + "SDXL API calls are disabled for artifact resolution"); + } + if (options.rejectServerConnectivityChecks && input.serverConnectivityCheckRequested) { + return stoppedResolverResult(std::move(result), LiteBackendArtifactResolverStatus::RuntimeActionDisabled, + LiteBackendArtifactResolverIssue::ServerConnectivityCheckRequested, + "server connectivity checks are disabled for artifact resolution"); + } + if (options.rejectWalletLifecycle && input.walletLifecycleRequested) { + return stoppedResolverResult(std::move(result), LiteBackendArtifactResolverStatus::RuntimeActionDisabled, + LiteBackendArtifactResolverIssue::WalletLifecycleRequested, + "wallet lifecycle execution is disabled for artifact resolution"); + } + if (options.rejectSync && input.syncRequested) { + return stoppedResolverResult(std::move(result), LiteBackendArtifactResolverStatus::RuntimeActionDisabled, + LiteBackendArtifactResolverIssue::SyncRequested, + "lite sync execution is disabled for artifact resolution"); + } + if (options.rejectSyncStatusPolling && input.syncStatusPollingRequested) { + return stoppedResolverResult(std::move(result), LiteBackendArtifactResolverStatus::RuntimeActionDisabled, + LiteBackendArtifactResolverIssue::SyncStatusPollingRequested, + "lite syncstatus polling is disabled for artifact resolution"); + } + if (options.rejectWorkerQueue && input.workerQueueRequested) { + return stoppedResolverResult(std::move(result), LiteBackendArtifactResolverStatus::RuntimeActionDisabled, + LiteBackendArtifactResolverIssue::WorkerQueueRequested, + "worker queue enqueue is disabled for artifact resolution"); + } + if (options.rejectWalletStateMutation && input.walletStateMutationRequested) { + return stoppedResolverResult(std::move(result), LiteBackendArtifactResolverStatus::RuntimeActionDisabled, + LiteBackendArtifactResolverIssue::WalletStateMutationRequested, + "WalletState mutation is disabled for artifact resolution"); + } + if (options.rejectWalletPersistence && input.walletPersistenceRequested) { + return stoppedResolverResult(std::move(result), LiteBackendArtifactResolverStatus::RuntimeActionDisabled, + LiteBackendArtifactResolverIssue::WalletPersistenceRequested, + "wallet persistence is disabled for artifact resolution"); + } + if (options.rejectUpload && input.uploadRequested) { + return stoppedResolverResult(std::move(result), LiteBackendArtifactResolverStatus::RuntimeActionDisabled, + LiteBackendArtifactResolverIssue::UploadRequested, + "upload is disabled for artifact resolution"); + } + if (options.rejectSigning && input.signingRequested) { + return stoppedResolverResult(std::move(result), LiteBackendArtifactResolverStatus::RuntimeActionDisabled, + LiteBackendArtifactResolverIssue::SigningRequested, + "signing is disabled for artifact resolution"); + } + if (options.rejectPublication && input.publicationRequested) { + return stoppedResolverResult(std::move(result), LiteBackendArtifactResolverStatus::RuntimeActionDisabled, + LiteBackendArtifactResolverIssue::PublicationRequested, + "publication is disabled for artifact resolution"); + } + return result; +} + +LiteBackendActivationReadinessResult rejectActivationRuntimeAction( + LiteBackendActivationReadinessResult result, + const LiteBackendActivationReadinessInput& input, + LiteBackendActivationReadinessOptions options) +{ + if (options.rejectArtifactMutation && input.artifactMutationRequested) { + return stoppedActivationResult(std::move(result), LiteBackendActivationReadinessStatus::RuntimeActionDisabled, + LiteBackendActivationReadinessIssue::ArtifactMutationRequested, + "lite backend artifact mutation is disabled for activation readiness"); + } + if (options.rejectSdxlApiCalls && input.sdxlApiRequested) { + return stoppedActivationResult(std::move(result), LiteBackendActivationReadinessStatus::RuntimeActionDisabled, + LiteBackendActivationReadinessIssue::SdxlApiRequested, + "SDXL API calls are disabled for activation readiness"); + } + if (options.rejectServerConnectivityChecks && input.serverConnectivityCheckRequested) { + return stoppedActivationResult(std::move(result), LiteBackendActivationReadinessStatus::RuntimeActionDisabled, + LiteBackendActivationReadinessIssue::ServerConnectivityCheckRequested, + "server connectivity checks are disabled for activation readiness"); + } + if (options.rejectWalletLifecycle && input.walletLifecycleRequested) { + return stoppedActivationResult(std::move(result), LiteBackendActivationReadinessStatus::RuntimeActionDisabled, + LiteBackendActivationReadinessIssue::WalletLifecycleRequested, + "wallet lifecycle execution is disabled for activation readiness"); + } + if (options.rejectSync && input.syncRequested) { + return stoppedActivationResult(std::move(result), LiteBackendActivationReadinessStatus::RuntimeActionDisabled, + LiteBackendActivationReadinessIssue::SyncRequested, + "lite sync execution is disabled for activation readiness"); + } + if (options.rejectSyncStatusPolling && input.syncStatusPollingRequested) { + return stoppedActivationResult(std::move(result), LiteBackendActivationReadinessStatus::RuntimeActionDisabled, + LiteBackendActivationReadinessIssue::SyncStatusPollingRequested, + "lite syncstatus polling is disabled for activation readiness"); + } + if (options.rejectWorkerQueue && input.workerQueueRequested) { + return stoppedActivationResult(std::move(result), LiteBackendActivationReadinessStatus::RuntimeActionDisabled, + LiteBackendActivationReadinessIssue::WorkerQueueRequested, + "worker queue enqueue is disabled for activation readiness"); + } + if (options.rejectWalletStateMutation && input.walletStateMutationRequested) { + return stoppedActivationResult(std::move(result), LiteBackendActivationReadinessStatus::RuntimeActionDisabled, + LiteBackendActivationReadinessIssue::WalletStateMutationRequested, + "WalletState mutation is disabled for activation readiness"); + } + if (options.rejectWalletPersistence && input.walletPersistenceRequested) { + return stoppedActivationResult(std::move(result), LiteBackendActivationReadinessStatus::RuntimeActionDisabled, + LiteBackendActivationReadinessIssue::WalletPersistenceRequested, + "wallet persistence is disabled for activation readiness"); + } + if (options.rejectUpload && input.uploadRequested) { + return stoppedActivationResult(std::move(result), LiteBackendActivationReadinessStatus::RuntimeActionDisabled, + LiteBackendActivationReadinessIssue::UploadRequested, + "upload is disabled for activation readiness"); + } + if (options.rejectSigning && input.signingRequested) { + return stoppedActivationResult(std::move(result), LiteBackendActivationReadinessStatus::RuntimeActionDisabled, + LiteBackendActivationReadinessIssue::SigningRequested, + "signing is disabled for activation readiness"); + } + if (options.rejectPublication && input.publicationRequested) { + return stoppedActivationResult(std::move(result), LiteBackendActivationReadinessStatus::RuntimeActionDisabled, + LiteBackendActivationReadinessIssue::PublicationRequested, + "publication is disabled for activation readiness"); + } + return result; +} + +WalletBackendStatus backendStatusOrDefault(const LiteBackendBridgeReadinessInput& backend, + const std::string& fallback) +{ + if (!backend.status.message.empty()) return backend.status; + return WalletBackendStatus{WalletBackendState::Unavailable, fallback, {}, {}, 0.0}; +} + +WalletBackendStatus readyConnectionStatus(const LiteServerSelectionResult& selectedServer) +{ + const std::string serverLabel = selectedServer.server.label.empty() + ? selectedServer.server.url + : selectedServer.server.label; + return WalletBackendStatus{ + WalletBackendState::Disconnected, + "lite backend activation readiness accepted for " + serverLabel + "; bridge calls remain disabled here", + {}, + {}, + 0.0 + }; +} + +} // namespace + +LiteBackendArtifactPlatform currentLiteBackendArtifactPlatform() +{ +#if defined(_WIN32) + return LiteBackendArtifactPlatform::Windows; +#elif defined(__APPLE__) + return LiteBackendArtifactPlatform::MacOS; +#else + return LiteBackendArtifactPlatform::Linux; +#endif +} + +const char* liteBackendArtifactPlatformName(LiteBackendArtifactPlatform platform) +{ + switch (platform) { + case LiteBackendArtifactPlatform::Current: return "Current"; + case LiteBackendArtifactPlatform::Linux: return "Linux"; + case LiteBackendArtifactPlatform::Windows: return "Windows"; + case LiteBackendArtifactPlatform::MacOS: return "MacOS"; + case LiteBackendArtifactPlatform::Unknown: return "Unknown"; + } + return "Unknown"; +} + +const char* liteBackendArtifactKindName(LiteBackendArtifactKind kind) +{ + switch (kind) { + case LiteBackendArtifactKind::Unknown: return "Unknown"; + case LiteBackendArtifactKind::StaticLibrary: return "StaticLibrary"; + case LiteBackendArtifactKind::SharedLibrary: return "SharedLibrary"; + case LiteBackendArtifactKind::Executable: return "Executable"; + } + return "Unknown"; +} + +const char* liteBackendArtifactResolverStatusName(LiteBackendArtifactResolverStatus status) +{ + switch (status) { + case LiteBackendArtifactResolverStatus::ReadyForActivationReadiness: return "ReadyForActivationReadiness"; + case LiteBackendArtifactResolverStatus::WaitingForResolverOwner: return "WaitingForResolverOwner"; + case LiteBackendArtifactResolverStatus::WaitingForReadOnlyGate: return "WaitingForReadOnlyGate"; + case LiteBackendArtifactResolverStatus::WaitingForArtifactSearchRoot: return "WaitingForArtifactSearchRoot"; + case LiteBackendArtifactResolverStatus::WaitingForArtifactCandidate: return "WaitingForArtifactCandidate"; + case LiteBackendArtifactResolverStatus::WaitingForArtifactMetadata: return "WaitingForArtifactMetadata"; + case LiteBackendArtifactResolverStatus::RuntimeActionDisabled: return "RuntimeActionDisabled"; + } + return "Unknown"; +} + +const char* liteBackendArtifactResolverIssueName(LiteBackendArtifactResolverIssue issue) +{ + switch (issue) { + case LiteBackendArtifactResolverIssue::ResolverOwnerMissing: return "ResolverOwnerMissing"; + case LiteBackendArtifactResolverIssue::ReadOnlyGateMissing: return "ReadOnlyGateMissing"; + case LiteBackendArtifactResolverIssue::ArtifactSearchRootMissing: return "ArtifactSearchRootMissing"; + case LiteBackendArtifactResolverIssue::ArtifactSearchRootNotConfigured: return "ArtifactSearchRootNotConfigured"; + case LiteBackendArtifactResolverIssue::ArtifactSearchRootNotDirectory: return "ArtifactSearchRootNotDirectory"; + case LiteBackendArtifactResolverIssue::ArtifactCandidateMissing: return "ArtifactCandidateMissing"; + case LiteBackendArtifactResolverIssue::ArtifactCandidateNotConfigured: return "ArtifactCandidateNotConfigured"; + case LiteBackendArtifactResolverIssue::ArtifactPathMissing: return "ArtifactPathMissing"; + case LiteBackendArtifactResolverIssue::ArtifactMissing: return "ArtifactMissing"; + case LiteBackendArtifactResolverIssue::ArtifactNotRegularFile: return "ArtifactNotRegularFile"; + case LiteBackendArtifactResolverIssue::ArtifactUnreadable: return "ArtifactUnreadable"; + case LiteBackendArtifactResolverIssue::UnsupportedArtifactKind: return "UnsupportedArtifactKind"; + case LiteBackendArtifactResolverIssue::PlatformMismatch: return "PlatformMismatch"; + case LiteBackendArtifactResolverIssue::VersionMissing: return "VersionMissing"; + case LiteBackendArtifactResolverIssue::ProvenanceOwnerMissing: return "ProvenanceOwnerMissing"; + case LiteBackendArtifactResolverIssue::ProvenanceMetadataMissing: return "ProvenanceMetadataMissing"; + case LiteBackendArtifactResolverIssue::ArtifactNotSdxlCompatible: return "ArtifactNotSdxlCompatible"; + case LiteBackendArtifactResolverIssue::ArtifactSymbolsMissing: return "ArtifactSymbolsMissing"; + case LiteBackendArtifactResolverIssue::ArtifactStringOwnershipUnverified: return "ArtifactStringOwnershipUnverified"; + case LiteBackendArtifactResolverIssue::ArtifactShutdownUnavailable: return "ArtifactShutdownUnavailable"; + case LiteBackendArtifactResolverIssue::ExecutableMetadataMissing: return "ExecutableMetadataMissing"; + case LiteBackendArtifactResolverIssue::ArtifactMutationRequested: return "ArtifactMutationRequested"; + case LiteBackendArtifactResolverIssue::SdxlApiRequested: return "SdxlApiRequested"; + case LiteBackendArtifactResolverIssue::ServerConnectivityCheckRequested: return "ServerConnectivityCheckRequested"; + case LiteBackendArtifactResolverIssue::WalletLifecycleRequested: return "WalletLifecycleRequested"; + case LiteBackendArtifactResolverIssue::SyncRequested: return "SyncRequested"; + case LiteBackendArtifactResolverIssue::SyncStatusPollingRequested: return "SyncStatusPollingRequested"; + case LiteBackendArtifactResolverIssue::WorkerQueueRequested: return "WorkerQueueRequested"; + case LiteBackendArtifactResolverIssue::WalletStateMutationRequested: return "WalletStateMutationRequested"; + case LiteBackendArtifactResolverIssue::WalletPersistenceRequested: return "WalletPersistenceRequested"; + case LiteBackendArtifactResolverIssue::UploadRequested: return "UploadRequested"; + case LiteBackendArtifactResolverIssue::SigningRequested: return "SigningRequested"; + case LiteBackendArtifactResolverIssue::PublicationRequested: return "PublicationRequested"; + } + return "Unknown"; +} + +const char* liteBackendActivationReadinessStatusName(LiteBackendActivationReadinessStatus status) +{ + switch (status) { + case LiteBackendActivationReadinessStatus::ReadyForConnectionReadiness: return "ReadyForConnectionReadiness"; + case LiteBackendActivationReadinessStatus::WaitingForActivationOwner: return "WaitingForActivationOwner"; + case LiteBackendActivationReadinessStatus::WaitingForReadOnlyGate: return "WaitingForReadOnlyGate"; + case LiteBackendActivationReadinessStatus::WaitingForLiteBuild: return "WaitingForLiteBuild"; + case LiteBackendActivationReadinessStatus::WaitingForBackendCapability: return "WaitingForBackendCapability"; + case LiteBackendActivationReadinessStatus::WaitingForArtifactResolver: return "WaitingForArtifactResolver"; + case LiteBackendActivationReadinessStatus::WaitingForBackendLink: return "WaitingForBackendLink"; + case LiteBackendActivationReadinessStatus::WaitingForBridge: return "WaitingForBridge"; + case LiteBackendActivationReadinessStatus::WaitingForConnectionSettings: return "WaitingForConnectionSettings"; + case LiteBackendActivationReadinessStatus::RuntimeActionDisabled: return "RuntimeActionDisabled"; + } + return "Unknown"; +} + +const char* liteBackendActivationReadinessIssueName(LiteBackendActivationReadinessIssue issue) +{ + switch (issue) { + case LiteBackendActivationReadinessIssue::ActivationOwnerMissing: return "ActivationOwnerMissing"; + case LiteBackendActivationReadinessIssue::ReadOnlyGateMissing: return "ReadOnlyGateMissing"; + case LiteBackendActivationReadinessIssue::FullNodeBuild: return "FullNodeBuild"; + case LiteBackendActivationReadinessIssue::LiteBackendCapabilityMissing: return "LiteBackendCapabilityMissing"; + case LiteBackendActivationReadinessIssue::ArtifactResolverRejected: return "ArtifactResolverRejected"; + case LiteBackendActivationReadinessIssue::BackendNotLinked: return "BackendNotLinked"; + case LiteBackendActivationReadinessIssue::BridgeUnavailable: return "BridgeUnavailable"; + case LiteBackendActivationReadinessIssue::ConnectionSettingsRejected: return "ConnectionSettingsRejected"; + case LiteBackendActivationReadinessIssue::ArtifactMutationRequested: return "ArtifactMutationRequested"; + case LiteBackendActivationReadinessIssue::SdxlApiRequested: return "SdxlApiRequested"; + case LiteBackendActivationReadinessIssue::ServerConnectivityCheckRequested: return "ServerConnectivityCheckRequested"; + case LiteBackendActivationReadinessIssue::WalletLifecycleRequested: return "WalletLifecycleRequested"; + case LiteBackendActivationReadinessIssue::SyncRequested: return "SyncRequested"; + case LiteBackendActivationReadinessIssue::SyncStatusPollingRequested: return "SyncStatusPollingRequested"; + case LiteBackendActivationReadinessIssue::WorkerQueueRequested: return "WorkerQueueRequested"; + case LiteBackendActivationReadinessIssue::WalletStateMutationRequested: return "WalletStateMutationRequested"; + case LiteBackendActivationReadinessIssue::WalletPersistenceRequested: return "WalletPersistenceRequested"; + case LiteBackendActivationReadinessIssue::UploadRequested: return "UploadRequested"; + case LiteBackendActivationReadinessIssue::SigningRequested: return "SigningRequested"; + case LiteBackendActivationReadinessIssue::PublicationRequested: return "PublicationRequested"; + } + return "Unknown"; +} + +LiteBackendArtifactResolverResult evaluateLiteBackendArtifactResolver( + const LiteBackendArtifactResolverInput& input, + LiteBackendArtifactResolverOptions options) +{ + LiteBackendArtifactResolverResult result; + + result = rejectResolverRuntimeAction(std::move(result), input, options); + if (!result.issues.empty()) return result; + + if (options.requireResolverOwner && !input.resolverOwnerReady) { + return stoppedResolverResult(std::move(result), LiteBackendArtifactResolverStatus::WaitingForResolverOwner, + LiteBackendArtifactResolverIssue::ResolverOwnerMissing, + "lite backend artifact resolver owner is not ready"); + } + result.resolverOwnerAccepted = true; + + if (options.requireReadOnlyGate && !input.readOnlyGateReady) { + return stoppedResolverResult(std::move(result), LiteBackendArtifactResolverStatus::WaitingForReadOnlyGate, + LiteBackendArtifactResolverIssue::ReadOnlyGateMissing, + "lite backend artifact resolver read-only gate is not ready"); + } + result.readOnlyGateAccepted = true; + + auto candidates = expandSearchRoots(input, result, options); + if (!result.issues.empty()) return result; + for (const auto& candidate : input.candidates) candidates.push_back(candidate); + + result.candidateCount = candidates.size(); + if (options.requireArtifactCandidates && candidates.empty()) { + return stoppedResolverResult(std::move(result), LiteBackendArtifactResolverStatus::WaitingForArtifactCandidate, + LiteBackendArtifactResolverIssue::ArtifactCandidateMissing, + "lite backend artifact resolver has no configured candidates"); + } + result.artifactCandidatesAccepted = true; + + CandidateInspectionResult firstRejected; + bool haveRejectedCandidate = false; + for (const auto& candidate : candidates) { + ++result.checkedCandidateCount; + auto inspection = inspectCandidate(input, candidate, options); + if (!inspection.ok) { + ++result.rejectedCandidateCount; + if (!haveRejectedCandidate) { + firstRejected = std::move(inspection); + haveRejectedCandidate = true; + } + continue; + } + + result.ok = true; + result.status = LiteBackendArtifactResolverStatus::ReadyForActivationReadiness; + result.artifact = std::move(inspection.artifact); + result.syncArtifactInput = std::move(inspection.syncArtifactInput); + result.artifactDiscovered = true; + result.artifactMetadataAccepted = true; + result.platformAccepted = true; + result.versionAccepted = !options.requireVersionMetadata || !result.artifact.versionLabel.empty(); + result.provenanceAccepted = !options.requireProvenanceMetadata || provenanceComplete(result.artifact.provenance); + result.sdxlCompatibilityAccepted = !options.requireSdxlCompatibility || result.artifact.sdxlCompatible; + result.symbolMetadataAccepted = !options.requireSdxlSymbols || + (coreSymbolsReady(result.artifact.symbols) && result.artifact.symbols.freeString && result.artifact.symbols.shutdown); + result.executableMetadataAccepted = true; + result.syncArtifactInputProduced = true; + return result; + } + + if (haveRejectedCandidate) { + return stoppedResolverResult(std::move(result), firstRejected.status, firstRejected.issue, firstRejected.message); + } + return stoppedResolverResult(std::move(result), LiteBackendArtifactResolverStatus::WaitingForArtifactCandidate, + LiteBackendArtifactResolverIssue::ArtifactCandidateMissing, + "lite backend artifact resolver did not find any artifact candidates"); +} + +LiteBackendActivationReadinessResult evaluateLiteBackendActivationReadiness( + const LiteBackendActivationReadinessInput& input, + LiteBackendActivationReadinessOptions options) +{ + LiteBackendActivationReadinessResult result; + result.connectionAvailability = LiteConnectionAvailability::BackendUnavailable; + + result = rejectActivationRuntimeAction(std::move(result), input, options); + if (!result.issues.empty()) return result; + + if (options.requireActivationOwner && !input.activationOwnerReady) { + return stoppedActivationResult(std::move(result), LiteBackendActivationReadinessStatus::WaitingForActivationOwner, + LiteBackendActivationReadinessIssue::ActivationOwnerMissing, + "lite backend activation readiness owner is not ready"); + } + result.activationOwnerAccepted = true; + + if (options.requireReadOnlyGate && !input.readOnlyGateReady) { + return stoppedActivationResult(std::move(result), LiteBackendActivationReadinessStatus::WaitingForReadOnlyGate, + LiteBackendActivationReadinessIssue::ReadOnlyGateMissing, + "lite backend activation readiness read-only gate is not ready"); + } + result.readOnlyGateAccepted = true; + + if (options.requireLiteBuild && !isLiteBuild(input.capabilities)) { + result.connectionAvailability = LiteConnectionAvailability::UnsupportedBuild; + return stoppedActivationResult(std::move(result), LiteBackendActivationReadinessStatus::WaitingForLiteBuild, + LiteBackendActivationReadinessIssue::FullNodeBuild, + "lite backend activation readiness requires a lite build"); + } + result.liteBuildAccepted = true; + + if (options.requireLiteBackendCapability && !supportsLiteBackend(input.capabilities)) { + result.connectionAvailability = LiteConnectionAvailability::BackendUnavailable; + return stoppedActivationResult(std::move(result), LiteBackendActivationReadinessStatus::WaitingForBackendCapability, + LiteBackendActivationReadinessIssue::LiteBackendCapabilityMissing, + "lite backend capability is not available for activation readiness"); + } + result.backendCapabilityAccepted = true; + + result.artifactResolverResult = evaluateLiteBackendArtifactResolver(input.artifactResolver, options.resolverOptions); + if (options.requireResolvedArtifact && !result.artifactResolverResult.ok) { + return stoppedActivationResult(std::move(result), LiteBackendActivationReadinessStatus::WaitingForArtifactResolver, + LiteBackendActivationReadinessIssue::ArtifactResolverRejected, + result.artifactResolverResult.error.empty() + ? "lite backend artifact resolver did not produce a usable artifact" + : result.artifactResolverResult.error); + } + result.artifactResolverAccepted = true; + result.syncArtifactInput = result.artifactResolverResult.syncArtifactInput; + + if (options.requireLinkedBackend && !input.backend.linked) { + result.connectionAvailability = LiteConnectionAvailability::BackendUnavailable; + const auto status = backendStatusOrDefault(input.backend, "lite backend is not linked"); + return stoppedActivationResult(std::move(result), LiteBackendActivationReadinessStatus::WaitingForBackendLink, + LiteBackendActivationReadinessIssue::BackendNotLinked, + status.message); + } + result.backendLinkedAccepted = true; + + if (options.requireBridgeAvailable && !input.backend.bridgeAvailable) { + result.connectionAvailability = LiteConnectionAvailability::BridgeUnavailable; + const std::string message = !input.backend.bridgeUnavailableReason.empty() + ? input.backend.bridgeUnavailableReason + : backendStatusOrDefault(input.backend, "lite client bridge is unavailable").message; + return stoppedActivationResult(std::move(result), LiteBackendActivationReadinessStatus::WaitingForBridge, + LiteBackendActivationReadinessIssue::BridgeUnavailable, + message); + } + result.bridgeAccepted = true; + + result.selectedServer = selectLiteServer(input.connectionSettings); + if (options.requireUsableServer && !result.selectedServer.ok) { + result.connectionAvailability = LiteConnectionAvailability::NoUsableServer; + return stoppedActivationResult(std::move(result), LiteBackendActivationReadinessStatus::WaitingForConnectionSettings, + LiteBackendActivationReadinessIssue::ConnectionSettingsRejected, + result.selectedServer.error.empty() + ? "no usable lite server is configured for activation readiness" + : result.selectedServer.error, + WalletBackendState::Error); + } + result.connectionSettingsAccepted = true; + + result.syncBackendInput.linked = input.backend.linked; + result.syncBackendInput.bridgeAvailable = input.backend.bridgeAvailable; + result.syncBackendInput.status = input.backend.status.message.empty() + ? WalletBackendStatus{WalletBackendState::Disconnected, "lite backend bridge readiness accepted", {}, {}, 0.0} + : input.backend.status; + result.syncBackendInput.bridgeUnavailableReason = input.backend.bridgeUnavailableReason; + result.syncReadinessInputsProduced = true; + + result.ok = true; + result.status = LiteBackendActivationReadinessStatus::ReadyForConnectionReadiness; + result.connectionAvailability = LiteConnectionAvailability::Ready; + result.connectionStatus = readyConnectionStatus(result.selectedServer); + result.connectionServiceBoundaryAccepted = true; + return result; +} + +LiteBackendArtifactResolver::LiteBackendArtifactResolver(LiteBackendArtifactResolverOptions options) + : options_(options) +{ +} + +LiteBackendArtifactResolverResult LiteBackendArtifactResolver::resolve( + const LiteBackendArtifactResolverInput& input) const +{ + return evaluateLiteBackendArtifactResolver(input, options_); +} + +LiteBackendActivationReadinessAdapter::LiteBackendActivationReadinessAdapter( + LiteBackendActivationReadinessOptions options) + : options_(options) +{ +} + +LiteBackendActivationReadinessResult LiteBackendActivationReadinessAdapter::evaluate( + const LiteBackendActivationReadinessInput& input) const +{ + return evaluateLiteBackendActivationReadiness(input, options_); +} + +} // namespace dragonx::wallet diff --git a/src/wallet/lite_backend_artifact_resolver.h b/src/wallet/lite_backend_artifact_resolver.h new file mode 100644 index 0000000..85f8395 --- /dev/null +++ b/src/wallet/lite_backend_artifact_resolver.h @@ -0,0 +1,414 @@ +#pragma once + +#include "lite_connection_service.h" +#include "lite_wallet_sync_execution_readiness.h" + +#include +#include +#include + +namespace dragonx::wallet { + +enum class LiteBackendArtifactPlatform { + Current, + Linux, + Windows, + MacOS, + Unknown, +}; + +enum class LiteBackendArtifactKind { + Unknown, + StaticLibrary, + SharedLibrary, + Executable, +}; + +enum class LiteBackendArtifactResolverStatus { + ReadyForActivationReadiness, + WaitingForResolverOwner, + WaitingForReadOnlyGate, + WaitingForArtifactSearchRoot, + WaitingForArtifactCandidate, + WaitingForArtifactMetadata, + RuntimeActionDisabled, +}; + +enum class LiteBackendArtifactResolverIssue { + ResolverOwnerMissing, + ReadOnlyGateMissing, + ArtifactSearchRootMissing, + ArtifactSearchRootNotConfigured, + ArtifactSearchRootNotDirectory, + ArtifactCandidateMissing, + ArtifactCandidateNotConfigured, + ArtifactPathMissing, + ArtifactMissing, + ArtifactNotRegularFile, + ArtifactUnreadable, + UnsupportedArtifactKind, + PlatformMismatch, + VersionMissing, + ProvenanceOwnerMissing, + ProvenanceMetadataMissing, + ArtifactNotSdxlCompatible, + ArtifactSymbolsMissing, + ArtifactStringOwnershipUnverified, + ArtifactShutdownUnavailable, + ExecutableMetadataMissing, + ArtifactMutationRequested, + SdxlApiRequested, + ServerConnectivityCheckRequested, + WalletLifecycleRequested, + SyncRequested, + SyncStatusPollingRequested, + WorkerQueueRequested, + WalletStateMutationRequested, + WalletPersistenceRequested, + UploadRequested, + SigningRequested, + PublicationRequested, +}; + +struct LiteBackendArtifactProvenanceMetadata { + bool ownerReady = false; + bool metadataProvided = false; + std::string source; + std::string builder; + std::string sourceRevision; + std::string artifactSetId; + bool redacted = true; +}; + +struct LiteBackendArtifactSignatureVerificationMetadata { + bool policyDefined = false; + bool requiredForRelease = false; + bool metadataProvided = false; + bool verificationPerformed = false; + bool verified = false; + std::string signatureFormat; + std::string signaturePath; + std::string signatureFileSha256; + std::string verificationTool; + std::string verificationCommand; + std::string keyFingerprint; + std::string certificateIdentity; + std::string certificateIssuer; + std::string transparencyLogUrl; + std::string verifiedArtifactSha256; +}; + +struct LiteBackendArtifactCandidate { + bool configured = false; + std::string artifactPath; + LiteBackendArtifactPlatform platform = LiteBackendArtifactPlatform::Current; + LiteBackendArtifactKind kind = LiteBackendArtifactKind::Unknown; + std::string versionLabel; + LiteBackendArtifactProvenanceMetadata provenance; + LiteBackendArtifactSignatureVerificationMetadata signatureVerification; + bool sdxlCompatible = false; + LiteWalletSdxlArtifactSymbolsInput symbols; + bool executableMetadataRequired = false; +}; + +struct LiteBackendArtifactSearchRoot { + bool configured = false; + std::string rootPath; + LiteBackendArtifactPlatform platform = LiteBackendArtifactPlatform::Current; + LiteBackendArtifactKind kind = LiteBackendArtifactKind::Unknown; + std::string versionLabel; + LiteBackendArtifactProvenanceMetadata provenance; + LiteBackendArtifactSignatureVerificationMetadata signatureVerification; + bool sdxlCompatible = false; + LiteWalletSdxlArtifactSymbolsInput symbols; + bool executableMetadataRequired = false; + std::vector expectedArtifactNames; +}; + +struct LiteBackendArtifactResolverInput { + bool resolverOwnerReady = false; + bool readOnlyGateReady = false; + std::string projectRoot; + LiteBackendArtifactPlatform expectedPlatform = LiteBackendArtifactPlatform::Current; + std::vector searchRoots; + std::vector candidates; + + bool artifactMutationRequested = false; + bool sdxlApiRequested = false; + bool serverConnectivityCheckRequested = false; + bool walletLifecycleRequested = false; + bool syncRequested = false; + bool syncStatusPollingRequested = false; + bool workerQueueRequested = false; + bool walletStateMutationRequested = false; + bool walletPersistenceRequested = false; + bool uploadRequested = false; + bool signingRequested = false; + bool publicationRequested = false; +}; + +struct LiteBackendArtifactResolverOptions { + bool requireResolverOwner = true; + bool requireReadOnlyGate = true; + bool requireArtifactCandidates = true; + bool requireVersionMetadata = true; + bool requireProvenanceMetadata = true; + bool requireSdxlCompatibility = true; + bool requireSdxlSymbols = true; + bool rejectArtifactMutation = true; + bool rejectSdxlApiCalls = true; + bool rejectServerConnectivityChecks = true; + bool rejectWalletLifecycle = true; + bool rejectSync = true; + bool rejectSyncStatusPolling = true; + bool rejectWorkerQueue = true; + bool rejectWalletStateMutation = true; + bool rejectWalletPersistence = true; + bool rejectUpload = true; + bool rejectSigning = true; + bool rejectPublication = true; +}; + +struct LiteBackendResolvedArtifact { + bool found = false; + std::string artifactPath; + LiteBackendArtifactPlatform platform = LiteBackendArtifactPlatform::Unknown; + LiteBackendArtifactKind kind = LiteBackendArtifactKind::Unknown; + std::string versionLabel; + LiteBackendArtifactProvenanceMetadata provenance; + LiteBackendArtifactSignatureVerificationMetadata signatureVerification; + bool exists = false; + bool regularFile = false; + bool readable = false; + bool executable = false; + bool sdxlCompatible = false; + LiteWalletSdxlArtifactSymbolsInput symbols; + std::size_t artifactSizeBytes = 0; +}; + +struct LiteBackendArtifactResolverIssueInfo { + LiteBackendArtifactResolverIssue issue = LiteBackendArtifactResolverIssue::ArtifactCandidateMissing; + std::string message; +}; + +struct LiteBackendArtifactResolverResult { + bool ok = false; + bool readOnlyArtifactDiscovery = true; + bool artifactMetadataReadOnly = true; + bool provenanceReadOnly = true; + bool executableMetadataReadOnly = true; + bool noArtifactMutation = true; + bool noSdxlCalls = true; + bool noServerConnectivityChecked = true; + bool noWalletCreated = true; + bool noWalletOpened = true; + bool noWalletRestored = true; + bool noSyncStarted = true; + bool noSyncStatusPolled = true; + bool noWorkerQueueEnqueue = true; + bool noWalletStateMutation = true; + bool noWalletPersistence = true; + bool noUpload = true; + bool noSigning = true; + bool noPublication = true; + + bool resolverOwnerAccepted = false; + bool readOnlyGateAccepted = false; + bool artifactSearchRootsAccepted = false; + bool artifactCandidatesAccepted = false; + bool artifactDiscovered = false; + bool artifactMetadataAccepted = false; + bool platformAccepted = false; + bool versionAccepted = false; + bool provenanceAccepted = false; + bool sdxlCompatibilityAccepted = false; + bool symbolMetadataAccepted = false; + bool executableMetadataAccepted = false; + bool syncArtifactInputProduced = false; + + std::size_t searchRootCount = 0; + std::size_t candidateCount = 0; + std::size_t checkedCandidateCount = 0; + std::size_t rejectedCandidateCount = 0; + + LiteBackendArtifactResolverStatus status = LiteBackendArtifactResolverStatus::WaitingForResolverOwner; + LiteBackendResolvedArtifact artifact; + LiteWalletSdxlArtifactInput syncArtifactInput; + std::vector issues; + std::string error; +}; + +enum class LiteBackendActivationReadinessStatus { + ReadyForConnectionReadiness, + WaitingForActivationOwner, + WaitingForReadOnlyGate, + WaitingForLiteBuild, + WaitingForBackendCapability, + WaitingForArtifactResolver, + WaitingForBackendLink, + WaitingForBridge, + WaitingForConnectionSettings, + RuntimeActionDisabled, +}; + +enum class LiteBackendActivationReadinessIssue { + ActivationOwnerMissing, + ReadOnlyGateMissing, + FullNodeBuild, + LiteBackendCapabilityMissing, + ArtifactResolverRejected, + BackendNotLinked, + BridgeUnavailable, + ConnectionSettingsRejected, + ArtifactMutationRequested, + SdxlApiRequested, + ServerConnectivityCheckRequested, + WalletLifecycleRequested, + SyncRequested, + SyncStatusPollingRequested, + WorkerQueueRequested, + WalletStateMutationRequested, + WalletPersistenceRequested, + UploadRequested, + SigningRequested, + PublicationRequested, +}; + +struct LiteBackendBridgeReadinessInput { + bool linked = false; + bool bridgeAvailable = false; + WalletBackendStatus status; + std::string bridgeUnavailableReason; +}; + +struct LiteBackendActivationReadinessInput { + WalletCapabilities capabilities; + LiteConnectionSettings connectionSettings; + LiteBackendArtifactResolverInput artifactResolver; + LiteBackendBridgeReadinessInput backend; + bool activationOwnerReady = false; + bool readOnlyGateReady = false; + + bool artifactMutationRequested = false; + bool sdxlApiRequested = false; + bool serverConnectivityCheckRequested = false; + bool walletLifecycleRequested = false; + bool syncRequested = false; + bool syncStatusPollingRequested = false; + bool workerQueueRequested = false; + bool walletStateMutationRequested = false; + bool walletPersistenceRequested = false; + bool uploadRequested = false; + bool signingRequested = false; + bool publicationRequested = false; +}; + +struct LiteBackendActivationReadinessOptions { + bool requireActivationOwner = true; + bool requireReadOnlyGate = true; + bool requireLiteBuild = true; + bool requireLiteBackendCapability = true; + bool requireResolvedArtifact = true; + bool requireLinkedBackend = true; + bool requireBridgeAvailable = true; + bool requireUsableServer = true; + bool rejectArtifactMutation = true; + bool rejectSdxlApiCalls = true; + bool rejectServerConnectivityChecks = true; + bool rejectWalletLifecycle = true; + bool rejectSync = true; + bool rejectSyncStatusPolling = true; + bool rejectWorkerQueue = true; + bool rejectWalletStateMutation = true; + bool rejectWalletPersistence = true; + bool rejectUpload = true; + bool rejectSigning = true; + bool rejectPublication = true; + LiteBackendArtifactResolverOptions resolverOptions; +}; + +struct LiteBackendActivationReadinessIssueInfo { + LiteBackendActivationReadinessIssue issue = LiteBackendActivationReadinessIssue::ActivationOwnerMissing; + std::string message; +}; + +struct LiteBackendActivationReadinessResult { + bool ok = false; + bool readOnlyActivation = true; + bool artifactDiscoveryReadOnly = true; + bool connectionReadinessOnly = true; + bool noBridgeCalls = true; + bool noArtifactMutation = true; + bool noSdxlCalls = true; + bool noServerConnectivityChecked = true; + bool noWalletCreated = true; + bool noWalletOpened = true; + bool noWalletRestored = true; + bool noSyncStarted = true; + bool noSyncStatusPolled = true; + bool noWorkerQueueEnqueue = true; + bool noWalletStateMutation = true; + bool noWalletPersistence = true; + bool noUpload = true; + bool noSigning = true; + bool noPublication = true; + + bool activationOwnerAccepted = false; + bool readOnlyGateAccepted = false; + bool liteBuildAccepted = false; + bool backendCapabilityAccepted = false; + bool artifactResolverAccepted = false; + bool backendLinkedAccepted = false; + bool bridgeAccepted = false; + bool connectionSettingsAccepted = false; + bool connectionServiceBoundaryAccepted = false; + bool syncReadinessInputsProduced = false; + + LiteBackendActivationReadinessStatus status = LiteBackendActivationReadinessStatus::WaitingForActivationOwner; + LiteBackendArtifactResolverResult artifactResolverResult; + LiteWalletSdxlArtifactInput syncArtifactInput; + LiteWalletLinkedBackendReadinessInput syncBackendInput; + LiteConnectionAvailability connectionAvailability = LiteConnectionAvailability::BackendUnavailable; + LiteServerSelectionResult selectedServer; + WalletBackendStatus connectionStatus; + std::vector issues; + std::string error; +}; + +LiteBackendArtifactPlatform currentLiteBackendArtifactPlatform(); +const char* liteBackendArtifactPlatformName(LiteBackendArtifactPlatform platform); +const char* liteBackendArtifactKindName(LiteBackendArtifactKind kind); +const char* liteBackendArtifactResolverStatusName(LiteBackendArtifactResolverStatus status); +const char* liteBackendArtifactResolverIssueName(LiteBackendArtifactResolverIssue issue); +const char* liteBackendActivationReadinessStatusName(LiteBackendActivationReadinessStatus status); +const char* liteBackendActivationReadinessIssueName(LiteBackendActivationReadinessIssue issue); + +LiteBackendArtifactResolverResult evaluateLiteBackendArtifactResolver( + const LiteBackendArtifactResolverInput& input, + LiteBackendArtifactResolverOptions options = {}); + +LiteBackendActivationReadinessResult evaluateLiteBackendActivationReadiness( + const LiteBackendActivationReadinessInput& input, + LiteBackendActivationReadinessOptions options = {}); + +class LiteBackendArtifactResolver { +public: + explicit LiteBackendArtifactResolver(LiteBackendArtifactResolverOptions options = {}); + + LiteBackendArtifactResolverResult resolve(const LiteBackendArtifactResolverInput& input) const; + +private: + LiteBackendArtifactResolverOptions options_; +}; + +class LiteBackendActivationReadinessAdapter { +public: + explicit LiteBackendActivationReadinessAdapter(LiteBackendActivationReadinessOptions options = {}); + + LiteBackendActivationReadinessResult evaluate(const LiteBackendActivationReadinessInput& input) const; + +private: + LiteBackendActivationReadinessOptions options_; +}; + +} // namespace dragonx::wallet diff --git a/src/wallet/lite_bridge_runtime.cpp b/src/wallet/lite_bridge_runtime.cpp new file mode 100644 index 0000000..a10334a --- /dev/null +++ b/src/wallet/lite_bridge_runtime.cpp @@ -0,0 +1,17669 @@ +#include "lite_bridge_runtime.h" + +#ifndef DRAGONX_ENABLE_LITE_BACKEND +#define DRAGONX_ENABLE_LITE_BACKEND 0 +#endif + +#if DRAGONX_ENABLE_LITE_BACKEND +extern "C" { +bool litelib_wallet_exists(const char* chain_name); +char* litelib_initialize_new(bool dangerous, const char* server); +char* litelib_initialize_new_from_phrase(bool dangerous, + const char* server, + const char* seed, + unsigned long long birthday, + unsigned long long number, + bool overwrite); +char* litelib_initialize_existing(bool dangerous, const char* server); +char* litelib_execute(const char* command, const char* args); +void litelib_rust_free_string(char* value); +bool litelib_check_server_online(const char* server); +void litelib_shutdown(); +} +#endif + +#include +#include +#include + +namespace dragonx::wallet { + +struct LiteBridgeRuntimeTeardownState { + LiteClientBridgeApi::ShutdownFn shutdown = nullptr; + LiteBridgeRuntimeDynamicLibraryHandle dynamicLibraryHandle; + std::size_t outstandingOwnedStrings = 0; + bool shutdownRequested = false; + bool shutdownCalled = false; + bool dynamicLibraryUnloadCalled = false; + bool dynamicLibraryUnloadDeferred = true; + LiteBridgeRuntimeStatus status = LiteBridgeRuntimeStatus::Ready; + + void retainOwnedString() + { + ++outstandingOwnedStrings; + } + + void releaseOwnedString() + { + if (outstandingOwnedStrings > 0) --outstandingOwnedStrings; + if (shutdownRequested && outstandingOwnedStrings == 0) callShutdown(); + } + + void requestShutdown() + { + if (shutdownCalled) return; + shutdownRequested = true; + if (outstandingOwnedStrings > 0) { + status = LiteBridgeRuntimeStatus::ShuttingDown; + return; + } + callShutdown(); + } + + void callShutdown() + { + if (shutdownCalled) return; + status = LiteBridgeRuntimeStatus::ShuttingDown; + if (shutdown) shutdown(); + shutdownCalled = true; + callDynamicLibraryUnload(); + status = LiteBridgeRuntimeStatus::Shutdown; + } + + void callDynamicLibraryUnload() + { + if (!dynamicLibraryHandle.present || dynamicLibraryUnloadCalled) return; + if (dynamicLibraryHandle.unload) { + dynamicLibraryHandle.unload(dynamicLibraryHandle.handleLabel.c_str()); + } + dynamicLibraryUnloadCalled = true; + dynamicLibraryHandle.present = false; + dynamicLibraryUnloadDeferred = false; + } +}; + +namespace { + +constexpr const char* kImportedLinkedSource = "imported-linked"; +constexpr const char* kFakeDynamicLibrarySource = "fake-dynamic-library"; + +void addIssue(LiteBridgeRuntimeBindingResult& result, + LiteBridgeRuntimeIssue issue, + const std::string& message) +{ + result.issues.push_back({issue, message}); + if (result.error.empty()) result.error = message; +} + +void addBinding(LiteBridgeRuntimeSymbolTable& table, + const std::string& logicalName, + const std::string& abiName, + bool available) +{ + table.bindings.push_back({logicalName, abiName, true, available, table.source}); + ++table.requiredSymbolCount; + if (available) ++table.availableSymbolCount; +} + +bool tableHasAnySymbol(const LiteBridgeRuntimeSymbolTable& table) +{ + return table.api.walletExists || + table.api.initializeNew || + table.api.initializeNewFromPhrase || + table.api.initializeExisting || + table.api.execute || + table.api.freeString || + table.api.checkServerOnline || + table.api.shutdown; +} + +void collectMissingSymbols(const LiteBridgeRuntimeSymbolTable& table, + std::vector& missingSymbols) +{ + for (const auto& binding : table.bindings) { + if (binding.required && !binding.available) missingSymbols.push_back(binding.logicalName); + } +} + +bool rejectRuntimeActions(const LiteBridgeRuntimeBindingInput& input, + LiteBridgeRuntimeBindingResult& result) +{ + struct RejectedAction { + bool requested; + LiteBridgeRuntimeIssue issue; + const char* message; + }; + + const RejectedAction actions[] = { + {input.artifactMutationRequested, LiteBridgeRuntimeIssue::ArtifactMutationRequested, "artifact mutation is disabled for lite bridge runtime binding"}, + {input.dynamicLibraryLoadRequested, LiteBridgeRuntimeIssue::DynamicLibraryLoadRequested, "dynamic library load is disabled for batch 1"}, + {input.dynamicLibraryUnloadRequested, LiteBridgeRuntimeIssue::DynamicLibraryUnloadRequested, "dynamic library unload is disabled for batch 1"}, + {input.symbolResolutionRequested, LiteBridgeRuntimeIssue::SymbolResolutionRequested, "platform symbol resolution is disabled for batch 1"}, + {input.sdxlCallRequested, LiteBridgeRuntimeIssue::SdxlCallRequested, "SDXL calls are disabled for lite bridge runtime binding"}, + {input.bridgeCallRequested, LiteBridgeRuntimeIssue::BridgeCallRequested, "bridge calls are disabled for lite bridge runtime binding"}, + {input.serverConnectivityCheckRequested, LiteBridgeRuntimeIssue::ServerConnectivityCheckRequested, "server connectivity checks are disabled for lite bridge runtime binding"}, + {input.walletLifecycleRequested, LiteBridgeRuntimeIssue::WalletLifecycleRequested, "wallet lifecycle execution is disabled for lite bridge runtime binding"}, + {input.syncRequested, LiteBridgeRuntimeIssue::SyncRequested, "sync execution is disabled for lite bridge runtime binding"}, + {input.syncStatusPollingRequested, LiteBridgeRuntimeIssue::SyncStatusPollingRequested, "syncstatus polling is disabled for lite bridge runtime binding"}, + {input.workerQueueRequested, LiteBridgeRuntimeIssue::WorkerQueueRequested, "worker queue enqueue is disabled for lite bridge runtime binding"}, + {input.walletStateMutationRequested, LiteBridgeRuntimeIssue::WalletStateMutationRequested, "WalletState mutation is disabled for lite bridge runtime binding"}, + {input.walletPersistenceRequested, LiteBridgeRuntimeIssue::WalletPersistenceRequested, "wallet persistence is disabled for lite bridge runtime binding"}, + {input.settingsWriteRequested, LiteBridgeRuntimeIssue::SettingsWriteRequested, "settings writes are disabled for lite bridge runtime binding"}, + {input.sendImportExportRequested, LiteBridgeRuntimeIssue::SendImportExportRequested, "send/import/export execution is disabled for lite bridge runtime binding"}, + }; + + for (const auto& action : actions) { + if (!action.requested) continue; + result.status = LiteBridgeRuntimeStatus::Failed; + addIssue(result, action.issue, action.message); + result.summary = "lite_bridge_runtime=blocked; reason=runtime_action_requested"; + return true; + } + + return false; +} + +std::string sourceOrDefault(const std::string& source) +{ + return source.empty() ? "provided" : source; +} + +bool looksLikeError(const std::string& value) +{ + return value.rfind("Error:", 0) == 0; +} + +bool isFakeSymbolSource(const std::string& source) +{ + return source.rfind("fake", 0) == 0; +} + +void wipeString(std::string& value) +{ + std::fill(value.begin(), value.end(), '\0'); + value.clear(); +} + +std::string dryDispatchBlockedSummary(const char* reason) +{ + return std::string("lite_bridge_runtime_dry_dispatch=blocked; reason=") + reason; +} + +std::string fakeDynamicLoaderBlockedSummary(const char* reason) +{ + return std::string("lite_bridge_runtime_fake_dynamic_loader=blocked; reason=") + reason; +} + +std::string platformLoaderReviewBlockedSummary(const char* reason) +{ + return std::string("lite_bridge_runtime_platform_loader_review=blocked; reason=") + reason; +} + +std::string dynamicLoaderSmokeGateBlockedSummary(const char* reason) +{ + return std::string("lite_bridge_runtime_dynamic_loader_smoke_gate=blocked; reason=") + reason; +} + +std::string sharedArtifactSmokeEvidenceAcquisitionBlockedSummary(const char* reason) +{ + return std::string("lite_bridge_runtime_shared_artifact_smoke_evidence_acquisition=blocked; reason=") + reason; +} + +std::string platformDynamicLoaderAdapterContractBlockedSummary(const char* reason) +{ + return std::string("lite_bridge_runtime_platform_dynamic_loader_adapter_contract=blocked; reason=") + reason; +} + +std::string platformDynamicLoaderNoOpAdapterSeamBlockedSummary(const char* reason) +{ + return std::string("lite_bridge_runtime_platform_dynamic_loader_noop_adapter_seam=blocked; reason=") + reason; +} + +std::string platformDynamicLoaderRealAdapterImplementationReviewBlockedSummary(const char* reason) +{ + return std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_implementation_review=blocked; reason=") + reason; +} + +std::string platformDynamicLoaderRealAdapterDisabledScaffoldBlockedSummary(const char* reason) +{ + return std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_disabled_scaffold=blocked; reason=") + reason; +} + +std::string platformDynamicLoaderRealAdapterLoadOnlyExecutionPreflightBlockedSummary(const char* reason) +{ + return std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_preflight=blocked; reason=") + reason; +} + +std::string platformDynamicLoaderRealAdapterLoadOnlyExecutionApprovalGateBlockedSummary(const char* reason) +{ + return std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_approval_gate=blocked; reason=") + reason; +} + +std::string platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledOwnerHandoffBlockedSummary(const char* reason) +{ + return std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_owner_handoff=blocked; reason=") + reason; +} + +std::string platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackBindingBlockedSummary(const char* reason) +{ + return std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_binding=blocked; reason=") + reason; +} + +std::string platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackPreInvocationGuardBlockedSummary(const char* reason) +{ + return std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_pre_invocation_guard=blocked; reason=") + reason; +} + +std::string platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultBlockedSummary(const char* reason) +{ + return std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_result=blocked; reason=") + reason; +} + +std::string platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultPropagationBlockedSummary(const char* reason) +{ + return std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_result_propagation=blocked; reason=") + reason; +} + +std::string platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessBlockedSummary(const char* reason) +{ + return std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness=blocked; reason=") + reason; +} + +std::string platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardBlockedSummary(const char* reason) +{ + return std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard=blocked; reason=") + reason; +} + +std::string platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffBlockedSummary(const char* reason) +{ + return std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_result_handoff=blocked; reason=") + reason; +} + +std::string platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionBlockedSummary(const char* reason) +{ + return std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_result_handoff_readiness_projection=blocked; reason=") + reason; +} + +std::string platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary(const char* reason) +{ + return std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_result_handoff_readiness_projection_status_handoff=blocked; reason=") + reason; +} + +std::string platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlockedSummary(const char* reason) +{ + return std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_result_handoff_readiness_projection_status_handoff_publication_guard=blocked; reason=") + reason; +} + +std::string platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlockedSummary(const char* reason) +{ + return std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff=blocked; reason=") + reason; +} + +std::string platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlockedSummary(const char* reason) +{ + return std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection=blocked; reason=") + reason; +} + +std::string platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary(const char* reason) +{ + return std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff=blocked; reason=") + reason; +} + +std::string platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlockedSummary(const char* reason) +{ + return std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard=blocked; reason=") + reason; +} + +std::string platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlockedSummary(const char* reason) +{ + return std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff=blocked; reason=") + reason; +} + +std::string platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlockedSummary(const char* reason) +{ + return std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection=blocked; reason=") + reason; +} + +std::string platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary(const char* reason) +{ + return std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff=blocked; reason=") + reason; +} + +std::string platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlockedSummary(const char* reason) +{ + return std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard=blocked; reason=") + reason; +} + +std::string platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlockedSummary(const char* reason) +{ + return std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff=blocked; reason=") + reason; +} + +std::string platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlockedSummary(const char* reason) +{ + return std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection=blocked; reason=") + reason; +} + +std::string platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary(const char* reason) +{ + return std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff=blocked; reason=") + reason; +} + +std::string dynamicLoaderSourceOrDefault(const std::string& source) +{ + return source.empty() ? kFakeDynamicLibrarySource : source; +} + +std::string normalizedPlatform(std::string platform) +{ + std::transform(platform.begin(), platform.end(), platform.begin(), [](unsigned char value) { + return static_cast(std::tolower(value)); + }); + return platform; +} + +bool isLinuxPlatform(const std::string& platform) +{ + return platform == "linux"; +} + +bool isWindowsPlatform(const std::string& platform) +{ + return platform == "windows" || platform == "win32" || platform == "win64"; +} + +bool isMacosPlatform(const std::string& platform) +{ + return platform == "macos" || platform == "darwin"; +} + +void addPlatformLoaderReviewIssue(LiteBridgeRuntimePlatformLoaderReviewResult& result, + const std::string& message) +{ + result.issues.push_back(message); + if (result.error.empty()) result.error = message; +} + +void addDynamicLoaderSmokeGateIssue(LiteBridgeRuntimeDynamicLoaderSmokeGateResult& result, + const std::string& message) +{ + result.issues.push_back(message); + if (result.error.empty()) result.error = message; +} + +void addSharedArtifactSmokeEvidenceAcquisitionIssue( + LiteBridgeRuntimeSharedArtifactSmokeEvidenceAcquisitionResult& result, + const std::string& message) +{ + result.issues.push_back(message); + if (result.error.empty()) result.error = message; +} + +void addPlatformDynamicLoaderAdapterContractIssue( + LiteBridgeRuntimePlatformDynamicLoaderAdapterContractResult& result, + const std::string& message) +{ + result.issues.push_back(message); + if (result.error.empty()) result.error = message; +} + +void addPlatformDynamicLoaderNoOpAdapterSeamIssue( + LiteBridgeRuntimePlatformDynamicLoaderNoOpAdapterSeamResult& result, + const std::string& message) +{ + result.issues.push_back(message); + if (result.error.empty()) result.error = message; +} + +void addPlatformDynamicLoaderRealAdapterImplementationReviewIssue( + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterImplementationReviewResult& result, + const std::string& message) +{ + result.issues.push_back(message); + if (result.error.empty()) result.error = message; +} + +void addPlatformDynamicLoaderRealAdapterDisabledScaffoldIssue( + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterDisabledScaffoldResult& result, + const std::string& message) +{ + result.issues.push_back(message); + if (result.error.empty()) result.error = message; +} + +void addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionPreflightIssue( + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionPreflightResult& result, + const std::string& message) +{ + result.issues.push_back(message); + if (result.error.empty()) result.error = message; +} + +void addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionApprovalGateIssue( + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionApprovalGateResult& result, + const std::string& message) +{ + result.issues.push_back(message); + if (result.error.empty()) result.error = message; +} + +void addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledOwnerHandoffIssue( + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledOwnerHandoffResult& result, + const std::string& message) +{ + result.issues.push_back(message); + if (result.error.empty()) result.error = message; +} + +void addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackBindingIssue( + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackBindingResult& result, + const std::string& message) +{ + result.issues.push_back(message); + if (result.error.empty()) result.error = message; +} + +void addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackPreInvocationGuardIssue( + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackPreInvocationGuardResult& result, + const std::string& message) +{ + result.issues.push_back(message); + if (result.error.empty()) result.error = message; +} + +void addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultIssue( + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultResult& result, + const std::string& message) +{ + result.issues.push_back(message); + if (result.error.empty()) result.error = message; +} + +void addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultPropagationIssue( + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultPropagationResult& result, + const std::string& message) +{ + result.issues.push_back(message); + if (result.error.empty()) result.error = message; +} + +void addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessIssue( + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessResult& result, + const std::string& message) +{ + result.issues.push_back(message); + if (result.error.empty()) result.error = message; +} + +void addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardIssue( + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResult& result, + const std::string& message) +{ + result.issues.push_back(message); + if (result.error.empty()) result.error = message; +} + +void addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffIssue( + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffResult& result, + const std::string& message) +{ + result.issues.push_back(message); + if (result.error.empty()) result.error = message; +} + +void addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionIssue( + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionResult& result, + const std::string& message) +{ + result.issues.push_back(message); + if (result.error.empty()) result.error = message; +} + +void addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffIssue( + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffResult& result, + const std::string& message) +{ + result.issues.push_back(message); + if (result.error.empty()) result.error = message; +} + +void addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardIssue( + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResult& result, + const std::string& message) +{ + result.issues.push_back(message); + if (result.error.empty()) result.error = message; +} + +void addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffIssue( + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffResult& result, + const std::string& message) +{ + result.issues.push_back(message); + if (result.error.empty()) result.error = message; +} + +void addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionIssue( + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionResult& result, + const std::string& message) +{ + result.issues.push_back(message); + if (result.error.empty()) result.error = message; +} + +void addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffIssue( + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffResult& result, + const std::string& message) +{ + result.issues.push_back(message); + if (result.error.empty()) result.error = message; +} + +void addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardIssue( + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResult& result, + const std::string& message) +{ + result.issues.push_back(message); + if (result.error.empty()) result.error = message; +} + +void addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffIssue( + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffResult& result, + const std::string& message) +{ + result.issues.push_back(message); + if (result.error.empty()) result.error = message; +} + +void addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionIssue( + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionResult& result, + const std::string& message) +{ + result.issues.push_back(message); + if (result.error.empty()) result.error = message; +} + +void addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffIssue( + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffResult& result, + const std::string& message) +{ + result.issues.push_back(message); + if (result.error.empty()) result.error = message; +} + +void addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardIssue( + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResult& result, + const std::string& message) +{ + result.issues.push_back(message); + if (result.error.empty()) result.error = message; +} + +void addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffIssue( + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffResult& result, + const std::string& message) +{ + result.issues.push_back(message); + if (result.error.empty()) result.error = message; +} + +void addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionIssue( + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionResult& result, + const std::string& message) +{ + result.issues.push_back(message); + if (result.error.empty()) result.error = message; +} + +void addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffIssue( + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffResult& result, + const std::string& message) +{ + result.issues.push_back(message); + if (result.error.empty()) result.error = message; +} + +LiteBridgeRuntimePlatformDynamicLoaderAdapterCallResult noOpAdapterDisabledResult( + const char* operation) +{ + LiteBridgeRuntimePlatformDynamicLoaderAdapterCallResult result; + result.ok = true; + result.disabled = true; + result.summary = std::string("lite_bridge_runtime_platform_dynamic_loader_noop_adapter=") + + operation + "; result=disabled"; + return result; +} + +LiteBridgeRuntimePlatformDynamicLoaderAdapterCallResult noOpAdapterLoad( + const char*, const char*) +{ + return noOpAdapterDisabledResult("load"); +} + +LiteBridgeRuntimePlatformDynamicLoaderAdapterCallResult noOpAdapterUnload( + const char*, const char*) +{ + return noOpAdapterDisabledResult("unload"); +} + +LiteBridgeRuntimePlatformDynamicLoaderAdapterCallResult noOpAdapterSymbolLookup( + const char*, const char*) +{ + return noOpAdapterDisabledResult("symbol_lookup"); +} + +LiteBridgeRuntimePlatformDynamicLoaderAdapterCallResult realAdapterDisabledScaffoldResult( + const char* operation) +{ + LiteBridgeRuntimePlatformDynamicLoaderAdapterCallResult result; + result.ok = true; + result.disabled = true; + result.summary = std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_disabled_scaffold=") + + operation + "; result=disabled"; + return result; +} + +LiteBridgeRuntimePlatformDynamicLoaderAdapterCallResult realAdapterDisabledLoad( + const char*, const char*) +{ + return realAdapterDisabledScaffoldResult("load"); +} + +LiteBridgeRuntimePlatformDynamicLoaderAdapterCallResult realAdapterDisabledUnload( + const char*, const char*) +{ + return realAdapterDisabledScaffoldResult("unload"); +} + +LiteBridgeRuntimePlatformDynamicLoaderAdapterCallResult realAdapterDisabledSymbolLookup( + const char*, const char*) +{ + return realAdapterDisabledScaffoldResult("symbol_lookup"); +} + +bool adapterCallStayedDisabled( + const LiteBridgeRuntimePlatformDynamicLoaderAdapterCallResult& callResult) +{ + return callResult.ok && + callResult.disabled && + callResult.noPlatformDynamicLibraryLoaded && + callResult.noPlatformDynamicLibraryUnloaded && + callResult.noPlatformSymbolResolution && + callResult.noBridgeCalls && + callResult.noSdxlCalls && + callResult.noServerConnectivityChecked && + callResult.noWalletLifecycle && + callResult.noSyncStarted && + callResult.noSyncStatusPolled && + callResult.noWorkerQueueEnqueue && + callResult.noWalletStateMutation && + callResult.noWalletPersistence && + callResult.noSettingsPersistence && + callResult.noSendImportExportExecution && + callResult.noArtifactMutation; +} + +} // namespace + +const char* liteBridgeRuntimeLinkModeName(LiteBridgeRuntimeLinkMode linkMode) +{ + switch (linkMode) { + case LiteBridgeRuntimeLinkMode::ImportedLinked: return "imported-linked"; + case LiteBridgeRuntimeLinkMode::DynamicLibrary: return "dynamic-library"; + } + return "unknown"; +} + +const char* liteBridgeRuntimeStatusName(LiteBridgeRuntimeStatus status) +{ + switch (status) { + case LiteBridgeRuntimeStatus::Unavailable: return "Unavailable"; + case LiteBridgeRuntimeStatus::Configured: return "Configured"; + case LiteBridgeRuntimeStatus::BindingSymbols: return "BindingSymbols"; + case LiteBridgeRuntimeStatus::Ready: return "Ready"; + case LiteBridgeRuntimeStatus::Failed: return "Failed"; + case LiteBridgeRuntimeStatus::ShuttingDown: return "ShuttingDown"; + case LiteBridgeRuntimeStatus::Shutdown: return "Shutdown"; + } + return "Unknown"; +} + +const char* liteBridgeRuntimeIssueName(LiteBridgeRuntimeIssue issue) +{ + switch (issue) { + case LiteBridgeRuntimeIssue::ArtifactContractRejected: return "ArtifactContractRejected"; + case LiteBridgeRuntimeIssue::ActivationNotRequested: return "ActivationNotRequested"; + case LiteBridgeRuntimeIssue::LinkModeNotImported: return "LinkModeNotImported"; + case LiteBridgeRuntimeIssue::DynamicLibraryDeferred: return "DynamicLibraryDeferred"; + case LiteBridgeRuntimeIssue::DynamicLibraryFakeLoaderFailed: return "DynamicLibraryFakeLoaderFailed"; + case LiteBridgeRuntimeIssue::DynamicLibraryNoOpAdapterSeamFailed: return "DynamicLibraryNoOpAdapterSeamFailed"; + case LiteBridgeRuntimeIssue::DynamicLibraryRealAdapterDisabledScaffoldFailed: return "DynamicLibraryRealAdapterDisabledScaffoldFailed"; + case LiteBridgeRuntimeIssue::ImportedBackendNotLinked: return "ImportedBackendNotLinked"; + case LiteBridgeRuntimeIssue::SymbolTableMissing: return "SymbolTableMissing"; + case LiteBridgeRuntimeIssue::RequiredSymbolMissing: return "RequiredSymbolMissing"; + case LiteBridgeRuntimeIssue::ArtifactMutationRequested: return "ArtifactMutationRequested"; + case LiteBridgeRuntimeIssue::DynamicLibraryLoadRequested: return "DynamicLibraryLoadRequested"; + case LiteBridgeRuntimeIssue::DynamicLibraryUnloadRequested: return "DynamicLibraryUnloadRequested"; + case LiteBridgeRuntimeIssue::SymbolResolutionRequested: return "SymbolResolutionRequested"; + case LiteBridgeRuntimeIssue::SdxlCallRequested: return "SdxlCallRequested"; + case LiteBridgeRuntimeIssue::BridgeCallRequested: return "BridgeCallRequested"; + case LiteBridgeRuntimeIssue::ServerConnectivityCheckRequested: return "ServerConnectivityCheckRequested"; + case LiteBridgeRuntimeIssue::WalletLifecycleRequested: return "WalletLifecycleRequested"; + case LiteBridgeRuntimeIssue::SyncRequested: return "SyncRequested"; + case LiteBridgeRuntimeIssue::SyncStatusPollingRequested: return "SyncStatusPollingRequested"; + case LiteBridgeRuntimeIssue::WorkerQueueRequested: return "WorkerQueueRequested"; + case LiteBridgeRuntimeIssue::WalletStateMutationRequested: return "WalletStateMutationRequested"; + case LiteBridgeRuntimeIssue::WalletPersistenceRequested: return "WalletPersistenceRequested"; + case LiteBridgeRuntimeIssue::SettingsWriteRequested: return "SettingsWriteRequested"; + case LiteBridgeRuntimeIssue::SendImportExportRequested: return "SendImportExportRequested"; + } + return "Unknown"; +} + +const char* liteBridgeRuntimeDryDispatchOperationName(LiteBridgeRuntimeDryDispatchOperation operation) +{ + switch (operation) { + case LiteBridgeRuntimeDryDispatchOperation::WalletExists: return "walletExists"; + case LiteBridgeRuntimeDryDispatchOperation::CheckServerOnline: return "checkServerOnline"; + case LiteBridgeRuntimeDryDispatchOperation::Execute: return "execute"; + case LiteBridgeRuntimeDryDispatchOperation::InitializeNew: return "initializeNew"; + case LiteBridgeRuntimeDryDispatchOperation::InitializeExisting: return "initializeExisting"; + case LiteBridgeRuntimeDryDispatchOperation::InitializeNewFromPhrase: return "initializeNewFromPhrase"; + case LiteBridgeRuntimeDryDispatchOperation::Shutdown: return "shutdown"; + } + return "unknown"; +} + +std::vector liteBridgeRuntimeRequiredSymbolLogicalNames() +{ + return { + "walletExists", + "initializeNew", + "initializeNewFromPhrase", + "initializeExisting", + "execute", + "freeString", + "checkServerOnline", + "shutdown", + }; +} + +LiteBridgeRuntimeConfig liteBridgeRuntimeConfigFromContractResult( + const LiteBackendArtifactContractResult& result, + bool activationRequested) +{ + LiteBridgeRuntimeConfig config; + config.activationRequested = activationRequested; + config.linkMode = LiteBridgeRuntimeLinkMode::ImportedLinked; + config.abiVersion = liteBackendArtifactContractSupportedAbiVersion(); + config.artifactPath = result.resolverCandidate.artifactPath; + config.artifactSummary = result.summary; + config.signatureRequiredForRelease = result.signatureRequiredForRelease; + config.signatureVerified = result.signatureVerified; + return config; +} + +LiteBridgeRuntimeSymbolTable liteBridgeRuntimeSymbolTableFromApi( + LiteClientBridgeApi api, + const std::string& source) +{ + LiteBridgeRuntimeSymbolTable table; + table.api = api; + table.source = sourceOrDefault(source); + addBinding(table, "walletExists", "litelib_wallet_exists", api.walletExists != nullptr); + addBinding(table, "initializeNew", "litelib_initialize_new", api.initializeNew != nullptr); + addBinding(table, "initializeNewFromPhrase", "litelib_initialize_new_from_phrase", api.initializeNewFromPhrase != nullptr); + addBinding(table, "initializeExisting", "litelib_initialize_existing", api.initializeExisting != nullptr); + addBinding(table, "execute", "litelib_execute", api.execute != nullptr); + addBinding(table, "freeString", "litelib_rust_free_string", api.freeString != nullptr); + addBinding(table, "checkServerOnline", "litelib_check_server_online", api.checkServerOnline != nullptr); + addBinding(table, "shutdown", "litelib_shutdown", api.shutdown != nullptr); + return table; +} + +LiteBridgeRuntimeSymbolTable liteBridgeRuntimeImportedLinkedSymbolTable() +{ +#if DRAGONX_ENABLE_LITE_BACKEND + return liteBridgeRuntimeSymbolTableFromApi( + LiteClientBridgeApi{ + &litelib_wallet_exists, + &litelib_initialize_new, + &litelib_initialize_new_from_phrase, + &litelib_initialize_existing, + &litelib_execute, + &litelib_rust_free_string, + &litelib_check_server_online, + &litelib_shutdown, + }, + kImportedLinkedSource); +#else + return liteBridgeRuntimeSymbolTableFromApi({}, kImportedLinkedSource); +#endif +} + +LiteBridgeRuntimeFakeDynamicLoaderResult evaluateLiteBridgeRuntimeFakeDynamicLoader( + const LiteBridgeRuntimeFakeDynamicLoaderInput& input) +{ + LiteBridgeRuntimeFakeDynamicLoaderResult result; + result.artifactPathReviewed = input.artifactPathReviewed; + result.platformLoaderStrategyReady = input.platformLoaderStrategyReady; + result.loadSequenceReady = input.loadSequenceReady; + result.unloadSequenceReady = input.unloadSequenceReady; + result.handleStoreReady = input.handleStoreReady; + result.symbolLookupReady = input.symbolLookupReady; + result.status = LiteBridgeRuntimeStatus::Configured; + + if (!input.artifactPathReviewed || input.artifactPath.empty()) { + result.status = LiteBridgeRuntimeStatus::Unavailable; + result.error = "lite bridge fake dynamic loader requires a reviewed artifact path"; + result.summary = fakeDynamicLoaderBlockedSummary("artifact_path_review_missing"); + return result; + } + if (!input.platformLoaderStrategyReady) { + result.status = LiteBridgeRuntimeStatus::Failed; + result.error = "lite bridge fake dynamic loader requires a platform loader strategy"; + result.summary = fakeDynamicLoaderBlockedSummary("platform_loader_strategy_missing"); + return result; + } + if (!input.loadSequenceReady || !input.unloadSequenceReady) { + result.status = LiteBridgeRuntimeStatus::Failed; + result.error = "lite bridge fake dynamic loader requires load and unload sequencing"; + result.summary = fakeDynamicLoaderBlockedSummary("load_unload_sequence_missing"); + return result; + } + if (!input.handleStoreReady || !input.fakeHandleProvided || input.handleLabel.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + result.error = "lite bridge fake dynamic loader requires a stored fake handle"; + result.summary = fakeDynamicLoaderBlockedSummary("handle_store_missing"); + return result; + } + if (!input.unload) { + result.status = LiteBridgeRuntimeStatus::Failed; + result.error = "lite bridge fake dynamic loader requires a fake unload callback"; + result.summary = fakeDynamicLoaderBlockedSummary("unload_callback_missing"); + return result; + } + if (!input.symbolLookupReady) { + result.status = LiteBridgeRuntimeStatus::Failed; + result.error = "lite bridge fake dynamic loader requires symbol lookup readiness"; + result.summary = fakeDynamicLoaderBlockedSummary("symbol_lookup_missing"); + return result; + } + + result.fakeLoadAttempted = true; + if (input.failLoad) { + result.status = LiteBridgeRuntimeStatus::Failed; + result.error = input.loadError.empty() + ? "lite bridge fake dynamic loader failed to load the fake handle" + : input.loadError; + result.summary = fakeDynamicLoaderBlockedSummary("fake_load_failed"); + return result; + } + + result.handle.present = true; + result.handle.fakeHandle = true; + result.handle.artifactPath = input.artifactPath; + result.handle.displayPath = input.displayPath.empty() ? input.artifactPath : input.displayPath; + result.handle.platform = input.platform; + result.handle.handleLabel = input.handleLabel; + result.handle.unload = input.unload; + result.handleStored = true; + result.handlePresent = true; + + result.fakeSymbolLookupAttempted = true; + result.status = LiteBridgeRuntimeStatus::BindingSymbols; + result.symbolTable = liteBridgeRuntimeSymbolTableFromApi( + input.api, dynamicLoaderSourceOrDefault(input.source)); + result.symbolTableProduced = true; + result.requiredSymbolCount = result.symbolTable.requiredSymbolCount; + result.availableSymbolCount = result.symbolTable.availableSymbolCount; + collectMissingSymbols(result.symbolTable, result.missingSymbols); + if (!result.missingSymbols.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + result.error = "lite bridge fake dynamic loader symbol table is missing required symbols"; + result.summary = fakeDynamicLoaderBlockedSummary("missing_symbols"); + result.fakeUnloadAttempted = true; + result.handle.unload(result.handle.handleLabel.c_str()); + result.handle.present = false; + result.handlePresent = false; + result.dynamicLibraryUnloadDeferred = false; + return result; + } + + result.symbolTableReady = true; + result.runtimeReady = true; + result.status = LiteBridgeRuntimeStatus::Ready; + result.ok = true; + result.summary = "lite_bridge_runtime_fake_dynamic_loader=ready; symbols=ready"; + return result; +} + +LiteBridgeRuntimePlatformLoaderReviewResult evaluateLiteBridgeRuntimePlatformLoaderReview( + const LiteBridgeRuntimePlatformLoaderReviewInput& input) +{ + LiteBridgeRuntimePlatformLoaderReviewResult result; + result.status = LiteBridgeRuntimeStatus::Configured; + result.platform = normalizedPlatform(input.platform); + result.requiredSymbolCount = input.requiredSymbolCount; + + result.noPlatformDynamicLibraryLoaded = !input.platformLoadAttempted; + result.noPlatformDynamicLibraryUnloaded = !input.platformUnloadAttempted; + result.noPlatformSymbolResolution = !input.platformSymbolResolutionAttempted; + result.noSdxlCalls = !input.sdxlCallRequested; + result.noBridgeCalls = !input.bridgeCallRequested; + result.noServerConnectivityChecked = !input.serverConnectivityCheckRequested; + result.noWalletLifecycle = !input.walletLifecycleRequested; + result.noSyncStarted = !input.syncRequested; + result.noSyncStatusPolled = !input.syncStatusPollingRequested; + result.noWorkerQueueEnqueue = !input.workerQueueRequested; + result.noWalletStateMutation = !input.walletStateMutationRequested; + result.noWalletPersistence = !input.walletPersistenceRequested; + result.noSettingsPersistence = !input.settingsWriteRequested; + result.noSendImportExportExecution = !input.sendImportExportRequested; + result.noArtifactMutation = !input.artifactMutationRequested; + + if (!result.noPlatformDynamicLibraryLoaded || + !result.noPlatformDynamicLibraryUnloaded || + !result.noPlatformSymbolResolution) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformLoaderReviewIssue(result, + "platform loader review must not attempt loader APIs"); + result.summary = platformLoaderReviewBlockedSummary("platform_api_attempted"); + return result; + } + + if (!result.noSdxlCalls || + !result.noBridgeCalls || + !result.noServerConnectivityChecked || + !result.noWalletLifecycle || + !result.noSyncStarted || + !result.noSyncStatusPolled || + !result.noWorkerQueueEnqueue || + !result.noWalletStateMutation || + !result.noWalletPersistence || + !result.noSettingsPersistence || + !result.noSendImportExportExecution || + !result.noArtifactMutation) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformLoaderReviewIssue(result, + "platform loader review must not request runtime actions"); + result.summary = platformLoaderReviewBlockedSummary("runtime_action_requested"); + return result; + } + + if (result.platform.empty()) { + result.status = LiteBridgeRuntimeStatus::Unavailable; + addPlatformLoaderReviewIssue(result, + "platform loader review requires a target platform"); + result.summary = platformLoaderReviewBlockedSummary("platform_missing"); + return result; + } + + if (isMacosPlatform(result.platform)) { + result.macosDeferred = true; + result.status = LiteBridgeRuntimeStatus::Unavailable; + addPlatformLoaderReviewIssue(result, + input.macosDeferredByOperator + ? "macOS platform loader review is deferred by operator request" + : "macOS platform loader review requires a reviewed builder before promotion"); + result.summary = platformLoaderReviewBlockedSummary("macos_deferred"); + return result; + } + + const bool linuxPlatform = isLinuxPlatform(result.platform); + const bool windowsPlatform = isWindowsPlatform(result.platform); + if (!linuxPlatform && !windowsPlatform) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformLoaderReviewIssue(result, + "platform loader review supports only Linux and Windows in batch 8"); + result.summary = platformLoaderReviewBlockedSummary("unsupported_platform"); + return result; + } + + result.platformAccepted = true; + result.linuxPlatformAccepted = linuxPlatform; + result.windowsPlatformAccepted = windowsPlatform; + + if (!input.sharedArtifactEvidenceReviewed || + input.sharedArtifactPath.empty() || + !input.sharedArtifactIsSharedLibrary || + !input.manifestRecordsSharedLibrary || + !input.artifactSha256Reviewed || + input.sharedArtifactSha256.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformLoaderReviewIssue(result, + "platform loader review requires reviewed shared-library artifact evidence"); + result.summary = platformLoaderReviewBlockedSummary("shared_artifact_evidence_missing"); + return result; + } + result.sharedArtifactEvidenceAccepted = true; + + if (!input.requiredSymbolEvidenceReviewed || + !input.requiredSymbolsPresent || + input.requiredSymbolCount != liteBridgeRuntimeRequiredSymbolLogicalNames().size()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformLoaderReviewIssue(result, + "platform loader review requires required-symbol evidence for every ABI symbol"); + result.summary = platformLoaderReviewBlockedSummary("required_symbol_evidence_missing"); + return result; + } + result.requiredSymbolEvidenceAccepted = true; + + if (!input.loaderAdapterSeamReviewed || + !input.unloadAdapterSeamReviewed || + !input.symbolLookupAdapterSeamReviewed || + (linuxPlatform && !input.linuxAdapterAvailable) || + (windowsPlatform && !input.windowsAdapterAvailable)) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformLoaderReviewIssue(result, + "platform loader review requires reviewed load, unload, and symbol lookup adapter seams"); + result.summary = platformLoaderReviewBlockedSummary("adapter_seam_missing"); + return result; + } + result.loaderAdapterSeamAccepted = true; + result.unloadAdapterSeamAccepted = true; + result.symbolLookupAdapterSeamAccepted = true; + + if (!input.handleOwnershipReviewed || + !input.teardownOrderingReviewed || + !input.stringOwnershipReused) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformLoaderReviewIssue(result, + "platform loader review requires handle ownership, teardown ordering, and string ownership reuse"); + result.summary = platformLoaderReviewBlockedSummary("ownership_teardown_missing"); + return result; + } + result.handleOwnershipAccepted = true; + result.teardownOrderingAccepted = true; + result.stringOwnershipReuseAccepted = true; + + if (!input.fakeDynamicBindingGreen) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformLoaderReviewIssue(result, + "platform loader review requires green fake dynamic binding first"); + result.summary = platformLoaderReviewBlockedSummary("fake_dynamic_binding_required"); + return result; + } + result.fakeDynamicBindingAccepted = true; + + result.platformLoaderReviewReady = true; + result.status = LiteBridgeRuntimeStatus::Ready; + result.ok = true; + result.summary = std::string("lite_bridge_runtime_platform_loader_review=ready; platform=") + + result.platform + "; loader_api=deferred"; + return result; +} + +LiteBridgeRuntimeDynamicLoaderSmokeGateResult evaluateLiteBridgeRuntimeDynamicLoaderSmokeGate( + const LiteBridgeRuntimeDynamicLoaderSmokeGateInput& input) +{ + LiteBridgeRuntimeDynamicLoaderSmokeGateResult result; + result.status = LiteBridgeRuntimeStatus::Configured; + result.platform = normalizedPlatform( + input.platform.empty() ? input.platformLoaderReview.platform : input.platform); + + result.noRuntimePlatformDynamicLibraryLoaded = !input.runtimePlatformLoadAttempted; + result.noRuntimePlatformDynamicLibraryUnloaded = !input.runtimePlatformUnloadAttempted; + result.noRuntimePlatformSymbolResolution = !input.runtimePlatformSymbolResolutionAttempted; + result.noSdxlCalls = !input.sdxlCallRequested && input.noSdxlCallsObserved; + result.noBridgeCalls = !input.bridgeCallRequested && input.noBridgeCallsObserved; + result.noServerConnectivityChecked = + !input.serverConnectivityCheckRequested && input.noServerConnectivityObserved; + result.noWalletLifecycle = !input.walletLifecycleRequested && input.noWalletLifecycleObserved; + result.noSyncStarted = !input.syncRequested && input.noSyncObserved; + result.noSyncStatusPolled = !input.syncStatusPollingRequested && input.noSyncStatusPollingObserved; + result.noWorkerQueueEnqueue = !input.workerQueueRequested && input.noWorkerQueueObserved; + result.noWalletStateMutation = + !input.walletStateMutationRequested && input.noWalletStateMutationObserved; + result.noWalletPersistence = !input.walletPersistenceRequested && input.noWalletPersistenceObserved; + result.noSettingsPersistence = !input.settingsWriteRequested && input.noSettingsPersistenceObserved; + result.noSendImportExportExecution = + !input.sendImportExportRequested && input.noSendImportExportObserved; + result.noArtifactMutation = !input.artifactMutationRequested && input.noArtifactMutationObserved; + result.symbolResolutionBlocked = input.noSymbolResolutionObserved && + result.noRuntimePlatformSymbolResolution; + + if (!result.noRuntimePlatformDynamicLibraryLoaded || + !result.noRuntimePlatformDynamicLibraryUnloaded || + !result.noRuntimePlatformSymbolResolution) { + result.status = LiteBridgeRuntimeStatus::Failed; + addDynamicLoaderSmokeGateIssue( + result, + "dynamic-loader smoke gate must not execute platform loader APIs in runtime"); + result.summary = dynamicLoaderSmokeGateBlockedSummary("runtime_platform_api_attempted"); + return result; + } + + if (!result.noSdxlCalls || + !result.noBridgeCalls || + !result.noServerConnectivityChecked || + !result.noWalletLifecycle || + !result.noSyncStarted || + !result.noSyncStatusPolled || + !result.noWorkerQueueEnqueue || + !result.noWalletStateMutation || + !result.noWalletPersistence || + !result.noSettingsPersistence || + !result.noSendImportExportExecution || + !result.noArtifactMutation) { + result.status = LiteBridgeRuntimeStatus::Failed; + addDynamicLoaderSmokeGateIssue( + result, + "dynamic-loader smoke gate must not request wallet runtime behavior"); + result.summary = dynamicLoaderSmokeGateBlockedSummary("runtime_action_requested"); + return result; + } + + if (result.platform.empty()) { + result.status = LiteBridgeRuntimeStatus::Unavailable; + addDynamicLoaderSmokeGateIssue(result, + "dynamic-loader smoke gate requires a target platform"); + result.summary = dynamicLoaderSmokeGateBlockedSummary("platform_missing"); + return result; + } + + if (isMacosPlatform(result.platform)) { + result.macosDeferred = true; + result.status = LiteBridgeRuntimeStatus::Unavailable; + addDynamicLoaderSmokeGateIssue( + result, + input.macosDeferredByOperator + ? "macOS dynamic-loader smoke gate is deferred by operator request" + : "macOS dynamic-loader smoke gate requires a reviewed builder before promotion"); + result.summary = dynamicLoaderSmokeGateBlockedSummary("macos_deferred"); + return result; + } + + const bool linuxPlatform = isLinuxPlatform(result.platform); + const bool windowsPlatform = isWindowsPlatform(result.platform); + if (!linuxPlatform && !windowsPlatform) { + result.status = LiteBridgeRuntimeStatus::Failed; + addDynamicLoaderSmokeGateIssue( + result, + "dynamic-loader smoke gate supports only Linux and Windows in batch 9"); + result.summary = dynamicLoaderSmokeGateBlockedSummary("unsupported_platform"); + return result; + } + + result.platformAccepted = true; + result.linuxPlatformAccepted = linuxPlatform; + result.windowsPlatformAccepted = windowsPlatform; + + const auto& review = input.platformLoaderReview; + if (!input.platformLoaderReviewAccepted || + !review.ok || + !review.platformLoaderReviewReady || + review.status != LiteBridgeRuntimeStatus::Ready || + review.platform != result.platform) { + result.status = LiteBridgeRuntimeStatus::Failed; + addDynamicLoaderSmokeGateIssue( + result, + "dynamic-loader smoke gate requires a matching ready platform-loader review"); + result.summary = dynamicLoaderSmokeGateBlockedSummary("platform_loader_review_required"); + return result; + } + result.platformLoaderReviewAccepted = true; + + if (!input.disposableSharedArtifactReviewed || + input.smokeArtifactPath.empty() || + !input.disposableSharedArtifactIsSharedLibrary || + !input.disposableArtifactSha256Reviewed || + input.smokeArtifactSha256.empty() || + !input.disposableArtifactNotReleaseArtifact) { + result.status = LiteBridgeRuntimeStatus::Failed; + addDynamicLoaderSmokeGateIssue( + result, + "dynamic-loader smoke gate requires a disposable reviewed shared artifact"); + result.summary = dynamicLoaderSmokeGateBlockedSummary("disposable_shared_artifact_required"); + return result; + } + result.disposableSmokeArtifactAccepted = true; + + if (!input.smokeEnvironmentReviewed) { + result.status = LiteBridgeRuntimeStatus::Failed; + addDynamicLoaderSmokeGateIssue(result, + "dynamic-loader smoke gate requires a reviewed smoke environment"); + result.summary = dynamicLoaderSmokeGateBlockedSummary("smoke_environment_required"); + return result; + } + result.smokeEnvironmentAccepted = true; + + if (!input.smokePlanReviewed || input.smokeRunId.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addDynamicLoaderSmokeGateIssue(result, + "dynamic-loader smoke gate requires a reviewed smoke plan and run id"); + result.summary = dynamicLoaderSmokeGateBlockedSummary("smoke_plan_required"); + return result; + } + result.smokePlanAccepted = true; + + if (!input.loadOnlySmokeEvidenceReviewed || + !input.unloadOnlySmokeEvidenceReviewed || + !input.unloadObservedAfterLoad) { + result.status = LiteBridgeRuntimeStatus::Failed; + addDynamicLoaderSmokeGateIssue( + result, + "dynamic-loader smoke gate requires reviewed load/unload-only smoke evidence"); + result.summary = dynamicLoaderSmokeGateBlockedSummary("load_unload_smoke_evidence_required"); + return result; + } + result.loadOnlySmokeEvidenceAccepted = true; + result.unloadOnlySmokeEvidenceAccepted = true; + + if (!input.noSymbolResolutionObserved || !result.noRuntimePlatformSymbolResolution) { + result.status = LiteBridgeRuntimeStatus::Failed; + addDynamicLoaderSmokeGateIssue( + result, + "dynamic-loader smoke gate forbids symbol resolution smoke in batch 9"); + result.summary = dynamicLoaderSmokeGateBlockedSummary("symbol_resolution_observed"); + result.symbolResolutionBlocked = false; + return result; + } + + if (!input.handleLifecycleEvidenceReviewed || !input.cleanupEvidenceReviewed) { + result.status = LiteBridgeRuntimeStatus::Failed; + addDynamicLoaderSmokeGateIssue( + result, + "dynamic-loader smoke gate requires handle lifecycle and cleanup evidence"); + result.summary = dynamicLoaderSmokeGateBlockedSummary("handle_cleanup_evidence_required"); + return result; + } + result.handleLifecycleEvidenceAccepted = true; + result.cleanupEvidenceAccepted = true; + + result.dynamicLoaderSmokeGateReady = true; + result.status = LiteBridgeRuntimeStatus::Ready; + result.ok = true; + result.summary = std::string("lite_bridge_runtime_dynamic_loader_smoke_gate=ready; platform=") + + result.platform + "; scope=load-unload-only"; + return result; +} + +LiteBridgeRuntimeSharedArtifactSmokeEvidenceAcquisitionResult +evaluateLiteBridgeRuntimeSharedArtifactSmokeEvidenceAcquisition( + const LiteBridgeRuntimeSharedArtifactSmokeEvidenceAcquisitionInput& input) +{ + LiteBridgeRuntimeSharedArtifactSmokeEvidenceAcquisitionResult result; + result.status = LiteBridgeRuntimeStatus::Configured; + result.platform = normalizedPlatform( + input.platform.empty() ? input.dynamicLoaderSmokeGate.platform : input.platform); + result.smokeRunId = input.smokeRunId; + result.manifestPath = input.manifestPath; + result.loadUnloadRecordPath = input.loadUnloadRecordPath; + result.cleanupRecordPath = input.cleanupRecordPath; + + result.noRuntimePlatformDynamicLibraryLoaded = !input.runtimePlatformLoadAttempted; + result.noRuntimePlatformDynamicLibraryUnloaded = !input.runtimePlatformUnloadAttempted; + result.noRuntimePlatformSymbolResolution = !input.runtimePlatformSymbolResolutionAttempted; + result.noSymbolResolutionRecord = input.noSymbolResolutionRecord && + result.noRuntimePlatformSymbolResolution; + result.noSdxlCalls = !input.sdxlCallRequested && input.noSdxlCallsRecord; + result.noBridgeCalls = !input.bridgeCallRequested && input.noBridgeCallsRecord; + result.noServerConnectivityChecked = + !input.serverConnectivityCheckRequested && input.noServerConnectivityRecord; + result.noWalletLifecycle = !input.walletLifecycleRequested && input.noWalletLifecycleRecord; + result.noSyncStarted = !input.syncRequested && input.noSyncRecord; + result.noSyncStatusPolled = !input.syncStatusPollingRequested && input.noSyncStatusPollingRecord; + result.noWorkerQueueEnqueue = !input.workerQueueRequested && input.noWorkerQueueRecord; + result.noWalletStateMutation = + !input.walletStateMutationRequested && input.noWalletStateMutationRecord; + result.noWalletPersistence = !input.walletPersistenceRequested && input.noWalletPersistenceRecord; + result.noSettingsPersistence = !input.settingsWriteRequested && input.noSettingsPersistenceRecord; + result.noSendImportExportExecution = + !input.sendImportExportRequested && input.noSendImportExportRecord; + result.noArtifactMutation = !input.artifactMutationRequested && input.noArtifactMutationRecord; + + if (!result.noRuntimePlatformDynamicLibraryLoaded || + !result.noRuntimePlatformDynamicLibraryUnloaded || + !result.noRuntimePlatformSymbolResolution) { + result.status = LiteBridgeRuntimeStatus::Failed; + addSharedArtifactSmokeEvidenceAcquisitionIssue( + result, + "shared-artifact smoke evidence acquisition must not execute platform loader APIs in runtime"); + result.summary = sharedArtifactSmokeEvidenceAcquisitionBlockedSummary( + "runtime_platform_api_attempted"); + return result; + } + + if (!result.noSdxlCalls || + !result.noBridgeCalls || + !result.noServerConnectivityChecked || + !result.noWalletLifecycle || + !result.noSyncStarted || + !result.noSyncStatusPolled || + !result.noWorkerQueueEnqueue || + !result.noWalletStateMutation || + !result.noWalletPersistence || + !result.noSettingsPersistence || + !result.noSendImportExportExecution || + !result.noArtifactMutation) { + result.status = LiteBridgeRuntimeStatus::Failed; + addSharedArtifactSmokeEvidenceAcquisitionIssue( + result, + "shared-artifact smoke evidence acquisition must not request or record wallet runtime behavior"); + result.summary = sharedArtifactSmokeEvidenceAcquisitionBlockedSummary( + "runtime_action_recorded"); + return result; + } + + if (result.platform.empty()) { + result.status = LiteBridgeRuntimeStatus::Unavailable; + addSharedArtifactSmokeEvidenceAcquisitionIssue( + result, + "shared-artifact smoke evidence acquisition requires a target platform"); + result.summary = sharedArtifactSmokeEvidenceAcquisitionBlockedSummary("platform_missing"); + return result; + } + + if (isMacosPlatform(result.platform)) { + result.macosDeferred = true; + result.status = LiteBridgeRuntimeStatus::Unavailable; + addSharedArtifactSmokeEvidenceAcquisitionIssue( + result, + input.macosDeferredByOperator + ? "macOS shared-artifact smoke evidence acquisition is deferred by operator request" + : "macOS shared-artifact smoke evidence acquisition requires a reviewed builder before promotion"); + result.summary = sharedArtifactSmokeEvidenceAcquisitionBlockedSummary("macos_deferred"); + return result; + } + + const bool linuxPlatform = isLinuxPlatform(result.platform); + const bool windowsPlatform = isWindowsPlatform(result.platform); + if (!linuxPlatform && !windowsPlatform) { + result.status = LiteBridgeRuntimeStatus::Failed; + addSharedArtifactSmokeEvidenceAcquisitionIssue( + result, + "shared-artifact smoke evidence acquisition supports only Linux and Windows in batch 10"); + result.summary = sharedArtifactSmokeEvidenceAcquisitionBlockedSummary("unsupported_platform"); + return result; + } + + result.platformAccepted = true; + result.linuxPlatformAccepted = linuxPlatform; + result.windowsPlatformAccepted = windowsPlatform; + + const auto& smokeGate = input.dynamicLoaderSmokeGate; + if (!input.dynamicLoaderSmokeGateAccepted || + !smokeGate.ok || + !smokeGate.dynamicLoaderSmokeGateReady || + smokeGate.status != LiteBridgeRuntimeStatus::Ready || + smokeGate.platform != result.platform) { + result.status = LiteBridgeRuntimeStatus::Failed; + addSharedArtifactSmokeEvidenceAcquisitionIssue( + result, + "shared-artifact smoke evidence acquisition requires a matching ready dynamic-loader smoke gate"); + result.summary = sharedArtifactSmokeEvidenceAcquisitionBlockedSummary( + "dynamic_loader_smoke_gate_required"); + return result; + } + result.dynamicLoaderSmokeGateAccepted = true; + + if (!input.releaseBuilderReviewed || + input.releaseBuilderId.empty() || + (linuxPlatform && !input.linuxReleaseBuilderAvailable) || + (windowsPlatform && !input.windowsReleaseBuilderAvailable)) { + result.status = LiteBridgeRuntimeStatus::Failed; + addSharedArtifactSmokeEvidenceAcquisitionIssue( + result, + "shared-artifact smoke evidence acquisition requires a reviewed release builder"); + result.summary = sharedArtifactSmokeEvidenceAcquisitionBlockedSummary("release_builder_required"); + return result; + } + result.releaseBuilderAccepted = true; + + if (!input.disposableWorkspaceReviewed || + input.disposableWorkspacePath.empty() || + !input.disposableWorkspaceIsIsolated) { + result.status = LiteBridgeRuntimeStatus::Failed; + addSharedArtifactSmokeEvidenceAcquisitionIssue( + result, + "shared-artifact smoke evidence acquisition requires an isolated disposable workspace record"); + result.summary = sharedArtifactSmokeEvidenceAcquisitionBlockedSummary( + "disposable_workspace_required"); + return result; + } + result.disposableWorkspaceAccepted = true; + + if (!input.sharedArtifactCaptured || + input.smokeArtifactPath.empty() || + !input.sharedArtifactIsSharedLibrary || + !input.sharedArtifactSha256Captured || + input.smokeArtifactSha256.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addSharedArtifactSmokeEvidenceAcquisitionIssue( + result, + "shared-artifact smoke evidence acquisition requires a captured disposable shared artifact"); + result.summary = sharedArtifactSmokeEvidenceAcquisitionBlockedSummary( + "shared_artifact_record_required"); + return result; + } + result.sharedArtifactRecordAccepted = true; + + if (!input.manifestCaptured || + input.manifestPath.empty() || + !input.manifestSha256Captured || + input.manifestSha256.empty() || + !input.manifestRecordsPlatform || + !input.manifestRecordsBuilder || + !input.manifestRecordsSmokeRunId || + !input.manifestRecordsArtifactPath || + !input.manifestRecordsArtifactSha256 || + !input.manifestRecordsDisposableArtifact || + input.smokeRunId.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addSharedArtifactSmokeEvidenceAcquisitionIssue( + result, + "shared-artifact smoke evidence acquisition requires a complete reviewed manifest record"); + result.summary = sharedArtifactSmokeEvidenceAcquisitionBlockedSummary("manifest_record_required"); + return result; + } + result.manifestRecordAccepted = true; + + if (!input.loadUnloadRecordCaptured || + input.loadUnloadRecordPath.empty() || + !input.loadRecordCaptured || + !input.unloadRecordCaptured || + !input.unloadRecordedAfterLoad || + !input.loadUnloadRecordIsLoadUnloadOnly) { + result.status = LiteBridgeRuntimeStatus::Failed; + addSharedArtifactSmokeEvidenceAcquisitionIssue( + result, + "shared-artifact smoke evidence acquisition requires load/unload-only builder records"); + result.summary = sharedArtifactSmokeEvidenceAcquisitionBlockedSummary( + "load_unload_record_required"); + return result; + } + result.loadUnloadRecordAccepted = true; + + if (!result.noSymbolResolutionRecord) { + result.status = LiteBridgeRuntimeStatus::Failed; + addSharedArtifactSmokeEvidenceAcquisitionIssue( + result, + "shared-artifact smoke evidence acquisition forbids symbol-resolution records in batch 10"); + result.summary = sharedArtifactSmokeEvidenceAcquisitionBlockedSummary("symbol_resolution_recorded"); + return result; + } + + if (!input.handleLifecycleRecordCaptured) { + result.status = LiteBridgeRuntimeStatus::Failed; + addSharedArtifactSmokeEvidenceAcquisitionIssue( + result, + "shared-artifact smoke evidence acquisition requires a handle lifecycle record"); + result.summary = sharedArtifactSmokeEvidenceAcquisitionBlockedSummary( + "handle_lifecycle_record_required"); + return result; + } + result.handleLifecycleRecordAccepted = true; + + if (!input.cleanupRecordCaptured || + input.cleanupRecordPath.empty() || + !input.cleanupRecordShowsHandleReleased || + !input.cleanupRecordShowsArtifactRemoved || + !input.cleanupRecordShowsWorkspaceRemoved) { + result.status = LiteBridgeRuntimeStatus::Failed; + addSharedArtifactSmokeEvidenceAcquisitionIssue( + result, + "shared-artifact smoke evidence acquisition requires cleanup proof for handle, artifact, and workspace"); + result.summary = sharedArtifactSmokeEvidenceAcquisitionBlockedSummary("cleanup_proof_required"); + return result; + } + result.cleanupProofAccepted = true; + + result.smokeEvidenceAcquisitionReady = true; + result.status = LiteBridgeRuntimeStatus::Ready; + result.ok = true; + result.summary = std::string("lite_bridge_runtime_shared_artifact_smoke_evidence_acquisition=ready; platform=") + + result.platform + "; scope=release-builder-records"; + return result; +} + +LiteBridgeRuntimePlatformDynamicLoaderAdapterContractResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderAdapterContract( + const LiteBridgeRuntimePlatformDynamicLoaderAdapterContractInput& input) +{ + LiteBridgeRuntimePlatformDynamicLoaderAdapterContractResult result; + result.status = LiteBridgeRuntimeStatus::Configured; + result.platform = normalizedPlatform( + input.platform.empty() ? input.smokeEvidenceAcquisition.platform : input.platform); + result.adapterName = input.adapterName; + result.requiredSymbolCount = input.requiredSymbolCount; + + result.noRuntimePlatformDynamicLibraryLoaded = !input.runtimePlatformLoadAttempted; + result.noRuntimePlatformDynamicLibraryUnloaded = !input.runtimePlatformUnloadAttempted; + result.noRuntimePlatformSymbolResolution = !input.runtimePlatformSymbolResolutionAttempted; + result.noSdxlCalls = !input.sdxlCallRequested; + result.noBridgeCalls = !input.bridgeCallRequested; + result.noServerConnectivityChecked = !input.serverConnectivityCheckRequested; + result.noWalletLifecycle = !input.walletLifecycleRequested; + result.noSyncStarted = !input.syncRequested; + result.noSyncStatusPolled = !input.syncStatusPollingRequested; + result.noWorkerQueueEnqueue = !input.workerQueueRequested; + result.noWalletStateMutation = !input.walletStateMutationRequested; + result.noWalletPersistence = !input.walletPersistenceRequested; + result.noSettingsPersistence = !input.settingsWriteRequested; + result.noSendImportExportExecution = !input.sendImportExportRequested; + result.noArtifactMutation = !input.artifactMutationRequested; + + if (!result.noRuntimePlatformDynamicLibraryLoaded || + !result.noRuntimePlatformDynamicLibraryUnloaded || + !result.noRuntimePlatformSymbolResolution) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderAdapterContractIssue( + result, + "platform dynamic-loader adapter contract must not execute platform loader APIs in runtime"); + result.summary = platformDynamicLoaderAdapterContractBlockedSummary( + "runtime_platform_api_attempted"); + return result; + } + + if (!result.noSdxlCalls || + !result.noBridgeCalls || + !result.noServerConnectivityChecked || + !result.noWalletLifecycle || + !result.noSyncStarted || + !result.noSyncStatusPolled || + !result.noWorkerQueueEnqueue || + !result.noWalletStateMutation || + !result.noWalletPersistence || + !result.noSettingsPersistence || + !result.noSendImportExportExecution || + !result.noArtifactMutation) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderAdapterContractIssue( + result, + "platform dynamic-loader adapter contract must not request wallet runtime behavior"); + result.summary = platformDynamicLoaderAdapterContractBlockedSummary("runtime_action_requested"); + return result; + } + + if (result.platform.empty()) { + result.status = LiteBridgeRuntimeStatus::Unavailable; + addPlatformDynamicLoaderAdapterContractIssue( + result, + "platform dynamic-loader adapter contract requires a target platform"); + result.summary = platformDynamicLoaderAdapterContractBlockedSummary("platform_missing"); + return result; + } + + if (isMacosPlatform(result.platform)) { + result.macosDeferred = true; + result.status = LiteBridgeRuntimeStatus::Unavailable; + addPlatformDynamicLoaderAdapterContractIssue( + result, + input.macosDeferredByOperator + ? "macOS platform dynamic-loader adapter contract is deferred by operator request" + : "macOS platform dynamic-loader adapter contract requires a reviewed builder before promotion"); + result.summary = platformDynamicLoaderAdapterContractBlockedSummary("macos_deferred"); + return result; + } + + const bool linuxPlatform = isLinuxPlatform(result.platform); + const bool windowsPlatform = isWindowsPlatform(result.platform); + if (!linuxPlatform && !windowsPlatform) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderAdapterContractIssue( + result, + "platform dynamic-loader adapter contract supports only Linux and Windows in batch 11"); + result.summary = platformDynamicLoaderAdapterContractBlockedSummary("unsupported_platform"); + return result; + } + + result.platformAccepted = true; + result.linuxPlatformAccepted = linuxPlatform; + result.windowsPlatformAccepted = windowsPlatform; + + const auto& acquisition = input.smokeEvidenceAcquisition; + if (!input.smokeEvidenceAcquisitionAccepted || + !acquisition.ok || + !acquisition.smokeEvidenceAcquisitionReady || + acquisition.status != LiteBridgeRuntimeStatus::Ready || + acquisition.platform != result.platform) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderAdapterContractIssue( + result, + "platform dynamic-loader adapter contract requires matching shared-artifact smoke evidence acquisition"); + result.summary = platformDynamicLoaderAdapterContractBlockedSummary( + "smoke_evidence_acquisition_required"); + return result; + } + result.smokeEvidenceAcquisitionAccepted = true; + + if (!input.adapterContractReviewed || + input.adapterName.empty() || + (linuxPlatform && !input.linuxAdapterContractAvailable) || + (windowsPlatform && !input.windowsAdapterContractAvailable)) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderAdapterContractIssue( + result, + "platform dynamic-loader adapter contract requires a reviewed platform adapter contract"); + result.summary = platformDynamicLoaderAdapterContractBlockedSummary("adapter_contract_required"); + return result; + } + result.adapterContractAccepted = true; + + if (!input.loadAdapterSignatureDefined || + !input.adapterUsesReviewedArtifactPath || + !input.adapterReturnsOpaqueHandle) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderAdapterContractIssue( + result, + "platform dynamic-loader adapter contract requires a load signature with reviewed path and opaque handle output"); + result.summary = platformDynamicLoaderAdapterContractBlockedSummary("load_adapter_contract_required"); + return result; + } + result.loadAdapterContractAccepted = true; + + if (!input.unloadAdapterSignatureDefined || + !input.handleOwnershipContractDefined || + !input.unloadAfterRuntimeShutdownDefined || + !input.unloadAfterOwnedStringsReleasedDefined) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderAdapterContractIssue( + result, + "platform dynamic-loader adapter contract requires unload and handle ownership ordering contracts"); + result.summary = platformDynamicLoaderAdapterContractBlockedSummary("unload_adapter_contract_required"); + return result; + } + result.unloadAdapterContractAccepted = true; + result.handleOwnershipContractAccepted = true; + + if (!input.symbolLookupAdapterSignatureDefined || + !input.symbolLookupResultStaysInsideRuntime || + !input.rawSymbolPointerEscapeBlocked) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderAdapterContractIssue( + result, + "platform dynamic-loader adapter contract requires contained symbol lookup contracts without raw pointer escape"); + result.summary = platformDynamicLoaderAdapterContractBlockedSummary( + "symbol_lookup_adapter_contract_required"); + return result; + } + result.symbolLookupAdapterContractAccepted = true; + + if (!input.adapterErrorMappingDefined || !input.adapterPathEncodingDefined) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderAdapterContractIssue( + result, + "platform dynamic-loader adapter contract requires path encoding and error mapping contracts"); + result.summary = platformDynamicLoaderAdapterContractBlockedSummary("path_error_contract_required"); + return result; + } + result.pathAndErrorContractAccepted = true; + + if (!input.requiredSymbolMapDefined || + input.requiredSymbolCount != liteBridgeRuntimeRequiredSymbolLogicalNames().size() || + !input.symbolTableReuseDefined || + !input.stringOwnershipReused || + !input.fakeDynamicBindingStillRequired) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderAdapterContractIssue( + result, + "platform dynamic-loader adapter contract requires required-symbol mapping and existing runtime ownership reuse"); + result.summary = platformDynamicLoaderAdapterContractBlockedSummary("symbol_table_contract_required"); + return result; + } + result.symbolTableContractAccepted = true; + + if (!input.runtimePlatformImplementationDeferred || !input.productionLoaderExecutionDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderAdapterContractIssue( + result, + "platform dynamic-loader adapter contract must keep production loader execution disabled"); + result.summary = platformDynamicLoaderAdapterContractBlockedSummary("production_loader_enabled"); + return result; + } + result.runtimeDeferralAccepted = true; + + result.adapterContractReady = true; + result.status = LiteBridgeRuntimeStatus::Ready; + result.ok = true; + result.summary = std::string("lite_bridge_runtime_platform_dynamic_loader_adapter_contract=ready; platform=") + + result.platform + "; scope=contract-only"; + return result; +} + +LiteBridgeRuntimePlatformDynamicLoaderAdapter liteBridgeRuntimeNoOpPlatformDynamicLoaderAdapter( + const std::string& platform) +{ + LiteBridgeRuntimePlatformDynamicLoaderAdapter adapter; + adapter.platform = normalizedPlatform(platform); + adapter.name = adapter.platform.empty() + ? "platform-dynamic-loader-noop-adapter" + : adapter.platform + "-dynamic-loader-noop-adapter"; + adapter.noOpAdapter = true; + adapter.productionLoader = false; + adapter.load = &noOpAdapterLoad; + adapter.unload = &noOpAdapterUnload; + adapter.symbolLookup = &noOpAdapterSymbolLookup; + return adapter; +} + +LiteBridgeRuntimePlatformDynamicLoaderAdapter liteBridgeRuntimeDisabledPlatformDynamicLoaderRealAdapter( + const std::string& platform) +{ + LiteBridgeRuntimePlatformDynamicLoaderAdapter adapter; + adapter.platform = normalizedPlatform(platform); + adapter.name = adapter.platform.empty() + ? "platform-dynamic-loader-real-adapter-disabled-scaffold" + : adapter.platform + "-dynamic-loader-real-adapter-disabled-scaffold"; + adapter.noOpAdapter = false; + adapter.productionLoader = false; + adapter.load = &realAdapterDisabledLoad; + adapter.unload = &realAdapterDisabledUnload; + adapter.symbolLookup = &realAdapterDisabledSymbolLookup; + return adapter; +} + +LiteBridgeRuntimePlatformDynamicLoaderNoOpAdapterSeamResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderNoOpAdapterSeam( + const LiteBridgeRuntimePlatformDynamicLoaderNoOpAdapterSeamInput& input) +{ + LiteBridgeRuntimePlatformDynamicLoaderNoOpAdapterSeamResult result; + result.status = LiteBridgeRuntimeStatus::Configured; + result.platform = normalizedPlatform( + input.platform.empty() ? input.adapterContract.platform : input.platform); + result.adapterName = input.adapter.name; + + result.noRuntimePlatformDynamicLibraryLoaded = !input.runtimePlatformLoadAttempted; + result.noRuntimePlatformDynamicLibraryUnloaded = !input.runtimePlatformUnloadAttempted; + result.noRuntimePlatformSymbolResolution = !input.runtimePlatformSymbolResolutionAttempted; + result.noSdxlCalls = !input.sdxlCallRequested; + result.noBridgeCalls = !input.bridgeCallRequested; + result.noServerConnectivityChecked = !input.serverConnectivityCheckRequested; + result.noWalletLifecycle = !input.walletLifecycleRequested; + result.noSyncStarted = !input.syncRequested; + result.noSyncStatusPolled = !input.syncStatusPollingRequested; + result.noWorkerQueueEnqueue = !input.workerQueueRequested; + result.noWalletStateMutation = !input.walletStateMutationRequested; + result.noWalletPersistence = !input.walletPersistenceRequested; + result.noSettingsPersistence = !input.settingsWriteRequested; + result.noSendImportExportExecution = !input.sendImportExportRequested; + result.noArtifactMutation = !input.artifactMutationRequested; + + if (!result.noRuntimePlatformDynamicLibraryLoaded || + !result.noRuntimePlatformDynamicLibraryUnloaded || + !result.noRuntimePlatformSymbolResolution) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderNoOpAdapterSeamIssue( + result, + "platform dynamic-loader no-op adapter seam must not execute platform loader APIs in runtime"); + result.summary = platformDynamicLoaderNoOpAdapterSeamBlockedSummary( + "runtime_platform_api_attempted"); + return result; + } + + if (!result.noSdxlCalls || + !result.noBridgeCalls || + !result.noServerConnectivityChecked || + !result.noWalletLifecycle || + !result.noSyncStarted || + !result.noSyncStatusPolled || + !result.noWorkerQueueEnqueue || + !result.noWalletStateMutation || + !result.noWalletPersistence || + !result.noSettingsPersistence || + !result.noSendImportExportExecution || + !result.noArtifactMutation) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderNoOpAdapterSeamIssue( + result, + "platform dynamic-loader no-op adapter seam must not request wallet runtime behavior"); + result.summary = platformDynamicLoaderNoOpAdapterSeamBlockedSummary("runtime_action_requested"); + return result; + } + + if (result.platform.empty()) { + result.status = LiteBridgeRuntimeStatus::Unavailable; + addPlatformDynamicLoaderNoOpAdapterSeamIssue( + result, + "platform dynamic-loader no-op adapter seam requires a target platform"); + result.summary = platformDynamicLoaderNoOpAdapterSeamBlockedSummary("platform_missing"); + return result; + } + + if (isMacosPlatform(result.platform)) { + result.macosDeferred = true; + result.status = LiteBridgeRuntimeStatus::Unavailable; + addPlatformDynamicLoaderNoOpAdapterSeamIssue( + result, + input.macosDeferredByOperator + ? "macOS platform dynamic-loader no-op adapter seam is deferred by operator request" + : "macOS platform dynamic-loader no-op adapter seam requires a reviewed builder before promotion"); + result.summary = platformDynamicLoaderNoOpAdapterSeamBlockedSummary("macos_deferred"); + return result; + } + + const bool linuxPlatform = isLinuxPlatform(result.platform); + const bool windowsPlatform = isWindowsPlatform(result.platform); + if (!linuxPlatform && !windowsPlatform) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderNoOpAdapterSeamIssue( + result, + "platform dynamic-loader no-op adapter seam supports only Linux and Windows in batch 12"); + result.summary = platformDynamicLoaderNoOpAdapterSeamBlockedSummary("unsupported_platform"); + return result; + } + + result.platformAccepted = true; + result.linuxPlatformAccepted = linuxPlatform; + result.windowsPlatformAccepted = windowsPlatform; + + const auto& contract = input.adapterContract; + if (!input.adapterContractAccepted || + !contract.ok || + !contract.adapterContractReady || + contract.status != LiteBridgeRuntimeStatus::Ready || + contract.platform != result.platform) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderNoOpAdapterSeamIssue( + result, + "platform dynamic-loader no-op adapter seam requires a matching ready adapter contract"); + result.summary = platformDynamicLoaderNoOpAdapterSeamBlockedSummary( + "adapter_contract_required"); + return result; + } + result.adapterContractAccepted = true; + + const auto& adapter = input.adapter; + if (!input.noOpAdapterRegistered || + !adapter.noOpAdapter || + adapter.productionLoader || + adapter.name.empty() || + normalizedPlatform(adapter.platform) != result.platform || + !adapter.load || + !adapter.unload || + !adapter.symbolLookup) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderNoOpAdapterSeamIssue( + result, + "platform dynamic-loader no-op adapter seam requires a registered no-op adapter with all callbacks"); + result.summary = platformDynamicLoaderNoOpAdapterSeamBlockedSummary("noop_adapter_required"); + return result; + } + result.noOpAdapterAccepted = true; + + if (!input.runtimeOwnsAdapter) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderNoOpAdapterSeamIssue( + result, + "platform dynamic-loader no-op adapter seam requires runtime-owned adapter lifetime"); + result.summary = platformDynamicLoaderNoOpAdapterSeamBlockedSummary( + "runtime_adapter_ownership_required"); + return result; + } + result.runtimeAdapterOwnershipAccepted = true; + + if (!input.productionLoaderExecutionDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderNoOpAdapterSeamIssue( + result, + "platform dynamic-loader no-op adapter seam must keep production loader execution disabled"); + result.summary = platformDynamicLoaderNoOpAdapterSeamBlockedSummary("production_loader_enabled"); + return result; + } + result.productionLoaderDisabled = true; + + if (!input.loadProbeRequested || input.artifactPath.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderNoOpAdapterSeamIssue( + result, + "platform dynamic-loader no-op adapter seam requires a disabled load probe"); + result.summary = platformDynamicLoaderNoOpAdapterSeamBlockedSummary("load_probe_required"); + return result; + } + const auto loadResult = adapter.load(result.platform.c_str(), input.artifactPath.c_str()); + if (!adapterCallStayedDisabled(loadResult) || loadResult.handleProduced) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderNoOpAdapterSeamIssue( + result, + "platform dynamic-loader no-op adapter load probe must stay disabled and produce no handle"); + result.summary = platformDynamicLoaderNoOpAdapterSeamBlockedSummary("load_probe_failed"); + return result; + } + result.loadProbeAccepted = true; + result.noHandleProduced = true; + + if (!input.unloadProbeRequested || input.handleLabel.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderNoOpAdapterSeamIssue( + result, + "platform dynamic-loader no-op adapter seam requires a disabled unload probe"); + result.summary = platformDynamicLoaderNoOpAdapterSeamBlockedSummary("unload_probe_required"); + return result; + } + const auto unloadResult = adapter.unload(result.platform.c_str(), input.handleLabel.c_str()); + if (!adapterCallStayedDisabled(unloadResult) || unloadResult.handleReleased) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderNoOpAdapterSeamIssue( + result, + "platform dynamic-loader no-op adapter unload probe must stay disabled and release no handle"); + result.summary = platformDynamicLoaderNoOpAdapterSeamBlockedSummary("unload_probe_failed"); + return result; + } + result.unloadProbeAccepted = true; + + if (!input.symbolLookupProbeRequested || input.symbolName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderNoOpAdapterSeamIssue( + result, + "platform dynamic-loader no-op adapter seam requires a disabled symbol lookup probe"); + result.summary = platformDynamicLoaderNoOpAdapterSeamBlockedSummary( + "symbol_lookup_probe_required"); + return result; + } + const auto symbolLookupResult = adapter.symbolLookup( + result.platform.c_str(), input.symbolName.c_str()); + if (!adapterCallStayedDisabled(symbolLookupResult) || + symbolLookupResult.symbolAddressProduced) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderNoOpAdapterSeamIssue( + result, + "platform dynamic-loader no-op adapter symbol lookup probe must stay disabled and produce no symbol address"); + result.summary = platformDynamicLoaderNoOpAdapterSeamBlockedSummary( + "symbol_lookup_probe_failed"); + result.noSymbolAddressProduced = false; + return result; + } + result.symbolLookupProbeAccepted = true; + result.noSymbolAddressProduced = true; + + result.noOpAdapterSeamReady = true; + result.status = LiteBridgeRuntimeStatus::Ready; + result.ok = true; + result.summary = std::string("lite_bridge_runtime_platform_dynamic_loader_noop_adapter_seam=ready; platform=") + + result.platform + "; scope=noop-adapter"; + return result; +} + +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterDisabledScaffoldResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterDisabledScaffold( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterDisabledScaffoldInput& input) +{ + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterDisabledScaffoldResult result; + result.status = LiteBridgeRuntimeStatus::Configured; + result.platform = normalizedPlatform( + input.platform.empty() ? input.implementationReview.platform : input.platform); + result.adapterName = input.adapter.name; + + result.noRuntimePlatformDynamicLibraryLoaded = !input.runtimePlatformLoadAttempted; + result.noRuntimePlatformDynamicLibraryUnloaded = !input.runtimePlatformUnloadAttempted; + result.noRuntimePlatformSymbolResolution = !input.runtimePlatformSymbolResolutionAttempted; + result.noSdxlCalls = !input.sdxlCallRequested; + result.noBridgeCalls = !input.bridgeCallRequested; + result.noServerConnectivityChecked = !input.serverConnectivityCheckRequested; + result.noWalletLifecycle = !input.walletLifecycleRequested; + result.noSyncStarted = !input.syncRequested; + result.noSyncStatusPolled = !input.syncStatusPollingRequested; + result.noWorkerQueueEnqueue = !input.workerQueueRequested; + result.noWalletStateMutation = !input.walletStateMutationRequested; + result.noWalletPersistence = !input.walletPersistenceRequested; + result.noSettingsPersistence = !input.settingsWriteRequested; + result.noSendImportExportExecution = !input.sendImportExportRequested; + result.noArtifactMutation = !input.artifactMutationRequested; + + if (!result.noRuntimePlatformDynamicLibraryLoaded || + !result.noRuntimePlatformDynamicLibraryUnloaded || + !result.noRuntimePlatformSymbolResolution) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterDisabledScaffoldIssue( + result, + "platform dynamic-loader real-adapter disabled scaffold must not execute platform loader APIs in runtime"); + result.summary = platformDynamicLoaderRealAdapterDisabledScaffoldBlockedSummary( + "runtime_platform_api_attempted"); + return result; + } + + if (!result.noSdxlCalls || + !result.noBridgeCalls || + !result.noServerConnectivityChecked || + !result.noWalletLifecycle || + !result.noSyncStarted || + !result.noSyncStatusPolled || + !result.noWorkerQueueEnqueue || + !result.noWalletStateMutation || + !result.noWalletPersistence || + !result.noSettingsPersistence || + !result.noSendImportExportExecution || + !result.noArtifactMutation) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterDisabledScaffoldIssue( + result, + "platform dynamic-loader real-adapter disabled scaffold must not request wallet runtime behavior"); + result.summary = platformDynamicLoaderRealAdapterDisabledScaffoldBlockedSummary( + "runtime_action_requested"); + return result; + } + + if (result.platform.empty()) { + result.status = LiteBridgeRuntimeStatus::Unavailable; + addPlatformDynamicLoaderRealAdapterDisabledScaffoldIssue( + result, + "platform dynamic-loader real-adapter disabled scaffold requires a target platform"); + result.summary = platformDynamicLoaderRealAdapterDisabledScaffoldBlockedSummary( + "platform_missing"); + return result; + } + + if (isMacosPlatform(result.platform)) { + result.macosDeferred = true; + result.status = LiteBridgeRuntimeStatus::Unavailable; + addPlatformDynamicLoaderRealAdapterDisabledScaffoldIssue( + result, + input.macosDeferredByOperator + ? "macOS platform dynamic-loader real-adapter disabled scaffold is deferred by operator request" + : "macOS platform dynamic-loader real-adapter disabled scaffold requires a reviewed builder before promotion"); + result.summary = platformDynamicLoaderRealAdapterDisabledScaffoldBlockedSummary( + "macos_deferred"); + return result; + } + + const bool linuxPlatform = isLinuxPlatform(result.platform); + const bool windowsPlatform = isWindowsPlatform(result.platform); + if (!linuxPlatform && !windowsPlatform) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterDisabledScaffoldIssue( + result, + "platform dynamic-loader real-adapter disabled scaffold supports only Linux and Windows in batch 15"); + result.summary = platformDynamicLoaderRealAdapterDisabledScaffoldBlockedSummary( + "unsupported_platform"); + return result; + } + + result.platformAccepted = true; + result.linuxPlatformAccepted = linuxPlatform; + result.windowsPlatformAccepted = windowsPlatform; + + const auto& review = input.implementationReview; + if (!input.implementationReviewAccepted || + !review.ok || + !review.realAdapterImplementationReviewReady || + review.status != LiteBridgeRuntimeStatus::Ready || + review.platform != result.platform || + !review.runtimeDeferralAccepted || + !review.productionLoaderDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterDisabledScaffoldIssue( + result, + "platform dynamic-loader real-adapter disabled scaffold requires a matching ready implementation review"); + result.summary = platformDynamicLoaderRealAdapterDisabledScaffoldBlockedSummary( + "implementation_review_required"); + return result; + } + result.implementationReviewAccepted = true; + + const auto& adapter = input.adapter; + if (!input.realAdapterRegistered || + adapter.noOpAdapter || + adapter.productionLoader || + adapter.name.empty() || + normalizedPlatform(adapter.platform) != result.platform || + !adapter.load || + !adapter.unload || + !adapter.symbolLookup) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterDisabledScaffoldIssue( + result, + "platform dynamic-loader real-adapter disabled scaffold requires a registered disabled real adapter with all callbacks"); + result.summary = platformDynamicLoaderRealAdapterDisabledScaffoldBlockedSummary( + "real_adapter_required"); + return result; + } + result.realAdapterAccepted = true; + + if (!input.runtimeOwnsAdapter) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterDisabledScaffoldIssue( + result, + "platform dynamic-loader real-adapter disabled scaffold requires runtime-owned adapter lifetime"); + result.summary = platformDynamicLoaderRealAdapterDisabledScaffoldBlockedSummary( + "runtime_adapter_ownership_required"); + return result; + } + result.runtimeAdapterOwnershipAccepted = true; + + if (!input.productionLoaderExecutionDisabled || !input.realAdapterExecutionDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterDisabledScaffoldIssue( + result, + "platform dynamic-loader real-adapter disabled scaffold must keep production loader execution disabled"); + result.summary = platformDynamicLoaderRealAdapterDisabledScaffoldBlockedSummary( + "production_loader_enabled"); + return result; + } + result.productionLoaderDisabled = true; + result.realAdapterExecutionDisabled = true; + + if (!input.loadScaffoldProbeRequested || input.artifactPath.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterDisabledScaffoldIssue( + result, + "platform dynamic-loader real-adapter disabled scaffold requires a disabled load probe"); + result.summary = platformDynamicLoaderRealAdapterDisabledScaffoldBlockedSummary( + "load_scaffold_probe_required"); + return result; + } + const auto loadResult = adapter.load(result.platform.c_str(), input.artifactPath.c_str()); + if (!adapterCallStayedDisabled(loadResult) || loadResult.handleProduced) { + result.status = LiteBridgeRuntimeStatus::Failed; + result.noHandleProduced = !loadResult.handleProduced; + addPlatformDynamicLoaderRealAdapterDisabledScaffoldIssue( + result, + "platform dynamic-loader real-adapter disabled scaffold load probe must stay disabled and produce no handle"); + result.summary = platformDynamicLoaderRealAdapterDisabledScaffoldBlockedSummary( + "load_scaffold_probe_failed"); + return result; + } + result.loadScaffoldProbeAccepted = true; + result.noHandleProduced = true; + + if (!input.unloadScaffoldProbeRequested || input.handleLabel.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterDisabledScaffoldIssue( + result, + "platform dynamic-loader real-adapter disabled scaffold requires a disabled unload probe"); + result.summary = platformDynamicLoaderRealAdapterDisabledScaffoldBlockedSummary( + "unload_scaffold_probe_required"); + return result; + } + const auto unloadResult = adapter.unload(result.platform.c_str(), input.handleLabel.c_str()); + if (!adapterCallStayedDisabled(unloadResult) || unloadResult.handleReleased) { + result.status = LiteBridgeRuntimeStatus::Failed; + result.noHandleReleased = !unloadResult.handleReleased; + addPlatformDynamicLoaderRealAdapterDisabledScaffoldIssue( + result, + "platform dynamic-loader real-adapter disabled scaffold unload probe must stay disabled and release no handle"); + result.summary = platformDynamicLoaderRealAdapterDisabledScaffoldBlockedSummary( + "unload_scaffold_probe_failed"); + return result; + } + result.unloadScaffoldProbeAccepted = true; + result.noHandleReleased = true; + + if (!input.symbolLookupScaffoldProbeRequested || input.symbolName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterDisabledScaffoldIssue( + result, + "platform dynamic-loader real-adapter disabled scaffold requires a disabled symbol lookup probe"); + result.summary = platformDynamicLoaderRealAdapterDisabledScaffoldBlockedSummary( + "symbol_lookup_scaffold_probe_required"); + return result; + } + const auto symbolLookupResult = adapter.symbolLookup( + result.platform.c_str(), input.symbolName.c_str()); + if (!adapterCallStayedDisabled(symbolLookupResult) || + symbolLookupResult.symbolAddressProduced) { + result.status = LiteBridgeRuntimeStatus::Failed; + result.noSymbolAddressProduced = !symbolLookupResult.symbolAddressProduced; + addPlatformDynamicLoaderRealAdapterDisabledScaffoldIssue( + result, + "platform dynamic-loader real-adapter disabled scaffold symbol lookup probe must stay disabled and produce no symbol address"); + result.summary = platformDynamicLoaderRealAdapterDisabledScaffoldBlockedSummary( + "symbol_lookup_scaffold_probe_failed"); + return result; + } + result.symbolLookupScaffoldProbeAccepted = true; + result.noSymbolAddressProduced = true; + + result.realAdapterDisabledScaffoldReady = true; + result.status = LiteBridgeRuntimeStatus::Ready; + result.ok = true; + result.summary = std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_disabled_scaffold=ready; platform=") + + result.platform + "; scope=disabled-scaffold; execution=disabled"; + return result; +} + +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionPreflightResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionPreflight( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionPreflightInput& input) +{ + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionPreflightResult result; + result.status = LiteBridgeRuntimeStatus::Configured; + result.platform = normalizedPlatform( + input.platform.empty() ? input.disabledScaffold.platform : input.platform); + result.adapterName = input.adapterName.empty() + ? input.disabledScaffold.adapterName + : input.adapterName; + + result.noRuntimePlatformDynamicLibraryLoaded = !input.runtimePlatformLoadAttempted; + result.noRuntimePlatformDynamicLibraryUnloaded = !input.runtimePlatformUnloadAttempted; + result.noRuntimePlatformSymbolResolution = !input.runtimePlatformSymbolResolutionAttempted; + result.noSdxlCalls = !input.sdxlCallRequested; + result.noBridgeCalls = !input.bridgeCallRequested; + result.noServerConnectivityChecked = !input.serverConnectivityCheckRequested; + result.noWalletLifecycle = !input.walletLifecycleRequested; + result.noSyncStarted = !input.syncRequested; + result.noSyncStatusPolled = !input.syncStatusPollingRequested; + result.noWorkerQueueEnqueue = !input.workerQueueRequested; + result.noWalletStateMutation = !input.walletStateMutationRequested; + result.noWalletPersistence = !input.walletPersistenceRequested; + result.noSettingsPersistence = !input.settingsWriteRequested; + result.noSendImportExportExecution = !input.sendImportExportRequested; + result.noArtifactMutation = !input.artifactMutationRequested; + + if (!result.noRuntimePlatformDynamicLibraryLoaded || + !result.noRuntimePlatformDynamicLibraryUnloaded || + !result.noRuntimePlatformSymbolResolution) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionPreflightIssue( + result, + "platform dynamic-loader real-adapter load-only execution preflight must not execute platform loader APIs in runtime"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionPreflightBlockedSummary( + "runtime_platform_api_attempted"); + return result; + } + + if (!result.noSdxlCalls || + !result.noBridgeCalls || + !result.noServerConnectivityChecked || + !result.noWalletLifecycle || + !result.noSyncStarted || + !result.noSyncStatusPolled || + !result.noWorkerQueueEnqueue || + !result.noWalletStateMutation || + !result.noWalletPersistence || + !result.noSettingsPersistence || + !result.noSendImportExportExecution || + !result.noArtifactMutation) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionPreflightIssue( + result, + "platform dynamic-loader real-adapter load-only execution preflight must not request wallet runtime behavior"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionPreflightBlockedSummary( + "runtime_action_requested"); + return result; + } + + if (result.platform.empty()) { + result.status = LiteBridgeRuntimeStatus::Unavailable; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionPreflightIssue( + result, + "platform dynamic-loader real-adapter load-only execution preflight requires a target platform"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionPreflightBlockedSummary( + "platform_missing"); + return result; + } + + if (isMacosPlatform(result.platform)) { + result.macosDeferred = true; + result.status = LiteBridgeRuntimeStatus::Unavailable; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionPreflightIssue( + result, + input.macosDeferredByOperator + ? "macOS platform dynamic-loader real-adapter load-only execution preflight is deferred by operator request" + : "macOS platform dynamic-loader real-adapter load-only execution preflight requires a reviewed builder before promotion"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionPreflightBlockedSummary( + "macos_deferred"); + return result; + } + + const bool linuxPlatform = isLinuxPlatform(result.platform); + const bool windowsPlatform = isWindowsPlatform(result.platform); + if (!linuxPlatform && !windowsPlatform) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionPreflightIssue( + result, + "platform dynamic-loader real-adapter load-only execution preflight supports only Linux and Windows in batch 17"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionPreflightBlockedSummary( + "unsupported_platform"); + return result; + } + + result.platformAccepted = true; + result.linuxPlatformAccepted = linuxPlatform; + result.windowsPlatformAccepted = windowsPlatform; + + const auto& scaffold = input.disabledScaffold; + if (!input.disabledScaffoldAccepted || + !scaffold.ok || + !scaffold.realAdapterDisabledScaffoldReady || + scaffold.status != LiteBridgeRuntimeStatus::Ready || + scaffold.platform != result.platform || + !scaffold.realAdapterAccepted || + !scaffold.runtimeAdapterOwnershipAccepted || + !scaffold.loadScaffoldProbeAccepted || + !scaffold.noHandleProduced || + !scaffold.noHandleReleased || + !scaffold.noSymbolAddressProduced || + !scaffold.productionLoaderDisabled || + !scaffold.realAdapterExecutionDisabled || + !scaffold.noRuntimePlatformDynamicLibraryLoaded || + !scaffold.noRuntimePlatformSymbolResolution) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionPreflightIssue( + result, + "platform dynamic-loader real-adapter load-only execution preflight requires a matching ready disabled scaffold"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionPreflightBlockedSummary( + "disabled_scaffold_required"); + return result; + } + result.disabledScaffoldAccepted = true; + + const auto& binding = input.disabledScaffoldBinding; + if (!input.disabledScaffoldBindingAccepted || + binding.ok || + binding.status != LiteBridgeRuntimeStatus::Configured || + !binding.dynamicLibraryBindingRequested || + !binding.realAdapterDisabledScaffoldResultAccepted || + !binding.realAdapterDisabledScaffoldBindingEvidenceReady || + binding.symbolTableProduced || + binding.symbolTableReady || + binding.runtimeReady || + binding.dynamicLibraryHandlePresent || + !binding.noDynamicLibraryLoaded || + !binding.noPlatformSymbolResolution || + !binding.realAdapterDisabledScaffoldNoHandleProduced || + !binding.realAdapterDisabledScaffoldNoHandleReleased || + !binding.realAdapterDisabledScaffoldNoSymbolAddressProduced || + !binding.realAdapterDisabledScaffoldProductionLoaderDisabled || + !binding.realAdapterDisabledScaffoldExecutionDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionPreflightIssue( + result, + "platform dynamic-loader real-adapter load-only execution preflight requires disabled scaffold binding evidence"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionPreflightBlockedSummary( + "disabled_scaffold_binding_required"); + return result; + } + result.disabledScaffoldBindingAccepted = true; + + if (!input.artifactPathReviewed || input.artifactPath.empty() || result.adapterName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionPreflightIssue( + result, + "platform dynamic-loader real-adapter load-only execution preflight requires reviewed artifact path and adapter identity"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionPreflightBlockedSummary( + "artifact_path_review_required"); + return result; + } + result.artifactPathAccepted = true; + + if (!input.loadOnlyScopeReviewed || + !input.loadCallbackIsolationReviewed || + !input.operatorApprovalRequired) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionPreflightIssue( + result, + "platform dynamic-loader real-adapter load-only execution preflight requires reviewed load-only scope and operator approval boundary"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionPreflightBlockedSummary( + "load_only_scope_required"); + return result; + } + result.loadOnlyScopeAccepted = true; + result.loadCallbackIsolationAccepted = true; + result.operatorApprovalRequired = true; + + if ((linuxPlatform && !input.linuxPlatformLoadApiReviewed) || + (windowsPlatform && !input.windowsPlatformLoadApiReviewed)) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionPreflightIssue( + result, + "platform dynamic-loader real-adapter load-only execution preflight requires reviewed platform load API mapping"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionPreflightBlockedSummary( + "platform_load_api_review_required"); + return result; + } + result.platformLoadApiReviewAccepted = true; + + if (!input.loadFailureMappingReviewed) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionPreflightIssue( + result, + "platform dynamic-loader real-adapter load-only execution preflight requires load failure mapping review"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionPreflightBlockedSummary( + "load_failure_mapping_required"); + return result; + } + result.loadFailureMappingAccepted = true; + + if (!input.opaqueHandleStoragePlanReviewed || !input.handleCleanupFallbackReviewed) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionPreflightIssue( + result, + "platform dynamic-loader real-adapter load-only execution preflight requires handle storage and cleanup fallback review"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionPreflightBlockedSummary( + "handle_storage_plan_required"); + return result; + } + result.handleStoragePlanAccepted = true; + + if (!input.unloadExecutionStillDisabled || !input.symbolResolutionStillDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionPreflightIssue( + result, + "platform dynamic-loader real-adapter load-only execution preflight must keep unload and symbol resolution disabled"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionPreflightBlockedSummary( + "non_load_execution_enabled"); + return result; + } + result.unloadExecutionBlocked = true; + result.symbolResolutionBlocked = true; + + if (!input.productionLoaderExecutionDisabled || + !input.realAdapterExecutionDisabled || + !input.loadOnlyExecutionDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionPreflightIssue( + result, + "platform dynamic-loader real-adapter load-only execution preflight must keep real loader execution disabled"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionPreflightBlockedSummary( + "production_loader_enabled"); + return result; + } + result.productionLoaderDisabled = true; + result.realAdapterExecutionDisabled = true; + result.loadOnlyExecutionDisabled = true; + + result.loadOnlyExecutionPreflightReady = true; + result.status = LiteBridgeRuntimeStatus::Ready; + result.ok = true; + result.summary = std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_preflight=ready; platform=") + + result.platform + "; scope=load-only-preflight; execution=disabled"; + return result; +} + +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionApprovalGateResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionApprovalGate( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionApprovalGateInput& input) +{ + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionApprovalGateResult result; + result.status = LiteBridgeRuntimeStatus::Configured; + result.platform = normalizedPlatform( + input.platform.empty() ? input.loadOnlyPreflight.platform : input.platform); + result.adapterName = input.adapterName.empty() + ? input.loadOnlyPreflight.adapterName + : input.adapterName; + result.approvalId = input.approvalId; + result.releaseBuilderId = input.releaseBuilderId; + result.loadOnlyEvidenceId = input.loadOnlyEvidenceId; + + result.noRuntimePlatformDynamicLibraryLoaded = !input.runtimePlatformLoadAttempted; + result.noRuntimePlatformDynamicLibraryUnloaded = !input.runtimePlatformUnloadAttempted; + result.noRuntimePlatformSymbolResolution = !input.runtimePlatformSymbolResolutionAttempted; + result.noSdxlCalls = !input.sdxlCallRequested; + result.noBridgeCalls = !input.bridgeCallRequested; + result.noServerConnectivityChecked = !input.serverConnectivityCheckRequested; + result.noWalletLifecycle = !input.walletLifecycleRequested; + result.noSyncStarted = !input.syncRequested; + result.noSyncStatusPolled = !input.syncStatusPollingRequested; + result.noWorkerQueueEnqueue = !input.workerQueueRequested; + result.noWalletStateMutation = !input.walletStateMutationRequested; + result.noWalletPersistence = !input.walletPersistenceRequested; + result.noSettingsPersistence = !input.settingsWriteRequested; + result.noSendImportExportExecution = !input.sendImportExportRequested; + result.noArtifactMutation = !input.artifactMutationRequested; + + if (!result.noRuntimePlatformDynamicLibraryLoaded || + !result.noRuntimePlatformDynamicLibraryUnloaded || + !result.noRuntimePlatformSymbolResolution) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionApprovalGateIssue( + result, + "platform dynamic-loader real-adapter load-only execution approval gate must not execute platform loader APIs in runtime"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionApprovalGateBlockedSummary( + "runtime_platform_api_attempted"); + return result; + } + + if (!result.noSdxlCalls || + !result.noBridgeCalls || + !result.noServerConnectivityChecked || + !result.noWalletLifecycle || + !result.noSyncStarted || + !result.noSyncStatusPolled || + !result.noWorkerQueueEnqueue || + !result.noWalletStateMutation || + !result.noWalletPersistence || + !result.noSettingsPersistence || + !result.noSendImportExportExecution || + !result.noArtifactMutation) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionApprovalGateIssue( + result, + "platform dynamic-loader real-adapter load-only execution approval gate must not request wallet runtime behavior"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionApprovalGateBlockedSummary( + "runtime_action_requested"); + return result; + } + + if (result.platform.empty()) { + result.status = LiteBridgeRuntimeStatus::Unavailable; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionApprovalGateIssue( + result, + "platform dynamic-loader real-adapter load-only execution approval gate requires a target platform"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionApprovalGateBlockedSummary( + "platform_missing"); + return result; + } + + if (isMacosPlatform(result.platform)) { + result.macosDeferred = true; + result.status = LiteBridgeRuntimeStatus::Unavailable; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionApprovalGateIssue( + result, + input.macosDeferredByOperator + ? "macOS platform dynamic-loader real-adapter load-only execution approval gate is deferred by operator request" + : "macOS platform dynamic-loader real-adapter load-only execution approval gate requires a reviewed builder before promotion"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionApprovalGateBlockedSummary( + "macos_deferred"); + return result; + } + + const bool linuxPlatform = isLinuxPlatform(result.platform); + const bool windowsPlatform = isWindowsPlatform(result.platform); + if (!linuxPlatform && !windowsPlatform) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionApprovalGateIssue( + result, + "platform dynamic-loader real-adapter load-only execution approval gate supports only Linux and Windows in batch 18"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionApprovalGateBlockedSummary( + "unsupported_platform"); + return result; + } + + result.platformAccepted = true; + result.linuxPlatformAccepted = linuxPlatform; + result.windowsPlatformAccepted = windowsPlatform; + + const auto& preflight = input.loadOnlyPreflight; + if (!input.loadOnlyPreflightAccepted || + !preflight.ok || + !preflight.loadOnlyExecutionPreflightReady || + preflight.status != LiteBridgeRuntimeStatus::Ready || + preflight.platform != result.platform || + !preflight.operatorApprovalRequired || + !preflight.unloadExecutionBlocked || + !preflight.symbolResolutionBlocked || + !preflight.productionLoaderDisabled || + !preflight.realAdapterExecutionDisabled || + !preflight.loadOnlyExecutionDisabled || + !preflight.noRuntimePlatformDynamicLibraryLoaded || + !preflight.noRuntimePlatformSymbolResolution) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionApprovalGateIssue( + result, + "platform dynamic-loader real-adapter load-only execution approval gate requires a matching ready load-only preflight"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionApprovalGateBlockedSummary( + "load_only_preflight_required"); + return result; + } + result.loadOnlyPreflightAccepted = true; + + if (!input.operatorApprovalGranted || + !input.operatorApprovalRecorded || + !input.operatorApprovalScopeReviewed || + input.approvalId.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionApprovalGateIssue( + result, + "platform dynamic-loader real-adapter load-only execution approval gate requires explicit recorded operator approval"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionApprovalGateBlockedSummary( + "operator_approval_required"); + return result; + } + result.operatorApprovalAccepted = true; + + if (!input.releaseBuilderIdentityReviewed || + !input.releaseBuilderTrusted || + input.releaseBuilderId.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionApprovalGateIssue( + result, + "platform dynamic-loader real-adapter load-only execution approval gate requires reviewed release-builder evidence"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionApprovalGateBlockedSummary( + "release_builder_evidence_required"); + return result; + } + result.releaseBuilderEvidenceAccepted = true; + + if (!input.loadOnlyEvidenceReviewed || + !input.loadOnlyEvidenceMatchesPreflight || + !input.loadOnlyEvidenceRecordsLoadOnly || + !input.loadOnlyEvidenceNoSymbolResolution || + !input.loadOnlyEvidenceNoWalletRuntime || + input.loadOnlyEvidenceId.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionApprovalGateIssue( + result, + "platform dynamic-loader real-adapter load-only execution approval gate requires load-only evidence without symbol resolution or wallet runtime behavior"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionApprovalGateBlockedSummary( + "load_only_evidence_required"); + return result; + } + result.loadOnlyEvidenceAccepted = true; + + if (!input.artifactPathReviewed || + !input.artifactSha256Reviewed || + input.artifactPath.empty() || + input.artifactSha256.empty() || + result.adapterName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionApprovalGateIssue( + result, + "platform dynamic-loader real-adapter load-only execution approval gate requires reviewed artifact path and hash evidence"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionApprovalGateBlockedSummary( + "artifact_evidence_required"); + return result; + } + result.artifactEvidenceAccepted = true; + + if (!input.handleCleanupEvidenceReviewed) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionApprovalGateIssue( + result, + "platform dynamic-loader real-adapter load-only execution approval gate requires handle cleanup evidence review"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionApprovalGateBlockedSummary( + "handle_cleanup_evidence_required"); + return result; + } + result.handleCleanupEvidenceAccepted = true; + + if (!input.changeControlReviewed || !input.rollbackPlanReviewed) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionApprovalGateIssue( + result, + "platform dynamic-loader real-adapter load-only execution approval gate requires change control and rollback review"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionApprovalGateBlockedSummary( + "change_control_required"); + return result; + } + result.changeControlAccepted = true; + result.rollbackPlanAccepted = true; + + if (!input.unloadExecutionStillDisabled || !input.symbolResolutionStillDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionApprovalGateIssue( + result, + "platform dynamic-loader real-adapter load-only execution approval gate must keep unload and symbol resolution disabled"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionApprovalGateBlockedSummary( + "non_load_execution_enabled"); + return result; + } + result.unloadExecutionBlocked = true; + result.symbolResolutionBlocked = true; + + if (!input.productionLoaderExecutionDisabled || + !input.realAdapterExecutionDisabled || + !input.loadOnlyExecutionDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionApprovalGateIssue( + result, + "platform dynamic-loader real-adapter load-only execution approval gate must keep real loader execution disabled"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionApprovalGateBlockedSummary( + "production_loader_enabled"); + return result; + } + result.productionLoaderDisabled = true; + result.realAdapterExecutionDisabled = true; + result.loadOnlyExecutionDisabled = true; + + if (!input.separateExecutionBatchRequired) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionApprovalGateIssue( + result, + "platform dynamic-loader real-adapter load-only execution approval gate requires a separate execution batch"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionApprovalGateBlockedSummary( + "separate_execution_batch_required"); + return result; + } + result.separateExecutionBatchRequired = true; + + result.loadOnlyExecutionApprovalGateReady = true; + result.status = LiteBridgeRuntimeStatus::Ready; + result.ok = true; + result.summary = std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_approval_gate=ready; platform=") + + result.platform + "; scope=load-only-approval; execution=disabled"; + return result; +} + +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledOwnerHandoffResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledOwnerHandoff( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledOwnerHandoffInput& input) +{ + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledOwnerHandoffResult result; + result.status = LiteBridgeRuntimeStatus::Configured; + result.platform = normalizedPlatform( + input.platform.empty() ? input.approvalGate.platform : input.platform); + result.adapterName = input.adapterName.empty() + ? input.approvalGate.adapterName + : input.adapterName; + result.ownerName = input.ownerName; + result.handoffId = input.handoffId; + result.loadCallbackBoundaryName = input.loadCallbackBoundaryName; + + result.noRuntimePlatformDynamicLibraryLoaded = !input.runtimePlatformLoadAttempted; + result.noRuntimePlatformDynamicLibraryUnloaded = !input.runtimePlatformUnloadAttempted; + result.noRuntimePlatformSymbolResolution = !input.runtimePlatformSymbolResolutionAttempted; + result.noSdxlCalls = !input.sdxlCallRequested; + result.noBridgeCalls = !input.bridgeCallRequested; + result.noServerConnectivityChecked = !input.serverConnectivityCheckRequested; + result.noWalletLifecycle = !input.walletLifecycleRequested; + result.noSyncStarted = !input.syncRequested; + result.noSyncStatusPolled = !input.syncStatusPollingRequested; + result.noWorkerQueueEnqueue = !input.workerQueueRequested; + result.noWalletStateMutation = !input.walletStateMutationRequested; + result.noWalletPersistence = !input.walletPersistenceRequested; + result.noSettingsPersistence = !input.settingsWriteRequested; + result.noSendImportExportExecution = !input.sendImportExportRequested; + result.noArtifactMutation = !input.artifactMutationRequested; + + if (!result.noRuntimePlatformDynamicLibraryLoaded || + !result.noRuntimePlatformDynamicLibraryUnloaded || + !result.noRuntimePlatformSymbolResolution) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledOwnerHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled owner handoff must not execute platform loader APIs in runtime"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledOwnerHandoffBlockedSummary( + "runtime_platform_api_attempted"); + return result; + } + + if (!result.noSdxlCalls || + !result.noBridgeCalls || + !result.noServerConnectivityChecked || + !result.noWalletLifecycle || + !result.noSyncStarted || + !result.noSyncStatusPolled || + !result.noWorkerQueueEnqueue || + !result.noWalletStateMutation || + !result.noWalletPersistence || + !result.noSettingsPersistence || + !result.noSendImportExportExecution || + !result.noArtifactMutation) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledOwnerHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled owner handoff must not request wallet runtime behavior"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledOwnerHandoffBlockedSummary( + "runtime_action_requested"); + return result; + } + + if (result.platform.empty()) { + result.status = LiteBridgeRuntimeStatus::Unavailable; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledOwnerHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled owner handoff requires a target platform"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledOwnerHandoffBlockedSummary( + "platform_missing"); + return result; + } + + if (isMacosPlatform(result.platform)) { + result.macosDeferred = true; + result.status = LiteBridgeRuntimeStatus::Unavailable; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledOwnerHandoffIssue( + result, + input.macosDeferredByOperator + ? "macOS platform dynamic-loader real-adapter load-only execution disabled owner handoff is deferred by operator request" + : "macOS platform dynamic-loader real-adapter load-only execution disabled owner handoff requires a reviewed builder before promotion"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledOwnerHandoffBlockedSummary( + "macos_deferred"); + return result; + } + + const bool linuxPlatform = isLinuxPlatform(result.platform); + const bool windowsPlatform = isWindowsPlatform(result.platform); + if (!linuxPlatform && !windowsPlatform) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledOwnerHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled owner handoff supports only Linux and Windows in batch 19"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledOwnerHandoffBlockedSummary( + "unsupported_platform"); + return result; + } + + result.platformAccepted = true; + result.linuxPlatformAccepted = linuxPlatform; + result.windowsPlatformAccepted = windowsPlatform; + + const auto& approvalGate = input.approvalGate; + if (!input.approvalGateAccepted || + !approvalGate.ok || + !approvalGate.loadOnlyExecutionApprovalGateReady || + approvalGate.status != LiteBridgeRuntimeStatus::Ready || + approvalGate.platform != result.platform || + !approvalGate.loadOnlyPreflightAccepted || + !approvalGate.operatorApprovalAccepted || + !approvalGate.releaseBuilderEvidenceAccepted || + !approvalGate.loadOnlyEvidenceAccepted || + !approvalGate.artifactEvidenceAccepted || + !approvalGate.handleCleanupEvidenceAccepted || + !approvalGate.changeControlAccepted || + !approvalGate.rollbackPlanAccepted || + !approvalGate.unloadExecutionBlocked || + !approvalGate.symbolResolutionBlocked || + !approvalGate.productionLoaderDisabled || + !approvalGate.realAdapterExecutionDisabled || + !approvalGate.loadOnlyExecutionDisabled || + !approvalGate.separateExecutionBatchRequired || + !approvalGate.noRuntimePlatformDynamicLibraryLoaded || + !approvalGate.noRuntimePlatformSymbolResolution) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledOwnerHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled owner handoff requires a matching ready approval gate"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledOwnerHandoffBlockedSummary( + "approval_gate_required"); + return result; + } + result.approvalGateAccepted = true; + + if (!input.runtimeOwnerIdentified || + !input.runtimeOwnerHandoffReviewed || + input.ownerName.empty() || + input.handoffId.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledOwnerHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled owner handoff requires reviewed runtime owner handoff evidence"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledOwnerHandoffBlockedSummary( + "runtime_owner_handoff_required"); + return result; + } + result.runtimeOwnerHandoffAccepted = true; + + if (!input.loadCallbackBoundaryNamed || + !input.loadCallbackBoundaryReviewed || + input.loadCallbackBoundaryName.empty() || + result.adapterName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledOwnerHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled owner handoff requires a named reviewed future load callback boundary"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledOwnerHandoffBlockedSummary( + "load_callback_boundary_required"); + return result; + } + result.loadCallbackBoundaryAccepted = true; + + if (!input.loadCallbackExecutionStillDisabled || + !input.loadCallbackRequiresSeparateExecutionBatch) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledOwnerHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled owner handoff must keep the future load callback disabled"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledOwnerHandoffBlockedSummary( + "load_callback_execution_disabled_required"); + return result; + } + result.loadCallbackExecutionBlocked = true; + + if (!input.ownerStoresNoDynamicHandle || + !input.ownerReleasesNoDynamicHandle || + !input.ownerStoresNoSymbolTable) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledOwnerHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled owner handoff must not store runtime handles or symbol tables"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledOwnerHandoffBlockedSummary( + "disabled_owner_state_required"); + return result; + } + result.disabledOwnerStateAccepted = true; + + if (!input.unloadExecutionStillDisabled || !input.symbolResolutionStillDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledOwnerHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled owner handoff must keep unload and symbol resolution disabled"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledOwnerHandoffBlockedSummary( + "non_load_execution_enabled"); + return result; + } + result.unloadExecutionBlocked = true; + result.symbolResolutionBlocked = true; + + if (!input.productionLoaderExecutionDisabled || + !input.realAdapterExecutionDisabled || + !input.loadOnlyExecutionDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledOwnerHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled owner handoff must keep real loader execution disabled"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledOwnerHandoffBlockedSummary( + "production_loader_enabled"); + return result; + } + result.productionLoaderDisabled = true; + result.realAdapterExecutionDisabled = true; + result.loadOnlyExecutionDisabled = true; + + if (!input.separateExecutionBatchRequired) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledOwnerHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled owner handoff requires a separate execution batch"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledOwnerHandoffBlockedSummary( + "separate_execution_batch_required"); + return result; + } + result.separateExecutionBatchRequired = true; + + result.loadOnlyExecutionDisabledOwnerHandoffReady = true; + result.status = LiteBridgeRuntimeStatus::Ready; + result.ok = true; + result.summary = std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_owner_handoff=ready; platform=") + + result.platform + "; scope=load-only-disabled-owner-handoff; execution=disabled"; + return result; +} + +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackBindingResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackBinding( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackBindingInput& input) +{ + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackBindingResult result; + result.status = LiteBridgeRuntimeStatus::Configured; + result.platform = normalizedPlatform( + input.platform.empty() ? input.disabledOwnerHandoff.platform : input.platform); + result.adapterName = input.adapterName.empty() + ? input.disabledOwnerHandoff.adapterName + : input.adapterName; + result.ownerName = input.ownerName.empty() + ? input.disabledOwnerHandoff.ownerName + : input.ownerName; + result.handoffId = input.handoffId.empty() + ? input.disabledOwnerHandoff.handoffId + : input.handoffId; + result.loadCallbackBoundaryName = input.loadCallbackBoundaryName.empty() + ? input.disabledOwnerHandoff.loadCallbackBoundaryName + : input.loadCallbackBoundaryName; + result.callbackBindingId = input.callbackBindingId; + result.callbackName = input.callbackName; + + result.noRuntimePlatformDynamicLibraryLoaded = !input.runtimePlatformLoadAttempted; + result.noRuntimePlatformDynamicLibraryUnloaded = !input.runtimePlatformUnloadAttempted; + result.noRuntimePlatformSymbolResolution = !input.runtimePlatformSymbolResolutionAttempted; + result.noSdxlCalls = !input.sdxlCallRequested; + result.noBridgeCalls = !input.bridgeCallRequested; + result.noServerConnectivityChecked = !input.serverConnectivityCheckRequested; + result.noWalletLifecycle = !input.walletLifecycleRequested; + result.noSyncStarted = !input.syncRequested; + result.noSyncStatusPolled = !input.syncStatusPollingRequested; + result.noWorkerQueueEnqueue = !input.workerQueueRequested; + result.noWalletStateMutation = !input.walletStateMutationRequested; + result.noWalletPersistence = !input.walletPersistenceRequested; + result.noSettingsPersistence = !input.settingsWriteRequested; + result.noSendImportExportExecution = !input.sendImportExportRequested; + result.noArtifactMutation = !input.artifactMutationRequested; + + if (!result.noRuntimePlatformDynamicLibraryLoaded || + !result.noRuntimePlatformDynamicLibraryUnloaded || + !result.noRuntimePlatformSymbolResolution) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackBindingIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback binding must not execute platform loader APIs in runtime"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackBindingBlockedSummary( + "runtime_platform_api_attempted"); + return result; + } + + if (!result.noSdxlCalls || + !result.noBridgeCalls || + !result.noServerConnectivityChecked || + !result.noWalletLifecycle || + !result.noSyncStarted || + !result.noSyncStatusPolled || + !result.noWorkerQueueEnqueue || + !result.noWalletStateMutation || + !result.noWalletPersistence || + !result.noSettingsPersistence || + !result.noSendImportExportExecution || + !result.noArtifactMutation) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackBindingIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback binding must not request wallet runtime behavior"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackBindingBlockedSummary( + "runtime_action_requested"); + return result; + } + + if (result.platform.empty()) { + result.status = LiteBridgeRuntimeStatus::Unavailable; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackBindingIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback binding requires a target platform"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackBindingBlockedSummary( + "platform_missing"); + return result; + } + + if (isMacosPlatform(result.platform)) { + result.macosDeferred = true; + result.status = LiteBridgeRuntimeStatus::Unavailable; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackBindingIssue( + result, + input.macosDeferredByOperator + ? "macOS platform dynamic-loader real-adapter load-only execution disabled callback binding is deferred by operator request" + : "macOS platform dynamic-loader real-adapter load-only execution disabled callback binding requires a reviewed builder before promotion"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackBindingBlockedSummary( + "macos_deferred"); + return result; + } + + const bool linuxPlatform = isLinuxPlatform(result.platform); + const bool windowsPlatform = isWindowsPlatform(result.platform); + if (!linuxPlatform && !windowsPlatform) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackBindingIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback binding supports only Linux and Windows in batch 20"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackBindingBlockedSummary( + "unsupported_platform"); + return result; + } + + result.platformAccepted = true; + result.linuxPlatformAccepted = linuxPlatform; + result.windowsPlatformAccepted = windowsPlatform; + + const auto& handoff = input.disabledOwnerHandoff; + if (!input.disabledOwnerHandoffAccepted || + !handoff.ok || + !handoff.loadOnlyExecutionDisabledOwnerHandoffReady || + handoff.status != LiteBridgeRuntimeStatus::Ready || + handoff.platform != result.platform || + !handoff.approvalGateAccepted || + !handoff.runtimeOwnerHandoffAccepted || + !handoff.loadCallbackBoundaryAccepted || + !handoff.loadCallbackExecutionBlocked || + !handoff.disabledOwnerStateAccepted || + !handoff.unloadExecutionBlocked || + !handoff.symbolResolutionBlocked || + !handoff.productionLoaderDisabled || + !handoff.realAdapterExecutionDisabled || + !handoff.loadOnlyExecutionDisabled || + !handoff.separateExecutionBatchRequired || + !handoff.noRuntimePlatformDynamicLibraryLoaded || + !handoff.noRuntimePlatformSymbolResolution) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackBindingIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback binding requires a matching ready disabled owner handoff"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackBindingBlockedSummary( + "disabled_owner_handoff_required"); + return result; + } + result.disabledOwnerHandoffAccepted = true; + + if (!input.callbackBindingRecordReviewed || + !input.callbackBindingRecordDisabled || + input.callbackBindingId.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackBindingIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback binding requires a reviewed disabled callback binding record"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackBindingBlockedSummary( + "callback_binding_record_required"); + return result; + } + result.callbackBindingRecordAccepted = true; + + if (!input.callbackOwnerMatchesHandoff || + !input.callbackBoundaryMatchesHandoff || + result.ownerName != handoff.ownerName || + result.handoffId != handoff.handoffId || + result.loadCallbackBoundaryName != handoff.loadCallbackBoundaryName || + result.adapterName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackBindingIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback binding requires owner and boundary match evidence"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackBindingBlockedSummary( + "callback_owner_boundary_required"); + return result; + } + result.callbackOwnerBoundaryAccepted = true; + + if (!input.callbackEntryPointNamed || + !input.callbackEntryPointReviewed || + input.callbackName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackBindingIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback binding requires a named reviewed disabled callback entry point"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackBindingBlockedSummary( + "callback_entry_point_required"); + return result; + } + result.callbackEntryPointAccepted = true; + + if (!input.callbackInvocationStillDisabled || + !input.callbackRequiresSeparateExecutionBatch) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackBindingIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback binding must keep callback invocation disabled"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackBindingBlockedSummary( + "callback_invocation_disabled_required"); + return result; + } + result.callbackInvocationBlocked = true; + + if (!input.callbackProducesNoDynamicHandle || + !input.callbackStoresNoDynamicHandle || + !input.callbackReleasesNoDynamicHandle || + !input.callbackResolvesNoSymbols || + !input.callbackStoresNoSymbolTable || + !input.callbackCreatesNoRuntime) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackBindingIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback binding must not create runtime loader state"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackBindingBlockedSummary( + "disabled_callback_state_required"); + return result; + } + result.disabledCallbackStateAccepted = true; + + if (!input.callbackFailureMappingReviewed) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackBindingIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback binding requires disabled callback failure mapping review"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackBindingBlockedSummary( + "callback_failure_mapping_required"); + return result; + } + result.callbackFailureMappingAccepted = true; + + if (!input.unloadExecutionStillDisabled || !input.symbolResolutionStillDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackBindingIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback binding must keep unload and symbol resolution disabled"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackBindingBlockedSummary( + "non_load_execution_enabled"); + return result; + } + result.unloadExecutionBlocked = true; + result.symbolResolutionBlocked = true; + + if (!input.productionLoaderExecutionDisabled || + !input.realAdapterExecutionDisabled || + !input.loadOnlyExecutionDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackBindingIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback binding must keep real loader execution disabled"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackBindingBlockedSummary( + "production_loader_enabled"); + return result; + } + result.productionLoaderDisabled = true; + result.realAdapterExecutionDisabled = true; + result.loadOnlyExecutionDisabled = true; + + if (!input.separateExecutionBatchRequired) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackBindingIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback binding requires a separate execution batch"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackBindingBlockedSummary( + "separate_execution_batch_required"); + return result; + } + result.separateExecutionBatchRequired = true; + + result.loadOnlyExecutionDisabledCallbackBindingReady = true; + result.status = LiteBridgeRuntimeStatus::Ready; + result.ok = true; + result.summary = std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_binding=ready; platform=") + + result.platform + "; scope=load-only-disabled-callback-binding; execution=disabled"; + return result; +} + +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackPreInvocationGuardResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackPreInvocationGuard( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackPreInvocationGuardInput& input) +{ + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackPreInvocationGuardResult result; + result.status = LiteBridgeRuntimeStatus::Configured; + result.platform = normalizedPlatform( + input.platform.empty() ? input.disabledCallbackBinding.platform : input.platform); + result.adapterName = input.adapterName.empty() + ? input.disabledCallbackBinding.adapterName + : input.adapterName; + result.ownerName = input.ownerName.empty() + ? input.disabledCallbackBinding.ownerName + : input.ownerName; + result.handoffId = input.handoffId.empty() + ? input.disabledCallbackBinding.handoffId + : input.handoffId; + result.loadCallbackBoundaryName = input.loadCallbackBoundaryName.empty() + ? input.disabledCallbackBinding.loadCallbackBoundaryName + : input.loadCallbackBoundaryName; + result.callbackBindingId = input.callbackBindingId.empty() + ? input.disabledCallbackBinding.callbackBindingId + : input.callbackBindingId; + result.callbackName = input.callbackName.empty() + ? input.disabledCallbackBinding.callbackName + : input.callbackName; + result.guardId = input.guardId; + + result.noCallbackInvocationAttempted = !input.callbackInvocationAttempted; + result.noRuntimePlatformDynamicLibraryLoaded = !input.runtimePlatformLoadAttempted; + result.noRuntimePlatformDynamicLibraryUnloaded = !input.runtimePlatformUnloadAttempted; + result.noRuntimePlatformSymbolResolution = !input.runtimePlatformSymbolResolutionAttempted; + result.noSdxlCalls = !input.sdxlCallRequested; + result.noBridgeCalls = !input.bridgeCallRequested; + result.noServerConnectivityChecked = !input.serverConnectivityCheckRequested; + result.noWalletLifecycle = !input.walletLifecycleRequested; + result.noSyncStarted = !input.syncRequested; + result.noSyncStatusPolled = !input.syncStatusPollingRequested; + result.noWorkerQueueEnqueue = !input.workerQueueRequested; + result.noWalletStateMutation = !input.walletStateMutationRequested; + result.noWalletPersistence = !input.walletPersistenceRequested; + result.noSettingsPersistence = !input.settingsWriteRequested; + result.noSendImportExportExecution = !input.sendImportExportRequested; + result.noArtifactMutation = !input.artifactMutationRequested; + + if (!result.noCallbackInvocationAttempted || + !result.noRuntimePlatformDynamicLibraryLoaded || + !result.noRuntimePlatformDynamicLibraryUnloaded || + !result.noRuntimePlatformSymbolResolution) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackPreInvocationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback pre-invocation guard must stop before callback invocation and platform loader APIs"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackPreInvocationGuardBlockedSummary( + "callback_or_platform_api_attempted"); + return result; + } + + if (!result.noSdxlCalls || + !result.noBridgeCalls || + !result.noServerConnectivityChecked || + !result.noWalletLifecycle || + !result.noSyncStarted || + !result.noSyncStatusPolled || + !result.noWorkerQueueEnqueue || + !result.noWalletStateMutation || + !result.noWalletPersistence || + !result.noSettingsPersistence || + !result.noSendImportExportExecution || + !result.noArtifactMutation) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackPreInvocationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback pre-invocation guard must not request wallet runtime behavior"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackPreInvocationGuardBlockedSummary( + "runtime_action_requested"); + return result; + } + + if (result.platform.empty()) { + result.status = LiteBridgeRuntimeStatus::Unavailable; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackPreInvocationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback pre-invocation guard requires a target platform"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackPreInvocationGuardBlockedSummary( + "platform_missing"); + return result; + } + + if (isMacosPlatform(result.platform)) { + result.macosDeferred = true; + result.status = LiteBridgeRuntimeStatus::Unavailable; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackPreInvocationGuardIssue( + result, + input.macosDeferredByOperator + ? "macOS platform dynamic-loader real-adapter load-only execution disabled callback pre-invocation guard is deferred by operator request" + : "macOS platform dynamic-loader real-adapter load-only execution disabled callback pre-invocation guard requires a reviewed builder before promotion"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackPreInvocationGuardBlockedSummary( + "macos_deferred"); + return result; + } + + const bool linuxPlatform = isLinuxPlatform(result.platform); + const bool windowsPlatform = isWindowsPlatform(result.platform); + if (!linuxPlatform && !windowsPlatform) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackPreInvocationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback pre-invocation guard supports only Linux and Windows in batch 21"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackPreInvocationGuardBlockedSummary( + "unsupported_platform"); + return result; + } + + result.platformAccepted = true; + result.linuxPlatformAccepted = linuxPlatform; + result.windowsPlatformAccepted = windowsPlatform; + + const auto& binding = input.disabledCallbackBinding; + if (!input.disabledCallbackBindingAccepted || + !binding.ok || + !binding.loadOnlyExecutionDisabledCallbackBindingReady || + binding.status != LiteBridgeRuntimeStatus::Ready || + binding.platform != result.platform || + !binding.disabledOwnerHandoffAccepted || + !binding.callbackBindingRecordAccepted || + !binding.callbackOwnerBoundaryAccepted || + !binding.callbackEntryPointAccepted || + !binding.callbackInvocationBlocked || + !binding.disabledCallbackStateAccepted || + !binding.callbackFailureMappingAccepted || + !binding.unloadExecutionBlocked || + !binding.symbolResolutionBlocked || + !binding.productionLoaderDisabled || + !binding.realAdapterExecutionDisabled || + !binding.loadOnlyExecutionDisabled || + !binding.separateExecutionBatchRequired || + !binding.noRuntimePlatformDynamicLibraryLoaded || + !binding.noRuntimePlatformSymbolResolution) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackPreInvocationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback pre-invocation guard requires a matching ready disabled callback binding"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackPreInvocationGuardBlockedSummary( + "disabled_callback_binding_required"); + return result; + } + result.disabledCallbackBindingAccepted = true; + + if (!input.preInvocationGuardReviewed || + !input.preInvocationGuardActive || + input.guardId.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackPreInvocationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback pre-invocation guard requires reviewed active guard evidence"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackPreInvocationGuardBlockedSummary( + "pre_invocation_guard_required"); + return result; + } + result.preInvocationGuardAccepted = true; + + if (!input.guardOwnerMatchesCallbackBinding || + !input.guardBoundaryMatchesCallbackBinding || + !input.guardCallbackMatchesCallbackBinding || + result.ownerName != binding.ownerName || + result.handoffId != binding.handoffId || + result.loadCallbackBoundaryName != binding.loadCallbackBoundaryName || + result.callbackBindingId != binding.callbackBindingId || + result.callbackName != binding.callbackName || + result.adapterName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackPreInvocationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback pre-invocation guard requires guard-to-binding match evidence"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackPreInvocationGuardBlockedSummary( + "guard_binding_match_required"); + return result; + } + result.guardCallbackBindingMatchAccepted = true; + + if (!input.callbackInvocationStillDisabled || + !input.callbackInvocationRefused || + !input.callbackInvocationRefusalReviewed || + !input.guardStopsBeforePlatformApi || + !input.guardReturnsDisabledResult || + !input.guardRequiresSeparateExecutionBatch) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackPreInvocationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback pre-invocation guard must refuse callback invocation before platform APIs"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackPreInvocationGuardBlockedSummary( + "callback_refusal_required"); + return result; + } + result.callbackInvocationRefused = true; + result.platformApiPreInvocationBlocked = true; + + if (!input.guardProducesNoDynamicHandle || + !input.guardStoresNoDynamicHandle || + !input.guardReleasesNoDynamicHandle || + !input.guardResolvesNoSymbols || + !input.guardStoresNoSymbolTable || + !input.guardCreatesNoRuntime) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackPreInvocationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback pre-invocation guard must not create runtime loader state"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackPreInvocationGuardBlockedSummary( + "disabled_guard_state_required"); + return result; + } + result.disabledGuardStateAccepted = true; + + if (!input.guardFailureMappingReviewed) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackPreInvocationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback pre-invocation guard requires disabled guard failure mapping review"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackPreInvocationGuardBlockedSummary( + "guard_failure_mapping_required"); + return result; + } + result.guardFailureMappingAccepted = true; + + if (!input.unloadExecutionStillDisabled || !input.symbolResolutionStillDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackPreInvocationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback pre-invocation guard must keep unload and symbol resolution disabled"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackPreInvocationGuardBlockedSummary( + "non_load_execution_enabled"); + return result; + } + result.unloadExecutionBlocked = true; + result.symbolResolutionBlocked = true; + + if (!input.productionLoaderExecutionDisabled || + !input.realAdapterExecutionDisabled || + !input.loadOnlyExecutionDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackPreInvocationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback pre-invocation guard must keep real loader execution disabled"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackPreInvocationGuardBlockedSummary( + "production_loader_enabled"); + return result; + } + result.productionLoaderDisabled = true; + result.realAdapterExecutionDisabled = true; + result.loadOnlyExecutionDisabled = true; + + if (!input.separateExecutionBatchRequired) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackPreInvocationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback pre-invocation guard requires a separate execution batch"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackPreInvocationGuardBlockedSummary( + "separate_execution_batch_required"); + return result; + } + result.separateExecutionBatchRequired = true; + + result.loadOnlyExecutionDisabledCallbackPreInvocationGuardReady = true; + result.status = LiteBridgeRuntimeStatus::Ready; + result.ok = true; + result.summary = std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_pre_invocation_guard=ready; platform=") + + result.platform + "; scope=load-only-disabled-callback-pre-invocation-guard; execution=disabled"; + return result; +} + +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResult( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultInput& input) +{ + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultResult result; + result.status = LiteBridgeRuntimeStatus::Configured; + result.platform = normalizedPlatform( + input.platform.empty() ? input.preInvocationGuard.platform : input.platform); + result.adapterName = input.adapterName.empty() + ? input.preInvocationGuard.adapterName + : input.adapterName; + result.ownerName = input.ownerName.empty() + ? input.preInvocationGuard.ownerName + : input.ownerName; + result.handoffId = input.handoffId.empty() + ? input.preInvocationGuard.handoffId + : input.handoffId; + result.loadCallbackBoundaryName = input.loadCallbackBoundaryName.empty() + ? input.preInvocationGuard.loadCallbackBoundaryName + : input.loadCallbackBoundaryName; + result.callbackBindingId = input.callbackBindingId.empty() + ? input.preInvocationGuard.callbackBindingId + : input.callbackBindingId; + result.callbackName = input.callbackName.empty() + ? input.preInvocationGuard.callbackName + : input.callbackName; + result.guardId = input.guardId.empty() + ? input.preInvocationGuard.guardId + : input.guardId; + result.refusalResultId = input.refusalResultId; + + result.noCallbackInvocationAttempted = !input.callbackInvocationAttempted; + result.noCallbackResultExecutionAttempted = !input.callbackResultExecutionAttempted; + result.noRuntimePlatformDynamicLibraryLoaded = !input.runtimePlatformLoadAttempted; + result.noRuntimePlatformDynamicLibraryUnloaded = !input.runtimePlatformUnloadAttempted; + result.noRuntimePlatformSymbolResolution = !input.runtimePlatformSymbolResolutionAttempted; + result.noSdxlCalls = !input.sdxlCallRequested; + result.noBridgeCalls = !input.bridgeCallRequested; + result.noServerConnectivityChecked = !input.serverConnectivityCheckRequested; + result.noWalletLifecycle = !input.walletLifecycleRequested; + result.noSyncStarted = !input.syncRequested; + result.noSyncStatusPolled = !input.syncStatusPollingRequested; + result.noWorkerQueueEnqueue = !input.workerQueueRequested; + result.noWalletStateMutation = !input.walletStateMutationRequested; + result.noWalletPersistence = !input.walletPersistenceRequested; + result.noSettingsPersistence = !input.settingsWriteRequested; + result.noSendImportExportExecution = !input.sendImportExportRequested; + result.noArtifactMutation = !input.artifactMutationRequested; + + if (!result.noCallbackInvocationAttempted || + !result.noCallbackResultExecutionAttempted || + !result.noRuntimePlatformDynamicLibraryLoaded || + !result.noRuntimePlatformDynamicLibraryUnloaded || + !result.noRuntimePlatformSymbolResolution) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal result must stop before callback result execution and platform loader APIs"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultBlockedSummary( + "callback_refusal_result_or_platform_api_attempted"); + return result; + } + + if (!result.noSdxlCalls || + !result.noBridgeCalls || + !result.noServerConnectivityChecked || + !result.noWalletLifecycle || + !result.noSyncStarted || + !result.noSyncStatusPolled || + !result.noWorkerQueueEnqueue || + !result.noWalletStateMutation || + !result.noWalletPersistence || + !result.noSettingsPersistence || + !result.noSendImportExportExecution || + !result.noArtifactMutation) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal result must not request wallet runtime behavior"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultBlockedSummary( + "runtime_action_requested"); + return result; + } + + if (result.platform.empty()) { + result.status = LiteBridgeRuntimeStatus::Unavailable; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal result requires a target platform"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultBlockedSummary( + "platform_missing"); + return result; + } + + if (isMacosPlatform(result.platform)) { + result.macosDeferred = true; + result.status = LiteBridgeRuntimeStatus::Unavailable; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultIssue( + result, + input.macosDeferredByOperator + ? "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal result is deferred by operator request" + : "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal result requires a reviewed builder before promotion"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultBlockedSummary( + "macos_deferred"); + return result; + } + + const bool linuxPlatform = isLinuxPlatform(result.platform); + const bool windowsPlatform = isWindowsPlatform(result.platform); + if (!linuxPlatform && !windowsPlatform) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal result supports only Linux and Windows in batch 22"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultBlockedSummary( + "unsupported_platform"); + return result; + } + + result.platformAccepted = true; + result.linuxPlatformAccepted = linuxPlatform; + result.windowsPlatformAccepted = windowsPlatform; + + const auto& guard = input.preInvocationGuard; + if (!input.preInvocationGuardAccepted || + !guard.ok || + !guard.loadOnlyExecutionDisabledCallbackPreInvocationGuardReady || + guard.status != LiteBridgeRuntimeStatus::Ready || + guard.platform != result.platform || + !guard.disabledCallbackBindingAccepted || + !guard.preInvocationGuardAccepted || + !guard.guardCallbackBindingMatchAccepted || + !guard.callbackInvocationRefused || + !guard.platformApiPreInvocationBlocked || + !guard.disabledGuardStateAccepted || + !guard.guardFailureMappingAccepted || + !guard.unloadExecutionBlocked || + !guard.symbolResolutionBlocked || + !guard.productionLoaderDisabled || + !guard.realAdapterExecutionDisabled || + !guard.loadOnlyExecutionDisabled || + !guard.separateExecutionBatchRequired || + !guard.noCallbackInvocationAttempted || + !guard.noRuntimePlatformDynamicLibraryLoaded || + !guard.noRuntimePlatformDynamicLibraryUnloaded || + !guard.noRuntimePlatformSymbolResolution) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal result requires a matching ready pre-invocation guard"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultBlockedSummary( + "pre_invocation_guard_required"); + return result; + } + result.preInvocationGuardAccepted = true; + + if (!input.refusalResultReviewed || + !input.refusalResultRecorded || + !input.refusalResultDisabled || + input.refusalResultId.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal result requires a reviewed disabled result record"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultBlockedSummary( + "callback_refusal_result_required"); + return result; + } + result.refusalResultAccepted = true; + + if (!input.refusalResultOwnerMatchesGuard || + !input.refusalResultBoundaryMatchesGuard || + !input.refusalResultCallbackMatchesGuard || + !input.refusalResultGuardMatchesPreInvocationGuard || + result.ownerName != guard.ownerName || + result.handoffId != guard.handoffId || + result.loadCallbackBoundaryName != guard.loadCallbackBoundaryName || + result.callbackBindingId != guard.callbackBindingId || + result.callbackName != guard.callbackName || + result.guardId != guard.guardId || + result.adapterName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal result requires result-to-guard match evidence"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultBlockedSummary( + "refusal_result_guard_match_required"); + return result; + } + result.refusalResultGuardMatchAccepted = true; + + if (!input.callbackInvocationStillDisabled || + !input.callbackInvocationRefused || + !input.callbackInvocationRefusalReviewed || + !input.refusalResultCarriesGuardEvidence || + !input.refusalResultStopsBeforeCallbackInvocation || + !input.refusalResultStopsBeforePlatformApi || + !input.refusalResultReturnsDisabledOutcome || + !input.refusalResultRequiresSeparateExecutionBatch) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal result must project only a disabled refusal before callback and platform APIs"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultBlockedSummary( + "callback_refusal_projection_required"); + return result; + } + result.callbackInvocationRefused = true; + result.callbackRefusalResultProjected = true; + result.platformApiPreInvocationBlocked = true; + + if (!input.refusalResultProducesNoDynamicHandle || + !input.refusalResultStoresNoDynamicHandle || + !input.refusalResultReleasesNoDynamicHandle || + !input.refusalResultResolvesNoSymbols || + !input.refusalResultStoresNoSymbolTable || + !input.refusalResultCreatesNoRuntime) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal result must not create runtime loader state"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultBlockedSummary( + "disabled_refusal_result_state_required"); + return result; + } + result.disabledRefusalResultStateAccepted = true; + + if (!input.refusalResultFailureMappingReviewed) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal result requires disabled result failure mapping review"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultBlockedSummary( + "refusal_result_failure_mapping_required"); + return result; + } + result.refusalResultFailureMappingAccepted = true; + + if (!input.unloadExecutionStillDisabled || !input.symbolResolutionStillDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal result must keep unload and symbol resolution disabled"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultBlockedSummary( + "non_load_execution_enabled"); + return result; + } + result.unloadExecutionBlocked = true; + result.symbolResolutionBlocked = true; + + if (!input.productionLoaderExecutionDisabled || + !input.realAdapterExecutionDisabled || + !input.loadOnlyExecutionDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal result must keep real loader execution disabled"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultBlockedSummary( + "production_loader_enabled"); + return result; + } + result.productionLoaderDisabled = true; + result.realAdapterExecutionDisabled = true; + result.loadOnlyExecutionDisabled = true; + + if (!input.separateExecutionBatchRequired) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal result requires a separate execution batch"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultBlockedSummary( + "separate_execution_batch_required"); + return result; + } + result.separateExecutionBatchRequired = true; + + result.loadOnlyExecutionDisabledCallbackRefusalResultReady = true; + result.status = LiteBridgeRuntimeStatus::Ready; + result.ok = true; + result.summary = std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_result=ready; platform=") + + result.platform + "; scope=load-only-disabled-callback-refusal-result; execution=disabled"; + return result; +} + +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultPropagationResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultPropagation( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultPropagationInput& input) +{ + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultPropagationResult result; + result.status = LiteBridgeRuntimeStatus::Configured; + result.platform = normalizedPlatform( + input.platform.empty() ? input.refusalResult.platform : input.platform); + result.adapterName = input.adapterName.empty() + ? input.refusalResult.adapterName + : input.adapterName; + result.ownerName = input.ownerName.empty() + ? input.refusalResult.ownerName + : input.ownerName; + result.handoffId = input.handoffId.empty() + ? input.refusalResult.handoffId + : input.handoffId; + result.loadCallbackBoundaryName = input.loadCallbackBoundaryName.empty() + ? input.refusalResult.loadCallbackBoundaryName + : input.loadCallbackBoundaryName; + result.callbackBindingId = input.callbackBindingId.empty() + ? input.refusalResult.callbackBindingId + : input.callbackBindingId; + result.callbackName = input.callbackName.empty() + ? input.refusalResult.callbackName + : input.callbackName; + result.guardId = input.guardId.empty() + ? input.refusalResult.guardId + : input.guardId; + result.refusalResultId = input.refusalResultId.empty() + ? input.refusalResult.refusalResultId + : input.refusalResultId; + result.propagationId = input.propagationId; + result.dispatchHandoffId = input.dispatchHandoffId; + result.statusRecordId = input.statusRecordId; + + result.noCallbackInvocationAttempted = !input.callbackInvocationAttempted; + result.noCallbackResultExecutionAttempted = !input.callbackResultExecutionAttempted; + result.noDispatchHandoffExecutionAttempted = !input.dispatchHandoffExecutionAttempted; + result.noDispatchStatusPublicationAttempted = !input.dispatchStatusPublicationAttempted; + result.noRuntimePlatformDynamicLibraryLoaded = !input.runtimePlatformLoadAttempted; + result.noRuntimePlatformDynamicLibraryUnloaded = !input.runtimePlatformUnloadAttempted; + result.noRuntimePlatformSymbolResolution = !input.runtimePlatformSymbolResolutionAttempted; + result.noSdxlCalls = !input.sdxlCallRequested; + result.noBridgeCalls = !input.bridgeCallRequested; + result.noServerConnectivityChecked = !input.serverConnectivityCheckRequested; + result.noWalletLifecycle = !input.walletLifecycleRequested; + result.noSyncStarted = !input.syncRequested; + result.noSyncStatusPolled = !input.syncStatusPollingRequested; + result.noWorkerQueueEnqueue = !input.workerQueueRequested; + result.noWalletStateMutation = !input.walletStateMutationRequested; + result.noWalletPersistence = !input.walletPersistenceRequested; + result.noSettingsPersistence = !input.settingsWriteRequested; + result.noSendImportExportExecution = !input.sendImportExportRequested; + result.noArtifactMutation = !input.artifactMutationRequested; + + if (!result.noCallbackInvocationAttempted || + !result.noCallbackResultExecutionAttempted || + !result.noDispatchHandoffExecutionAttempted || + !result.noDispatchStatusPublicationAttempted || + !result.noRuntimePlatformDynamicLibraryLoaded || + !result.noRuntimePlatformDynamicLibraryUnloaded || + !result.noRuntimePlatformSymbolResolution) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultPropagationIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal result propagation must stop before callback, dispatch, and platform loader APIs"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultPropagationBlockedSummary( + "callback_refusal_propagation_or_platform_api_attempted"); + return result; + } + + if (!result.noSdxlCalls || + !result.noBridgeCalls || + !result.noServerConnectivityChecked || + !result.noWalletLifecycle || + !result.noSyncStarted || + !result.noSyncStatusPolled || + !result.noWorkerQueueEnqueue || + !result.noWalletStateMutation || + !result.noWalletPersistence || + !result.noSettingsPersistence || + !result.noSendImportExportExecution || + !result.noArtifactMutation) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultPropagationIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal result propagation must not request wallet runtime behavior"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultPropagationBlockedSummary( + "runtime_action_requested"); + return result; + } + + if (result.platform.empty()) { + result.status = LiteBridgeRuntimeStatus::Unavailable; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultPropagationIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal result propagation requires a target platform"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultPropagationBlockedSummary( + "platform_missing"); + return result; + } + + if (isMacosPlatform(result.platform)) { + result.macosDeferred = true; + result.status = LiteBridgeRuntimeStatus::Unavailable; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultPropagationIssue( + result, + input.macosDeferredByOperator + ? "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal result propagation is deferred by operator request" + : "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal result propagation requires a reviewed builder before promotion"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultPropagationBlockedSummary( + "macos_deferred"); + return result; + } + + const bool linuxPlatform = isLinuxPlatform(result.platform); + const bool windowsPlatform = isWindowsPlatform(result.platform); + if (!linuxPlatform && !windowsPlatform) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultPropagationIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal result propagation supports only Linux and Windows in batch 23"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultPropagationBlockedSummary( + "unsupported_platform"); + return result; + } + + result.platformAccepted = true; + result.linuxPlatformAccepted = linuxPlatform; + result.windowsPlatformAccepted = windowsPlatform; + + const auto& refusal = input.refusalResult; + if (!input.refusalResultAccepted || + !refusal.ok || + !refusal.loadOnlyExecutionDisabledCallbackRefusalResultReady || + refusal.status != LiteBridgeRuntimeStatus::Ready || + refusal.platform != result.platform || + !refusal.preInvocationGuardAccepted || + !refusal.refusalResultAccepted || + !refusal.refusalResultGuardMatchAccepted || + !refusal.callbackInvocationRefused || + !refusal.callbackRefusalResultProjected || + !refusal.platformApiPreInvocationBlocked || + !refusal.disabledRefusalResultStateAccepted || + !refusal.refusalResultFailureMappingAccepted || + !refusal.unloadExecutionBlocked || + !refusal.symbolResolutionBlocked || + !refusal.productionLoaderDisabled || + !refusal.realAdapterExecutionDisabled || + !refusal.loadOnlyExecutionDisabled || + !refusal.separateExecutionBatchRequired || + !refusal.noCallbackInvocationAttempted || + !refusal.noCallbackResultExecutionAttempted || + !refusal.noRuntimePlatformDynamicLibraryLoaded || + !refusal.noRuntimePlatformDynamicLibraryUnloaded || + !refusal.noRuntimePlatformSymbolResolution) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultPropagationIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal result propagation requires a matching ready disabled refusal result"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultPropagationBlockedSummary( + "callback_refusal_result_required"); + return result; + } + result.refusalResultAccepted = true; + + if (!input.propagationRecordReviewed || + !input.propagationRecordRecorded || + !input.propagationRecordDisabled || + input.propagationId.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultPropagationIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal result propagation requires a reviewed disabled propagation record"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultPropagationBlockedSummary( + "refusal_result_propagation_required"); + return result; + } + result.propagationRecordAccepted = true; + + if (!input.propagationOwnerMatchesRefusalResult || + !input.propagationBoundaryMatchesRefusalResult || + !input.propagationCallbackMatchesRefusalResult || + !input.propagationGuardMatchesRefusalResult || + !input.propagationResultMatchesRefusalResult || + result.ownerName != refusal.ownerName || + result.handoffId != refusal.handoffId || + result.loadCallbackBoundaryName != refusal.loadCallbackBoundaryName || + result.callbackBindingId != refusal.callbackBindingId || + result.callbackName != refusal.callbackName || + result.guardId != refusal.guardId || + result.refusalResultId != refusal.refusalResultId || + result.adapterName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultPropagationIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal result propagation requires propagation-to-refusal-result match evidence"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultPropagationBlockedSummary( + "propagation_refusal_result_match_required"); + return result; + } + result.propagationRefusalResultMatchAccepted = true; + + if (!input.disabledDispatchHandoffReviewed || + !input.disabledDispatchHandoffRecorded || + !input.disabledStatusRecordReviewed || + !input.disabledStatusRecordRecorded || + !input.propagationCarriesRefusalResultEvidence || + !input.propagationReturnsDisabledDispatchStatus || + input.dispatchHandoffId.empty() || + input.statusRecordId.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultPropagationIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal result propagation requires disabled dispatch handoff and status records"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultPropagationBlockedSummary( + "disabled_dispatch_handoff_required"); + return result; + } + result.disabledDispatchHandoffAccepted = true; + result.disabledDispatchStatusAccepted = true; + + if (!input.callbackInvocationStillDisabled || + !input.callbackInvocationRefused || + !input.callbackInvocationRefusalReviewed || + !input.propagationStopsBeforeCallbackInvocation || + !input.propagationStopsBeforeCallbackResultExecution || + !input.propagationStopsBeforePlatformApi || + !input.propagationRequiresSeparateExecutionBatch) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultPropagationIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal result propagation must remain a disabled handoff before callback, result execution, and platform APIs"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultPropagationBlockedSummary( + "callback_refusal_propagation_required"); + return result; + } + result.callbackInvocationRefused = true; + result.callbackRefusalResultPropagated = true; + result.platformApiPreInvocationBlocked = true; + + if (!input.propagationProducesNoDynamicHandle || + !input.propagationStoresNoDynamicHandle || + !input.propagationReleasesNoDynamicHandle || + !input.propagationResolvesNoSymbols || + !input.propagationStoresNoSymbolTable || + !input.propagationCreatesNoRuntime) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultPropagationIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal result propagation must not create runtime loader state"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultPropagationBlockedSummary( + "disabled_propagation_state_required"); + return result; + } + result.disabledPropagationStateAccepted = true; + + if (!input.propagationFailureMappingReviewed) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultPropagationIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal result propagation requires disabled propagation failure mapping review"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultPropagationBlockedSummary( + "propagation_failure_mapping_required"); + return result; + } + result.propagationFailureMappingAccepted = true; + + if (!input.unloadExecutionStillDisabled || !input.symbolResolutionStillDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultPropagationIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal result propagation must keep unload and symbol resolution disabled"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultPropagationBlockedSummary( + "non_load_execution_enabled"); + return result; + } + result.unloadExecutionBlocked = true; + result.symbolResolutionBlocked = true; + + if (!input.productionLoaderExecutionDisabled || + !input.realAdapterExecutionDisabled || + !input.loadOnlyExecutionDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultPropagationIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal result propagation must keep real loader execution disabled"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultPropagationBlockedSummary( + "production_loader_enabled"); + return result; + } + result.productionLoaderDisabled = true; + result.realAdapterExecutionDisabled = true; + result.loadOnlyExecutionDisabled = true; + + if (!input.separateExecutionBatchRequired) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultPropagationIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal result propagation requires a separate execution batch"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultPropagationBlockedSummary( + "separate_execution_batch_required"); + return result; + } + result.separateExecutionBatchRequired = true; + + result.loadOnlyExecutionDisabledCallbackRefusalResultPropagationReady = true; + result.status = LiteBridgeRuntimeStatus::Ready; + result.ok = true; + result.summary = std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_result_propagation=ready; platform=") + + result.platform + "; scope=load-only-disabled-callback-refusal-result-propagation; execution=disabled"; + return result; +} + +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadiness( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessInput& input) +{ + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessResult result; + result.status = LiteBridgeRuntimeStatus::Configured; + result.platform = normalizedPlatform( + input.platform.empty() ? input.refusalPropagation.platform : input.platform); + result.adapterName = input.adapterName.empty() + ? input.refusalPropagation.adapterName + : input.adapterName; + result.ownerName = input.ownerName.empty() + ? input.refusalPropagation.ownerName + : input.ownerName; + result.handoffId = input.handoffId.empty() + ? input.refusalPropagation.handoffId + : input.handoffId; + result.loadCallbackBoundaryName = input.loadCallbackBoundaryName.empty() + ? input.refusalPropagation.loadCallbackBoundaryName + : input.loadCallbackBoundaryName; + result.callbackBindingId = input.callbackBindingId.empty() + ? input.refusalPropagation.callbackBindingId + : input.callbackBindingId; + result.callbackName = input.callbackName.empty() + ? input.refusalPropagation.callbackName + : input.callbackName; + result.guardId = input.guardId.empty() + ? input.refusalPropagation.guardId + : input.guardId; + result.refusalResultId = input.refusalResultId.empty() + ? input.refusalPropagation.refusalResultId + : input.refusalResultId; + result.propagationId = input.propagationId.empty() + ? input.refusalPropagation.propagationId + : input.propagationId; + result.dispatchHandoffId = input.dispatchHandoffId.empty() + ? input.refusalPropagation.dispatchHandoffId + : input.dispatchHandoffId; + result.statusRecordId = input.statusRecordId.empty() + ? input.refusalPropagation.statusRecordId + : input.statusRecordId; + result.consumerReadinessId = input.consumerReadinessId; + result.consumerName = input.consumerName; + + result.noCallbackInvocationAttempted = !input.callbackInvocationAttempted; + result.noCallbackResultExecutionAttempted = !input.callbackResultExecutionAttempted; + result.noDispatchHandoffExecutionAttempted = !input.dispatchHandoffExecutionAttempted; + result.noDispatchStatusPublicationAttempted = !input.dispatchStatusPublicationAttempted; + result.noDispatchConsumerConsumptionAttempted = !input.dispatchConsumerConsumptionAttempted; + result.noConsumerReadinessStatusPublicationAttempted = !input.consumerReadinessStatusPublicationAttempted; + result.noRuntimePlatformDynamicLibraryLoaded = !input.runtimePlatformLoadAttempted; + result.noRuntimePlatformDynamicLibraryUnloaded = !input.runtimePlatformUnloadAttempted; + result.noRuntimePlatformSymbolResolution = !input.runtimePlatformSymbolResolutionAttempted; + result.noSdxlCalls = !input.sdxlCallRequested; + result.noBridgeCalls = !input.bridgeCallRequested; + result.noServerConnectivityChecked = !input.serverConnectivityCheckRequested; + result.noWalletLifecycle = !input.walletLifecycleRequested; + result.noSyncStarted = !input.syncRequested; + result.noSyncStatusPolled = !input.syncStatusPollingRequested; + result.noWorkerQueueEnqueue = !input.workerQueueRequested; + result.noWalletStateMutation = !input.walletStateMutationRequested; + result.noWalletPersistence = !input.walletPersistenceRequested; + result.noSettingsPersistence = !input.settingsWriteRequested; + result.noSendImportExportExecution = !input.sendImportExportRequested; + result.noArtifactMutation = !input.artifactMutationRequested; + + if (!result.noCallbackInvocationAttempted || + !result.noCallbackResultExecutionAttempted || + !result.noDispatchHandoffExecutionAttempted || + !result.noDispatchStatusPublicationAttempted || + !result.noDispatchConsumerConsumptionAttempted || + !result.noConsumerReadinessStatusPublicationAttempted || + !result.noRuntimePlatformDynamicLibraryLoaded || + !result.noRuntimePlatformDynamicLibraryUnloaded || + !result.noRuntimePlatformSymbolResolution) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer readiness must stop before callback, dispatch consumer, status, and platform loader APIs"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessBlockedSummary( + "callback_refusal_consumer_or_platform_api_attempted"); + return result; + } + + if (!result.noSdxlCalls || + !result.noBridgeCalls || + !result.noServerConnectivityChecked || + !result.noWalletLifecycle || + !result.noSyncStarted || + !result.noSyncStatusPolled || + !result.noWorkerQueueEnqueue || + !result.noWalletStateMutation || + !result.noWalletPersistence || + !result.noSettingsPersistence || + !result.noSendImportExportExecution || + !result.noArtifactMutation) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer readiness must not request wallet runtime behavior"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessBlockedSummary( + "runtime_action_requested"); + return result; + } + + if (result.platform.empty()) { + result.status = LiteBridgeRuntimeStatus::Unavailable; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer readiness requires a target platform"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessBlockedSummary( + "platform_missing"); + return result; + } + + if (isMacosPlatform(result.platform)) { + result.macosDeferred = true; + result.status = LiteBridgeRuntimeStatus::Unavailable; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessIssue( + result, + input.macosDeferredByOperator + ? "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer readiness is deferred by operator request" + : "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer readiness requires a reviewed builder before promotion"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessBlockedSummary( + "macos_deferred"); + return result; + } + + const bool linuxPlatform = isLinuxPlatform(result.platform); + const bool windowsPlatform = isWindowsPlatform(result.platform); + if (!linuxPlatform && !windowsPlatform) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer readiness supports only Linux and Windows in batch 24"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessBlockedSummary( + "unsupported_platform"); + return result; + } + + result.platformAccepted = true; + result.linuxPlatformAccepted = linuxPlatform; + result.windowsPlatformAccepted = windowsPlatform; + + const auto& propagation = input.refusalPropagation; + if (!input.refusalPropagationAccepted || + !propagation.ok || + !propagation.loadOnlyExecutionDisabledCallbackRefusalResultPropagationReady || + propagation.status != LiteBridgeRuntimeStatus::Ready || + propagation.platform != result.platform || + !propagation.refusalResultAccepted || + !propagation.propagationRecordAccepted || + !propagation.propagationRefusalResultMatchAccepted || + !propagation.disabledDispatchHandoffAccepted || + !propagation.disabledDispatchStatusAccepted || + !propagation.callbackInvocationRefused || + !propagation.callbackRefusalResultPropagated || + !propagation.platformApiPreInvocationBlocked || + !propagation.disabledPropagationStateAccepted || + !propagation.propagationFailureMappingAccepted || + !propagation.unloadExecutionBlocked || + !propagation.symbolResolutionBlocked || + !propagation.productionLoaderDisabled || + !propagation.realAdapterExecutionDisabled || + !propagation.loadOnlyExecutionDisabled || + !propagation.separateExecutionBatchRequired || + !propagation.noCallbackInvocationAttempted || + !propagation.noCallbackResultExecutionAttempted || + !propagation.noDispatchHandoffExecutionAttempted || + !propagation.noDispatchStatusPublicationAttempted || + !propagation.noRuntimePlatformDynamicLibraryLoaded || + !propagation.noRuntimePlatformDynamicLibraryUnloaded || + !propagation.noRuntimePlatformSymbolResolution) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer readiness requires matching ready disabled propagation evidence"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessBlockedSummary( + "callback_refusal_propagation_required"); + return result; + } + result.refusalPropagationAccepted = true; + + if (!input.consumerReadinessReviewed || + !input.consumerReadinessRecorded || + !input.consumerReadinessDisabled || + input.consumerReadinessId.empty() || + input.consumerName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer readiness requires a reviewed disabled consumer readiness record"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessBlockedSummary( + "consumer_readiness_required"); + return result; + } + result.consumerReadinessRecordAccepted = true; + + if (!input.consumerOwnerMatchesPropagation || + !input.consumerBoundaryMatchesPropagation || + !input.consumerCallbackMatchesPropagation || + !input.consumerGuardMatchesPropagation || + !input.consumerRefusalResultMatchesPropagation || + !input.consumerPropagationMatchesPropagation || + !input.consumerDispatchHandoffMatchesPropagation || + !input.consumerStatusRecordMatchesPropagation || + result.ownerName != propagation.ownerName || + result.handoffId != propagation.handoffId || + result.loadCallbackBoundaryName != propagation.loadCallbackBoundaryName || + result.callbackBindingId != propagation.callbackBindingId || + result.callbackName != propagation.callbackName || + result.guardId != propagation.guardId || + result.refusalResultId != propagation.refusalResultId || + result.propagationId != propagation.propagationId || + result.dispatchHandoffId != propagation.dispatchHandoffId || + result.statusRecordId != propagation.statusRecordId || + result.adapterName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer readiness requires consumer-to-propagation match evidence"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessBlockedSummary( + "consumer_propagation_match_required"); + return result; + } + result.consumerPropagationMatchAccepted = true; + + if (!input.disabledConsumerRegistered || + !input.disabledConsumerAcceptsPropagationEvidence || + !input.consumerReturnsDisabledReadiness || + !input.consumerBlocksDispatchConsumption || + !input.consumerBlocksStatusPublication) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer readiness requires disabled consumer evidence"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessBlockedSummary( + "disabled_consumer_readiness_required"); + return result; + } + result.disabledConsumerReadinessAccepted = true; + + if (!input.callbackInvocationStillDisabled || + !input.callbackInvocationRefused || + !input.callbackInvocationRefusalReviewed || + !input.consumerStopsBeforeCallbackInvocation || + !input.consumerStopsBeforeCallbackResultExecution || + !input.consumerStopsBeforeDispatchExecution || + !input.consumerStopsBeforePlatformApi || + !input.consumerRequiresSeparateExecutionBatch) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer readiness must remain disabled before callback, dispatch, and platform APIs"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessBlockedSummary( + "callback_refusal_consumer_readiness_required"); + return result; + } + result.callbackInvocationRefused = true; + result.callbackRefusalPropagationConsumerReady = true; + result.platformApiPreInvocationBlocked = true; + + if (!input.consumerProducesNoDynamicHandle || + !input.consumerStoresNoDynamicHandle || + !input.consumerReleasesNoDynamicHandle || + !input.consumerResolvesNoSymbols || + !input.consumerStoresNoSymbolTable || + !input.consumerCreatesNoRuntime) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer readiness must not create runtime loader state"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessBlockedSummary( + "disabled_consumer_state_required"); + return result; + } + result.disabledConsumerStateAccepted = true; + + if (!input.consumerReadinessFailureMappingReviewed) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer readiness requires disabled consumer failure mapping review"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessBlockedSummary( + "consumer_readiness_failure_mapping_required"); + return result; + } + result.consumerReadinessFailureMappingAccepted = true; + + if (!input.unloadExecutionStillDisabled || !input.symbolResolutionStillDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer readiness must keep unload and symbol resolution disabled"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessBlockedSummary( + "non_load_execution_enabled"); + return result; + } + result.unloadExecutionBlocked = true; + result.symbolResolutionBlocked = true; + + if (!input.productionLoaderExecutionDisabled || + !input.realAdapterExecutionDisabled || + !input.loadOnlyExecutionDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer readiness must keep real loader execution disabled"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessBlockedSummary( + "production_loader_enabled"); + return result; + } + result.productionLoaderDisabled = true; + result.realAdapterExecutionDisabled = true; + result.loadOnlyExecutionDisabled = true; + + if (!input.separateExecutionBatchRequired) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer readiness requires a separate execution batch"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessBlockedSummary( + "separate_execution_batch_required"); + return result; + } + result.separateExecutionBatchRequired = true; + + result.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessReady = true; + result.status = LiteBridgeRuntimeStatus::Ready; + result.ok = true; + result.summary = std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness=ready; platform=") + + result.platform + "; scope=load-only-disabled-callback-refusal-propagation-consumer-readiness; execution=disabled"; + return result; +} + +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuard( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardInput& input) +{ + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResult result; + result.status = LiteBridgeRuntimeStatus::Configured; + result.platform = normalizedPlatform( + input.platform.empty() ? input.consumerReadiness.platform : input.platform); + result.adapterName = input.adapterName.empty() + ? input.consumerReadiness.adapterName + : input.adapterName; + result.ownerName = input.ownerName.empty() + ? input.consumerReadiness.ownerName + : input.ownerName; + result.handoffId = input.handoffId.empty() + ? input.consumerReadiness.handoffId + : input.handoffId; + result.loadCallbackBoundaryName = input.loadCallbackBoundaryName.empty() + ? input.consumerReadiness.loadCallbackBoundaryName + : input.loadCallbackBoundaryName; + result.callbackBindingId = input.callbackBindingId.empty() + ? input.consumerReadiness.callbackBindingId + : input.callbackBindingId; + result.callbackName = input.callbackName.empty() + ? input.consumerReadiness.callbackName + : input.callbackName; + result.guardId = input.guardId.empty() + ? input.consumerReadiness.guardId + : input.guardId; + result.refusalResultId = input.refusalResultId.empty() + ? input.consumerReadiness.refusalResultId + : input.refusalResultId; + result.propagationId = input.propagationId.empty() + ? input.consumerReadiness.propagationId + : input.propagationId; + result.dispatchHandoffId = input.dispatchHandoffId.empty() + ? input.consumerReadiness.dispatchHandoffId + : input.dispatchHandoffId; + result.statusRecordId = input.statusRecordId.empty() + ? input.consumerReadiness.statusRecordId + : input.statusRecordId; + result.consumerReadinessId = input.consumerReadinessId.empty() + ? input.consumerReadiness.consumerReadinessId + : input.consumerReadinessId; + result.consumerName = input.consumerName.empty() + ? input.consumerReadiness.consumerName + : input.consumerName; + result.dispatchConsumptionGuardId = input.dispatchConsumptionGuardId; + result.dispatchConsumerName = input.dispatchConsumerName; + + result.noCallbackInvocationAttempted = !input.callbackInvocationAttempted; + result.noCallbackResultExecutionAttempted = !input.callbackResultExecutionAttempted; + result.noDispatchHandoffExecutionAttempted = !input.dispatchHandoffExecutionAttempted; + result.noDispatchStatusPublicationAttempted = !input.dispatchStatusPublicationAttempted; + result.noDispatchConsumerConsumptionAttempted = !input.dispatchConsumerConsumptionAttempted; + result.noDispatchConsumptionGuardStatusPublicationAttempted = !input.dispatchConsumptionGuardStatusPublicationAttempted; + result.noRuntimePlatformDynamicLibraryLoaded = !input.runtimePlatformLoadAttempted; + result.noRuntimePlatformDynamicLibraryUnloaded = !input.runtimePlatformUnloadAttempted; + result.noRuntimePlatformSymbolResolution = !input.runtimePlatformSymbolResolutionAttempted; + result.noSdxlCalls = !input.sdxlCallRequested; + result.noBridgeCalls = !input.bridgeCallRequested; + result.noServerConnectivityChecked = !input.serverConnectivityCheckRequested; + result.noWalletLifecycle = !input.walletLifecycleRequested; + result.noSyncStarted = !input.syncRequested; + result.noSyncStatusPolled = !input.syncStatusPollingRequested; + result.noWorkerQueueEnqueue = !input.workerQueueRequested; + result.noWalletStateMutation = !input.walletStateMutationRequested; + result.noWalletPersistence = !input.walletPersistenceRequested; + result.noSettingsPersistence = !input.settingsWriteRequested; + result.noSendImportExportExecution = !input.sendImportExportRequested; + result.noArtifactMutation = !input.artifactMutationRequested; + + if (!result.noCallbackInvocationAttempted || + !result.noCallbackResultExecutionAttempted || + !result.noDispatchHandoffExecutionAttempted || + !result.noDispatchStatusPublicationAttempted || + !result.noDispatchConsumerConsumptionAttempted || + !result.noDispatchConsumptionGuardStatusPublicationAttempted || + !result.noRuntimePlatformDynamicLibraryLoaded || + !result.noRuntimePlatformDynamicLibraryUnloaded || + !result.noRuntimePlatformSymbolResolution) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer readiness dispatch-consumption guard must stop before callback, dispatch consumption, status, and platform loader APIs"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardBlockedSummary( + "dispatch_consumption_guard_or_platform_api_attempted"); + return result; + } + + if (!result.noSdxlCalls || + !result.noBridgeCalls || + !result.noServerConnectivityChecked || + !result.noWalletLifecycle || + !result.noSyncStarted || + !result.noSyncStatusPolled || + !result.noWorkerQueueEnqueue || + !result.noWalletStateMutation || + !result.noWalletPersistence || + !result.noSettingsPersistence || + !result.noSendImportExportExecution || + !result.noArtifactMutation) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer readiness dispatch-consumption guard must not request wallet runtime behavior"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardBlockedSummary( + "runtime_action_requested"); + return result; + } + + if (result.platform.empty()) { + result.status = LiteBridgeRuntimeStatus::Unavailable; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer readiness dispatch-consumption guard requires a target platform"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardBlockedSummary( + "platform_missing"); + return result; + } + + if (isMacosPlatform(result.platform)) { + result.macosDeferred = true; + result.status = LiteBridgeRuntimeStatus::Unavailable; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardIssue( + result, + input.macosDeferredByOperator + ? "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer readiness dispatch-consumption guard is deferred by operator request" + : "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer readiness dispatch-consumption guard requires a reviewed builder before promotion"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardBlockedSummary( + "macos_deferred"); + return result; + } + + const bool linuxPlatform = isLinuxPlatform(result.platform); + const bool windowsPlatform = isWindowsPlatform(result.platform); + if (!linuxPlatform && !windowsPlatform) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer readiness dispatch-consumption guard supports only Linux and Windows in batch 25"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardBlockedSummary( + "unsupported_platform"); + return result; + } + + result.platformAccepted = true; + result.linuxPlatformAccepted = linuxPlatform; + result.windowsPlatformAccepted = windowsPlatform; + + const auto& readiness = input.consumerReadiness; + if (!input.consumerReadinessAccepted || + !readiness.ok || + !readiness.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessReady || + readiness.status != LiteBridgeRuntimeStatus::Ready || + readiness.platform != result.platform || + !readiness.refusalPropagationAccepted || + !readiness.consumerReadinessRecordAccepted || + !readiness.consumerPropagationMatchAccepted || + !readiness.disabledConsumerReadinessAccepted || + !readiness.callbackInvocationRefused || + !readiness.callbackRefusalPropagationConsumerReady || + !readiness.platformApiPreInvocationBlocked || + !readiness.disabledConsumerStateAccepted || + !readiness.consumerReadinessFailureMappingAccepted || + !readiness.unloadExecutionBlocked || + !readiness.symbolResolutionBlocked || + !readiness.productionLoaderDisabled || + !readiness.realAdapterExecutionDisabled || + !readiness.loadOnlyExecutionDisabled || + !readiness.separateExecutionBatchRequired || + !readiness.noCallbackInvocationAttempted || + !readiness.noCallbackResultExecutionAttempted || + !readiness.noDispatchHandoffExecutionAttempted || + !readiness.noDispatchStatusPublicationAttempted || + !readiness.noDispatchConsumerConsumptionAttempted || + !readiness.noConsumerReadinessStatusPublicationAttempted || + !readiness.noRuntimePlatformDynamicLibraryLoaded || + !readiness.noRuntimePlatformDynamicLibraryUnloaded || + !readiness.noRuntimePlatformSymbolResolution) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer readiness dispatch-consumption guard requires matching ready disabled consumer-readiness evidence"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardBlockedSummary( + "consumer_readiness_required"); + return result; + } + result.consumerReadinessAccepted = true; + + if (!input.dispatchConsumptionGuardReviewed || + !input.dispatchConsumptionGuardRecorded || + !input.dispatchConsumptionGuardDisabled || + input.dispatchConsumptionGuardId.empty() || + input.dispatchConsumerName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer readiness dispatch-consumption guard requires a reviewed disabled guard record"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardBlockedSummary( + "dispatch_consumption_guard_required"); + return result; + } + result.dispatchConsumptionGuardRecordAccepted = true; + + if (!input.guardOwnerMatchesConsumerReadiness || + !input.guardBoundaryMatchesConsumerReadiness || + !input.guardCallbackMatchesConsumerReadiness || + !input.guardPreInvocationGuardMatchesConsumerReadiness || + !input.guardRefusalResultMatchesConsumerReadiness || + !input.guardPropagationMatchesConsumerReadiness || + !input.guardDispatchHandoffMatchesConsumerReadiness || + !input.guardStatusRecordMatchesConsumerReadiness || + !input.guardConsumerReadinessMatchesConsumerReadiness || + !input.guardConsumerNameMatchesConsumerReadiness || + result.ownerName != readiness.ownerName || + result.handoffId != readiness.handoffId || + result.loadCallbackBoundaryName != readiness.loadCallbackBoundaryName || + result.callbackBindingId != readiness.callbackBindingId || + result.callbackName != readiness.callbackName || + result.guardId != readiness.guardId || + result.refusalResultId != readiness.refusalResultId || + result.propagationId != readiness.propagationId || + result.dispatchHandoffId != readiness.dispatchHandoffId || + result.statusRecordId != readiness.statusRecordId || + result.consumerReadinessId != readiness.consumerReadinessId || + result.consumerName != readiness.consumerName || + result.adapterName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer readiness dispatch-consumption guard requires guard-to-consumer-readiness match evidence"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardBlockedSummary( + "dispatch_guard_consumer_readiness_match_required"); + return result; + } + result.guardConsumerReadinessMatchAccepted = true; + + if (!input.disabledDispatchConsumptionGuardRegistered || + !input.dispatchConsumptionGuardAcceptsConsumerReadinessEvidence || + !input.dispatchConsumptionGuardReturnsDisabledConsumption || + !input.dispatchConsumptionGuardBlocksDispatchConsumption || + !input.dispatchConsumptionGuardBlocksStatusPublication) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer readiness dispatch-consumption guard requires disabled dispatch-consumption guard evidence"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardBlockedSummary( + "disabled_dispatch_consumption_guard_required"); + return result; + } + result.disabledDispatchConsumptionGuardAccepted = true; + + if (!input.callbackInvocationStillDisabled || + !input.callbackInvocationRefused || + !input.callbackInvocationRefusalReviewed || + !input.guardStopsBeforeCallbackInvocation || + !input.guardStopsBeforeCallbackResultExecution || + !input.guardStopsBeforeDispatchConsumption || + !input.guardStopsBeforeDispatchStatusPublication || + !input.guardStopsBeforePlatformApi || + !input.guardRequiresSeparateExecutionBatch) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer readiness dispatch-consumption guard must remain disabled before callback, dispatch consumption, status publication, and platform APIs"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardBlockedSummary( + "dispatch_consumption_guard_disabled_state_required"); + return result; + } + result.callbackInvocationRefused = true; + result.dispatchConsumptionGuarded = true; + result.dispatchStatusPublicationBlocked = true; + result.platformApiPreInvocationBlocked = true; + + if (!input.guardProducesNoDynamicHandle || + !input.guardStoresNoDynamicHandle || + !input.guardReleasesNoDynamicHandle || + !input.guardResolvesNoSymbols || + !input.guardStoresNoSymbolTable || + !input.guardCreatesNoRuntime) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer readiness dispatch-consumption guard must not create runtime loader state"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardBlockedSummary( + "dispatch_consumption_guard_runtime_state_required"); + return result; + } + result.disabledDispatchConsumptionGuardStateAccepted = true; + + if (!input.dispatchConsumptionFailureMappingReviewed) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer readiness dispatch-consumption guard requires disabled dispatch-consumption failure mapping review"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardBlockedSummary( + "dispatch_consumption_failure_mapping_required"); + return result; + } + result.dispatchConsumptionFailureMappingAccepted = true; + + if (!input.unloadExecutionStillDisabled || !input.symbolResolutionStillDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer readiness dispatch-consumption guard must keep unload and symbol resolution disabled"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardBlockedSummary( + "non_load_execution_enabled"); + return result; + } + result.unloadExecutionBlocked = true; + result.symbolResolutionBlocked = true; + + if (!input.productionLoaderExecutionDisabled || + !input.realAdapterExecutionDisabled || + !input.loadOnlyExecutionDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer readiness dispatch-consumption guard must keep real loader execution disabled"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardBlockedSummary( + "production_loader_enabled"); + return result; + } + result.productionLoaderDisabled = true; + result.realAdapterExecutionDisabled = true; + result.loadOnlyExecutionDisabled = true; + + if (!input.separateExecutionBatchRequired) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer readiness dispatch-consumption guard requires a separate execution batch"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardBlockedSummary( + "separate_execution_batch_required"); + return result; + } + result.separateExecutionBatchRequired = true; + + result.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardReady = true; + result.status = LiteBridgeRuntimeStatus::Ready; + result.ok = true; + result.summary = std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard=ready; platform=") + + result.platform + "; scope=load-only-disabled-callback-refusal-propagation-consumer-readiness-dispatch-consumption-guard; execution=disabled"; + return result; +} + +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoff( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffInput& input) +{ + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffResult result; + result.status = LiteBridgeRuntimeStatus::Configured; + result.platform = normalizedPlatform( + input.platform.empty() ? input.dispatchConsumptionGuard.platform : input.platform); + result.adapterName = input.adapterName.empty() + ? input.dispatchConsumptionGuard.adapterName + : input.adapterName; + result.ownerName = input.ownerName.empty() + ? input.dispatchConsumptionGuard.ownerName + : input.ownerName; + result.handoffId = input.handoffId.empty() + ? input.dispatchConsumptionGuard.handoffId + : input.handoffId; + result.loadCallbackBoundaryName = input.loadCallbackBoundaryName.empty() + ? input.dispatchConsumptionGuard.loadCallbackBoundaryName + : input.loadCallbackBoundaryName; + result.callbackBindingId = input.callbackBindingId.empty() + ? input.dispatchConsumptionGuard.callbackBindingId + : input.callbackBindingId; + result.callbackName = input.callbackName.empty() + ? input.dispatchConsumptionGuard.callbackName + : input.callbackName; + result.guardId = input.guardId.empty() + ? input.dispatchConsumptionGuard.guardId + : input.guardId; + result.refusalResultId = input.refusalResultId.empty() + ? input.dispatchConsumptionGuard.refusalResultId + : input.refusalResultId; + result.propagationId = input.propagationId.empty() + ? input.dispatchConsumptionGuard.propagationId + : input.propagationId; + result.dispatchHandoffId = input.dispatchHandoffId.empty() + ? input.dispatchConsumptionGuard.dispatchHandoffId + : input.dispatchHandoffId; + result.statusRecordId = input.statusRecordId.empty() + ? input.dispatchConsumptionGuard.statusRecordId + : input.statusRecordId; + result.consumerReadinessId = input.consumerReadinessId.empty() + ? input.dispatchConsumptionGuard.consumerReadinessId + : input.consumerReadinessId; + result.consumerName = input.consumerName.empty() + ? input.dispatchConsumptionGuard.consumerName + : input.consumerName; + result.dispatchConsumptionGuardId = input.dispatchConsumptionGuardId.empty() + ? input.dispatchConsumptionGuard.dispatchConsumptionGuardId + : input.dispatchConsumptionGuardId; + result.dispatchConsumerName = input.dispatchConsumerName.empty() + ? input.dispatchConsumptionGuard.dispatchConsumerName + : input.dispatchConsumerName; + result.resultHandoffId = input.resultHandoffId; + result.resultConsumerName = input.resultConsumerName; + + result.noCallbackInvocationAttempted = !input.callbackInvocationAttempted; + result.noCallbackResultExecutionAttempted = !input.callbackResultExecutionAttempted; + result.noDispatchHandoffExecutionAttempted = !input.dispatchHandoffExecutionAttempted; + result.noDispatchStatusPublicationAttempted = !input.dispatchStatusPublicationAttempted; + result.noDispatchConsumerConsumptionAttempted = !input.dispatchConsumerConsumptionAttempted; + result.noDispatchResultExecutionAttempted = !input.dispatchResultExecutionAttempted; + result.noResultHandoffStatusPublicationAttempted = !input.resultHandoffStatusPublicationAttempted; + result.noRuntimePlatformDynamicLibraryLoaded = !input.runtimePlatformLoadAttempted; + result.noRuntimePlatformDynamicLibraryUnloaded = !input.runtimePlatformUnloadAttempted; + result.noRuntimePlatformSymbolResolution = !input.runtimePlatformSymbolResolutionAttempted; + result.noSdxlCalls = !input.sdxlCallRequested; + result.noBridgeCalls = !input.bridgeCallRequested; + result.noServerConnectivityChecked = !input.serverConnectivityCheckRequested; + result.noWalletLifecycle = !input.walletLifecycleRequested; + result.noSyncStarted = !input.syncRequested; + result.noSyncStatusPolled = !input.syncStatusPollingRequested; + result.noWorkerQueueEnqueue = !input.workerQueueRequested; + result.noWalletStateMutation = !input.walletStateMutationRequested; + result.noWalletPersistence = !input.walletPersistenceRequested; + result.noSettingsPersistence = !input.settingsWriteRequested; + result.noSendImportExportExecution = !input.sendImportExportRequested; + result.noArtifactMutation = !input.artifactMutationRequested; + + if (!result.noCallbackInvocationAttempted || + !result.noCallbackResultExecutionAttempted || + !result.noDispatchHandoffExecutionAttempted || + !result.noDispatchStatusPublicationAttempted || + !result.noDispatchConsumerConsumptionAttempted || + !result.noDispatchResultExecutionAttempted || + !result.noResultHandoffStatusPublicationAttempted || + !result.noRuntimePlatformDynamicLibraryLoaded || + !result.noRuntimePlatformDynamicLibraryUnloaded || + !result.noRuntimePlatformSymbolResolution) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff must stop before callback, dispatch result execution, status, and platform loader APIs"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffBlockedSummary( + "result_handoff_or_platform_api_attempted"); + return result; + } + + if (!result.noSdxlCalls || + !result.noBridgeCalls || + !result.noServerConnectivityChecked || + !result.noWalletLifecycle || + !result.noSyncStarted || + !result.noSyncStatusPolled || + !result.noWorkerQueueEnqueue || + !result.noWalletStateMutation || + !result.noWalletPersistence || + !result.noSettingsPersistence || + !result.noSendImportExportExecution || + !result.noArtifactMutation) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff must not request wallet runtime behavior"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffBlockedSummary( + "runtime_action_requested"); + return result; + } + + if (result.platform.empty()) { + result.status = LiteBridgeRuntimeStatus::Unavailable; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff requires a target platform"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffBlockedSummary( + "platform_missing"); + return result; + } + + if (isMacosPlatform(result.platform)) { + result.macosDeferred = true; + result.status = LiteBridgeRuntimeStatus::Unavailable; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffIssue( + result, + input.macosDeferredByOperator + ? "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff is deferred by operator request" + : "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff requires a reviewed builder before promotion"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffBlockedSummary( + "macos_deferred"); + return result; + } + + const bool linuxPlatform = isLinuxPlatform(result.platform); + const bool windowsPlatform = isWindowsPlatform(result.platform); + if (!linuxPlatform && !windowsPlatform) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff supports only Linux and Windows in batch 26"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffBlockedSummary( + "unsupported_platform"); + return result; + } + + result.platformAccepted = true; + result.linuxPlatformAccepted = linuxPlatform; + result.windowsPlatformAccepted = windowsPlatform; + + const auto& guard = input.dispatchConsumptionGuard; + if (!input.dispatchConsumptionGuardAccepted || + !guard.ok || + !guard.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardReady || + guard.status != LiteBridgeRuntimeStatus::Ready || + guard.platform != result.platform || + !guard.consumerReadinessAccepted || + !guard.dispatchConsumptionGuardRecordAccepted || + !guard.guardConsumerReadinessMatchAccepted || + !guard.disabledDispatchConsumptionGuardAccepted || + !guard.callbackInvocationRefused || + !guard.dispatchConsumptionGuarded || + !guard.dispatchStatusPublicationBlocked || + !guard.platformApiPreInvocationBlocked || + !guard.disabledDispatchConsumptionGuardStateAccepted || + !guard.dispatchConsumptionFailureMappingAccepted || + !guard.unloadExecutionBlocked || + !guard.symbolResolutionBlocked || + !guard.productionLoaderDisabled || + !guard.realAdapterExecutionDisabled || + !guard.loadOnlyExecutionDisabled || + !guard.separateExecutionBatchRequired || + !guard.noCallbackInvocationAttempted || + !guard.noCallbackResultExecutionAttempted || + !guard.noDispatchHandoffExecutionAttempted || + !guard.noDispatchStatusPublicationAttempted || + !guard.noDispatchConsumerConsumptionAttempted || + !guard.noDispatchConsumptionGuardStatusPublicationAttempted || + !guard.noRuntimePlatformDynamicLibraryLoaded || + !guard.noRuntimePlatformDynamicLibraryUnloaded || + !guard.noRuntimePlatformSymbolResolution) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff requires matching ready disabled dispatch-consumption guard evidence"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffBlockedSummary( + "dispatch_consumption_guard_required"); + return result; + } + result.dispatchConsumptionGuardAccepted = true; + + if (!input.resultHandoffReviewed || + !input.resultHandoffRecorded || + !input.resultHandoffDisabled || + input.resultHandoffId.empty() || + input.resultConsumerName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff requires a reviewed disabled result-handoff record"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffBlockedSummary( + "result_handoff_required"); + return result; + } + result.resultHandoffRecordAccepted = true; + + if (!input.handoffOwnerMatchesDispatchGuard || + !input.handoffBoundaryMatchesDispatchGuard || + !input.handoffCallbackMatchesDispatchGuard || + !input.handoffPreInvocationGuardMatchesDispatchGuard || + !input.handoffRefusalResultMatchesDispatchGuard || + !input.handoffPropagationMatchesDispatchGuard || + !input.handoffDispatchHandoffMatchesDispatchGuard || + !input.handoffStatusRecordMatchesDispatchGuard || + !input.handoffConsumerReadinessMatchesDispatchGuard || + !input.handoffConsumerNameMatchesDispatchGuard || + !input.handoffDispatchConsumptionGuardMatchesDispatchGuard || + !input.handoffDispatchConsumerNameMatchesDispatchGuard || + result.ownerName != guard.ownerName || + result.handoffId != guard.handoffId || + result.loadCallbackBoundaryName != guard.loadCallbackBoundaryName || + result.callbackBindingId != guard.callbackBindingId || + result.callbackName != guard.callbackName || + result.guardId != guard.guardId || + result.refusalResultId != guard.refusalResultId || + result.propagationId != guard.propagationId || + result.dispatchHandoffId != guard.dispatchHandoffId || + result.statusRecordId != guard.statusRecordId || + result.consumerReadinessId != guard.consumerReadinessId || + result.consumerName != guard.consumerName || + result.dispatchConsumptionGuardId != guard.dispatchConsumptionGuardId || + result.dispatchConsumerName != guard.dispatchConsumerName || + result.adapterName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff requires result-handoff-to-guard match evidence"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffBlockedSummary( + "result_handoff_guard_match_required"); + return result; + } + result.handoffDispatchGuardMatchAccepted = true; + + if (!input.disabledResultHandoffRegistered || + !input.resultHandoffAcceptsDispatchConsumptionGuardEvidence || + !input.resultHandoffReturnsDisabledResult || + !input.resultHandoffBlocksDispatchConsumption || + !input.resultHandoffBlocksDispatchResultExecution || + !input.resultHandoffBlocksStatusPublication) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff requires disabled result-handoff evidence"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffBlockedSummary( + "disabled_result_handoff_required"); + return result; + } + result.disabledResultHandoffAccepted = true; + + if (!input.callbackInvocationStillDisabled || + !input.callbackInvocationRefused || + !input.callbackInvocationRefusalReviewed || + !input.handoffStopsBeforeCallbackInvocation || + !input.handoffStopsBeforeCallbackResultExecution || + !input.handoffStopsBeforeDispatchConsumption || + !input.handoffStopsBeforeDispatchResultExecution || + !input.handoffStopsBeforeDispatchStatusPublication || + !input.handoffStopsBeforePlatformApi || + !input.handoffRequiresSeparateExecutionBatch) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff must remain disabled before callback, dispatch result execution, status publication, and platform APIs"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffBlockedSummary( + "result_handoff_disabled_state_required"); + return result; + } + result.callbackInvocationRefused = true; + result.dispatchConsumptionStillGuarded = true; + result.dispatchResultExecutionBlocked = true; + result.dispatchStatusPublicationBlocked = true; + result.platformApiPreInvocationBlocked = true; + + if (!input.handoffProducesNoDynamicHandle || + !input.handoffStoresNoDynamicHandle || + !input.handoffReleasesNoDynamicHandle || + !input.handoffResolvesNoSymbols || + !input.handoffStoresNoSymbolTable || + !input.handoffCreatesNoRuntime) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff must not create runtime loader state"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffBlockedSummary( + "result_handoff_runtime_state_required"); + return result; + } + result.disabledResultHandoffStateAccepted = true; + + if (!input.resultHandoffFailureMappingReviewed) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff requires disabled result-handoff failure mapping review"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffBlockedSummary( + "result_handoff_failure_mapping_required"); + return result; + } + result.resultHandoffFailureMappingAccepted = true; + + if (!input.unloadExecutionStillDisabled || !input.symbolResolutionStillDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff must keep unload and symbol resolution disabled"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffBlockedSummary( + "non_load_execution_enabled"); + return result; + } + result.unloadExecutionBlocked = true; + result.symbolResolutionBlocked = true; + + if (!input.productionLoaderExecutionDisabled || + !input.realAdapterExecutionDisabled || + !input.loadOnlyExecutionDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff must keep real loader execution disabled"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffBlockedSummary( + "production_loader_enabled"); + return result; + } + result.productionLoaderDisabled = true; + result.realAdapterExecutionDisabled = true; + result.loadOnlyExecutionDisabled = true; + + if (!input.separateExecutionBatchRequired) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff requires a separate execution batch"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffBlockedSummary( + "separate_execution_batch_required"); + return result; + } + result.separateExecutionBatchRequired = true; + + result.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReady = true; + result.status = LiteBridgeRuntimeStatus::Ready; + result.ok = true; + result.summary = std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_result_handoff=ready; platform=") + + result.platform + "; scope=load-only-disabled-callback-refusal-propagation-consumer-readiness-dispatch-consumption-guard-result-handoff; execution=disabled"; + return result; +} + +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjection( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionInput& input) +{ + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionResult result; + result.status = LiteBridgeRuntimeStatus::Configured; + result.platform = normalizedPlatform( + input.platform.empty() ? input.resultHandoff.platform : input.platform); + result.adapterName = input.adapterName.empty() + ? input.resultHandoff.adapterName + : input.adapterName; + result.ownerName = input.ownerName.empty() + ? input.resultHandoff.ownerName + : input.ownerName; + result.handoffId = input.handoffId.empty() + ? input.resultHandoff.handoffId + : input.handoffId; + result.loadCallbackBoundaryName = input.loadCallbackBoundaryName.empty() + ? input.resultHandoff.loadCallbackBoundaryName + : input.loadCallbackBoundaryName; + result.callbackBindingId = input.callbackBindingId.empty() + ? input.resultHandoff.callbackBindingId + : input.callbackBindingId; + result.callbackName = input.callbackName.empty() + ? input.resultHandoff.callbackName + : input.callbackName; + result.guardId = input.guardId.empty() + ? input.resultHandoff.guardId + : input.guardId; + result.refusalResultId = input.refusalResultId.empty() + ? input.resultHandoff.refusalResultId + : input.refusalResultId; + result.propagationId = input.propagationId.empty() + ? input.resultHandoff.propagationId + : input.propagationId; + result.dispatchHandoffId = input.dispatchHandoffId.empty() + ? input.resultHandoff.dispatchHandoffId + : input.dispatchHandoffId; + result.statusRecordId = input.statusRecordId.empty() + ? input.resultHandoff.statusRecordId + : input.statusRecordId; + result.consumerReadinessId = input.consumerReadinessId.empty() + ? input.resultHandoff.consumerReadinessId + : input.consumerReadinessId; + result.consumerName = input.consumerName.empty() + ? input.resultHandoff.consumerName + : input.consumerName; + result.dispatchConsumptionGuardId = input.dispatchConsumptionGuardId.empty() + ? input.resultHandoff.dispatchConsumptionGuardId + : input.dispatchConsumptionGuardId; + result.dispatchConsumerName = input.dispatchConsumerName.empty() + ? input.resultHandoff.dispatchConsumerName + : input.dispatchConsumerName; + result.resultHandoffId = input.resultHandoffId.empty() + ? input.resultHandoff.resultHandoffId + : input.resultHandoffId; + result.resultConsumerName = input.resultConsumerName.empty() + ? input.resultHandoff.resultConsumerName + : input.resultConsumerName; + result.readinessProjectionId = input.readinessProjectionId; + result.readinessConsumerName = input.readinessConsumerName; + + result.noCallbackInvocationAttempted = !input.callbackInvocationAttempted; + result.noCallbackResultExecutionAttempted = !input.callbackResultExecutionAttempted; + result.noDispatchHandoffExecutionAttempted = !input.dispatchHandoffExecutionAttempted; + result.noDispatchStatusPublicationAttempted = !input.dispatchStatusPublicationAttempted; + result.noDispatchConsumerConsumptionAttempted = !input.dispatchConsumerConsumptionAttempted; + result.noDispatchResultExecutionAttempted = !input.dispatchResultExecutionAttempted; + result.noResultHandoffStatusPublicationAttempted = !input.resultHandoffStatusPublicationAttempted; + result.noReadinessProjectionStatusPublicationAttempted = !input.readinessProjectionStatusPublicationAttempted; + result.noRuntimePlatformDynamicLibraryLoaded = !input.runtimePlatformLoadAttempted; + result.noRuntimePlatformDynamicLibraryUnloaded = !input.runtimePlatformUnloadAttempted; + result.noRuntimePlatformSymbolResolution = !input.runtimePlatformSymbolResolutionAttempted; + result.noSdxlCalls = !input.sdxlCallRequested; + result.noBridgeCalls = !input.bridgeCallRequested; + result.noServerConnectivityChecked = !input.serverConnectivityCheckRequested; + result.noWalletLifecycle = !input.walletLifecycleRequested; + result.noSyncStarted = !input.syncRequested; + result.noSyncStatusPolled = !input.syncStatusPollingRequested; + result.noWorkerQueueEnqueue = !input.workerQueueRequested; + result.noWalletStateMutation = !input.walletStateMutationRequested; + result.noWalletPersistence = !input.walletPersistenceRequested; + result.noSettingsPersistence = !input.settingsWriteRequested; + result.noSendImportExportExecution = !input.sendImportExportRequested; + result.noArtifactMutation = !input.artifactMutationRequested; + + if (!result.noCallbackInvocationAttempted || + !result.noCallbackResultExecutionAttempted || + !result.noDispatchHandoffExecutionAttempted || + !result.noDispatchStatusPublicationAttempted || + !result.noDispatchConsumerConsumptionAttempted || + !result.noDispatchResultExecutionAttempted || + !result.noResultHandoffStatusPublicationAttempted || + !result.noReadinessProjectionStatusPublicationAttempted || + !result.noRuntimePlatformDynamicLibraryLoaded || + !result.noRuntimePlatformDynamicLibraryUnloaded || + !result.noRuntimePlatformSymbolResolution) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection must stop before callback, dispatch result execution, readiness publication, status, and platform loader APIs"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionBlockedSummary( + "readiness_projection_or_platform_api_attempted"); + return result; + } + + if (!result.noSdxlCalls || + !result.noBridgeCalls || + !result.noServerConnectivityChecked || + !result.noWalletLifecycle || + !result.noSyncStarted || + !result.noSyncStatusPolled || + !result.noWorkerQueueEnqueue || + !result.noWalletStateMutation || + !result.noWalletPersistence || + !result.noSettingsPersistence || + !result.noSendImportExportExecution || + !result.noArtifactMutation) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection must not request wallet runtime behavior"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionBlockedSummary( + "runtime_action_requested"); + return result; + } + + if (result.platform.empty()) { + result.status = LiteBridgeRuntimeStatus::Unavailable; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection requires a target platform"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionBlockedSummary( + "platform_missing"); + return result; + } + + if (isMacosPlatform(result.platform)) { + result.macosDeferred = true; + result.status = LiteBridgeRuntimeStatus::Unavailable; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionIssue( + result, + input.macosDeferredByOperator + ? "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection is deferred by operator request" + : "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection requires a reviewed builder before promotion"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionBlockedSummary( + "macos_deferred"); + return result; + } + + const bool linuxPlatform = isLinuxPlatform(result.platform); + const bool windowsPlatform = isWindowsPlatform(result.platform); + if (!linuxPlatform && !windowsPlatform) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection supports only Linux and Windows in batch 27"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionBlockedSummary( + "unsupported_platform"); + return result; + } + + result.platformAccepted = true; + result.linuxPlatformAccepted = linuxPlatform; + result.windowsPlatformAccepted = windowsPlatform; + + const auto& handoff = input.resultHandoff; + if (!input.resultHandoffAccepted || + !handoff.ok || + !handoff.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReady || + handoff.status != LiteBridgeRuntimeStatus::Ready || + handoff.platform != result.platform || + !handoff.dispatchConsumptionGuardAccepted || + !handoff.resultHandoffRecordAccepted || + !handoff.handoffDispatchGuardMatchAccepted || + !handoff.disabledResultHandoffAccepted || + !handoff.callbackInvocationRefused || + !handoff.dispatchConsumptionStillGuarded || + !handoff.dispatchResultExecutionBlocked || + !handoff.dispatchStatusPublicationBlocked || + !handoff.platformApiPreInvocationBlocked || + !handoff.disabledResultHandoffStateAccepted || + !handoff.resultHandoffFailureMappingAccepted || + !handoff.unloadExecutionBlocked || + !handoff.symbolResolutionBlocked || + !handoff.productionLoaderDisabled || + !handoff.realAdapterExecutionDisabled || + !handoff.loadOnlyExecutionDisabled || + !handoff.separateExecutionBatchRequired || + !handoff.noCallbackInvocationAttempted || + !handoff.noCallbackResultExecutionAttempted || + !handoff.noDispatchHandoffExecutionAttempted || + !handoff.noDispatchStatusPublicationAttempted || + !handoff.noDispatchConsumerConsumptionAttempted || + !handoff.noDispatchResultExecutionAttempted || + !handoff.noResultHandoffStatusPublicationAttempted || + !handoff.noRuntimePlatformDynamicLibraryLoaded || + !handoff.noRuntimePlatformDynamicLibraryUnloaded || + !handoff.noRuntimePlatformSymbolResolution) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection requires matching ready disabled result-handoff evidence"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionBlockedSummary( + "result_handoff_required"); + return result; + } + result.resultHandoffAccepted = true; + + if (!input.readinessProjectionReviewed || + !input.readinessProjectionRecorded || + !input.readinessProjectionDisabled || + input.readinessProjectionId.empty() || + input.readinessConsumerName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection requires a reviewed disabled readiness-projection record"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionBlockedSummary( + "readiness_projection_required"); + return result; + } + result.readinessProjectionRecordAccepted = true; + + if (!input.projectionOwnerMatchesResultHandoff || + !input.projectionBoundaryMatchesResultHandoff || + !input.projectionCallbackMatchesResultHandoff || + !input.projectionPreInvocationGuardMatchesResultHandoff || + !input.projectionRefusalResultMatchesResultHandoff || + !input.projectionPropagationMatchesResultHandoff || + !input.projectionDispatchHandoffMatchesResultHandoff || + !input.projectionStatusRecordMatchesResultHandoff || + !input.projectionConsumerReadinessMatchesResultHandoff || + !input.projectionConsumerNameMatchesResultHandoff || + !input.projectionDispatchConsumptionGuardMatchesResultHandoff || + !input.projectionDispatchConsumerNameMatchesResultHandoff || + !input.projectionResultHandoffMatchesResultHandoff || + !input.projectionResultConsumerNameMatchesResultHandoff || + result.ownerName != handoff.ownerName || + result.handoffId != handoff.handoffId || + result.loadCallbackBoundaryName != handoff.loadCallbackBoundaryName || + result.callbackBindingId != handoff.callbackBindingId || + result.callbackName != handoff.callbackName || + result.guardId != handoff.guardId || + result.refusalResultId != handoff.refusalResultId || + result.propagationId != handoff.propagationId || + result.dispatchHandoffId != handoff.dispatchHandoffId || + result.statusRecordId != handoff.statusRecordId || + result.consumerReadinessId != handoff.consumerReadinessId || + result.consumerName != handoff.consumerName || + result.dispatchConsumptionGuardId != handoff.dispatchConsumptionGuardId || + result.dispatchConsumerName != handoff.dispatchConsumerName || + result.resultHandoffId != handoff.resultHandoffId || + result.resultConsumerName != handoff.resultConsumerName || + result.adapterName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection requires projection-to-handoff match evidence"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionBlockedSummary( + "readiness_projection_handoff_match_required"); + return result; + } + result.projectionResultHandoffMatchAccepted = true; + + if (!input.disabledReadinessProjectionRegistered || + !input.readinessProjectionAcceptsResultHandoffEvidence || + !input.readinessProjectionReturnsDisabledReadiness || + !input.readinessProjectionBlocksDispatchConsumption || + !input.readinessProjectionBlocksDispatchResultExecution || + !input.readinessProjectionBlocksStatusPublication || + !input.readinessProjectionBlocksReadinessPublication) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection requires disabled readiness-projection evidence"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionBlockedSummary( + "disabled_readiness_projection_required"); + return result; + } + result.disabledReadinessProjectionAccepted = true; + + if (!input.callbackInvocationStillDisabled || + !input.callbackInvocationRefused || + !input.callbackInvocationRefusalReviewed || + !input.projectionStopsBeforeCallbackInvocation || + !input.projectionStopsBeforeCallbackResultExecution || + !input.projectionStopsBeforeDispatchConsumption || + !input.projectionStopsBeforeDispatchResultExecution || + !input.projectionStopsBeforeDispatchStatusPublication || + !input.projectionStopsBeforeReadinessPublication || + !input.projectionStopsBeforePlatformApi || + !input.projectionRequiresSeparateExecutionBatch) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection must remain disabled before callback, dispatch result execution, status publication, readiness publication, and platform APIs"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionBlockedSummary( + "readiness_projection_disabled_state_required"); + return result; + } + result.callbackInvocationRefused = true; + result.dispatchConsumptionStillGuarded = true; + result.dispatchResultExecutionBlocked = true; + result.dispatchStatusPublicationBlocked = true; + result.readinessProjectionPublicationBlocked = true; + result.platformApiPreInvocationBlocked = true; + + if (!input.projectionProducesNoDynamicHandle || + !input.projectionStoresNoDynamicHandle || + !input.projectionReleasesNoDynamicHandle || + !input.projectionResolvesNoSymbols || + !input.projectionStoresNoSymbolTable || + !input.projectionCreatesNoRuntime) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection must not create runtime loader state"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionBlockedSummary( + "readiness_projection_runtime_state_required"); + return result; + } + result.disabledReadinessProjectionStateAccepted = true; + + if (!input.readinessProjectionFailureMappingReviewed) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection requires disabled readiness-projection failure mapping review"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionBlockedSummary( + "readiness_projection_failure_mapping_required"); + return result; + } + result.readinessProjectionFailureMappingAccepted = true; + + if (!input.unloadExecutionStillDisabled || !input.symbolResolutionStillDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection must keep unload and symbol resolution disabled"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionBlockedSummary( + "non_load_execution_enabled"); + return result; + } + result.unloadExecutionBlocked = true; + result.symbolResolutionBlocked = true; + + if (!input.productionLoaderExecutionDisabled || + !input.realAdapterExecutionDisabled || + !input.loadOnlyExecutionDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection must keep real loader execution disabled"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionBlockedSummary( + "production_loader_enabled"); + return result; + } + result.productionLoaderDisabled = true; + result.realAdapterExecutionDisabled = true; + result.loadOnlyExecutionDisabled = true; + + if (!input.separateExecutionBatchRequired) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection requires a separate execution batch"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionBlockedSummary( + "separate_execution_batch_required"); + return result; + } + result.separateExecutionBatchRequired = true; + + result.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionReady = true; + result.status = LiteBridgeRuntimeStatus::Ready; + result.ok = true; + result.summary = std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_result_handoff_readiness_projection=ready; platform=") + + result.platform + "; scope=load-only-disabled-callback-refusal-propagation-consumer-readiness-dispatch-consumption-guard-result-handoff-readiness-projection; execution=disabled"; + return result; +} + +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoff( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffInput& input) +{ + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffResult result; + result.status = LiteBridgeRuntimeStatus::Configured; + result.platform = normalizedPlatform( + input.platform.empty() ? input.readinessProjection.platform : input.platform); + result.adapterName = input.adapterName.empty() + ? input.readinessProjection.adapterName + : input.adapterName; + result.ownerName = input.ownerName.empty() + ? input.readinessProjection.ownerName + : input.ownerName; + result.handoffId = input.handoffId.empty() + ? input.readinessProjection.handoffId + : input.handoffId; + result.loadCallbackBoundaryName = input.loadCallbackBoundaryName.empty() + ? input.readinessProjection.loadCallbackBoundaryName + : input.loadCallbackBoundaryName; + result.callbackBindingId = input.callbackBindingId.empty() + ? input.readinessProjection.callbackBindingId + : input.callbackBindingId; + result.callbackName = input.callbackName.empty() + ? input.readinessProjection.callbackName + : input.callbackName; + result.guardId = input.guardId.empty() + ? input.readinessProjection.guardId + : input.guardId; + result.refusalResultId = input.refusalResultId.empty() + ? input.readinessProjection.refusalResultId + : input.refusalResultId; + result.propagationId = input.propagationId.empty() + ? input.readinessProjection.propagationId + : input.propagationId; + result.dispatchHandoffId = input.dispatchHandoffId.empty() + ? input.readinessProjection.dispatchHandoffId + : input.dispatchHandoffId; + result.statusRecordId = input.statusRecordId.empty() + ? input.readinessProjection.statusRecordId + : input.statusRecordId; + result.consumerReadinessId = input.consumerReadinessId.empty() + ? input.readinessProjection.consumerReadinessId + : input.consumerReadinessId; + result.consumerName = input.consumerName.empty() + ? input.readinessProjection.consumerName + : input.consumerName; + result.dispatchConsumptionGuardId = input.dispatchConsumptionGuardId.empty() + ? input.readinessProjection.dispatchConsumptionGuardId + : input.dispatchConsumptionGuardId; + result.dispatchConsumerName = input.dispatchConsumerName.empty() + ? input.readinessProjection.dispatchConsumerName + : input.dispatchConsumerName; + result.resultHandoffId = input.resultHandoffId.empty() + ? input.readinessProjection.resultHandoffId + : input.resultHandoffId; + result.resultConsumerName = input.resultConsumerName.empty() + ? input.readinessProjection.resultConsumerName + : input.resultConsumerName; + result.readinessProjectionId = input.readinessProjectionId.empty() + ? input.readinessProjection.readinessProjectionId + : input.readinessProjectionId; + result.readinessConsumerName = input.readinessConsumerName.empty() + ? input.readinessProjection.readinessConsumerName + : input.readinessConsumerName; + result.statusHandoffId = input.statusHandoffId; + result.statusConsumerName = input.statusConsumerName; + + result.noCallbackInvocationAttempted = !input.callbackInvocationAttempted; + result.noCallbackResultExecutionAttempted = !input.callbackResultExecutionAttempted; + result.noDispatchHandoffExecutionAttempted = !input.dispatchHandoffExecutionAttempted; + result.noDispatchStatusPublicationAttempted = !input.dispatchStatusPublicationAttempted; + result.noDispatchConsumerConsumptionAttempted = !input.dispatchConsumerConsumptionAttempted; + result.noDispatchResultExecutionAttempted = !input.dispatchResultExecutionAttempted; + result.noResultHandoffStatusPublicationAttempted = !input.resultHandoffStatusPublicationAttempted; + result.noReadinessProjectionStatusPublicationAttempted = !input.readinessProjectionStatusPublicationAttempted; + result.noStatusHandoffPublicationAttempted = !input.statusHandoffPublicationAttempted; + result.noRuntimePlatformDynamicLibraryLoaded = !input.runtimePlatformLoadAttempted; + result.noRuntimePlatformDynamicLibraryUnloaded = !input.runtimePlatformUnloadAttempted; + result.noRuntimePlatformSymbolResolution = !input.runtimePlatformSymbolResolutionAttempted; + result.noSdxlCalls = !input.sdxlCallRequested; + result.noBridgeCalls = !input.bridgeCallRequested; + result.noServerConnectivityChecked = !input.serverConnectivityCheckRequested; + result.noWalletLifecycle = !input.walletLifecycleRequested; + result.noSyncStarted = !input.syncRequested; + result.noSyncStatusPolled = !input.syncStatusPollingRequested; + result.noWorkerQueueEnqueue = !input.workerQueueRequested; + result.noWalletStateMutation = !input.walletStateMutationRequested; + result.noWalletPersistence = !input.walletPersistenceRequested; + result.noSettingsPersistence = !input.settingsWriteRequested; + result.noSendImportExportExecution = !input.sendImportExportRequested; + result.noArtifactMutation = !input.artifactMutationRequested; + + if (!result.noCallbackInvocationAttempted || + !result.noCallbackResultExecutionAttempted || + !result.noDispatchHandoffExecutionAttempted || + !result.noDispatchStatusPublicationAttempted || + !result.noDispatchConsumerConsumptionAttempted || + !result.noDispatchResultExecutionAttempted || + !result.noResultHandoffStatusPublicationAttempted || + !result.noReadinessProjectionStatusPublicationAttempted || + !result.noStatusHandoffPublicationAttempted || + !result.noRuntimePlatformDynamicLibraryLoaded || + !result.noRuntimePlatformDynamicLibraryUnloaded || + !result.noRuntimePlatformSymbolResolution) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff must stop before callback, dispatch result execution, readiness publication, status handoff publication, and platform loader APIs"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary( + "status_handoff_or_platform_api_attempted"); + return result; + } + + if (!result.noSdxlCalls || + !result.noBridgeCalls || + !result.noServerConnectivityChecked || + !result.noWalletLifecycle || + !result.noSyncStarted || + !result.noSyncStatusPolled || + !result.noWorkerQueueEnqueue || + !result.noWalletStateMutation || + !result.noWalletPersistence || + !result.noSettingsPersistence || + !result.noSendImportExportExecution || + !result.noArtifactMutation) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff must not request wallet runtime behavior"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary( + "runtime_action_requested"); + return result; + } + + if (result.platform.empty()) { + result.status = LiteBridgeRuntimeStatus::Unavailable; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff requires a target platform"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary( + "platform_missing"); + return result; + } + + if (isMacosPlatform(result.platform)) { + result.macosDeferred = true; + result.status = LiteBridgeRuntimeStatus::Unavailable; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffIssue( + result, + input.macosDeferredByOperator + ? "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff is deferred by operator request" + : "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff requires a reviewed builder before promotion"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary( + "macos_deferred"); + return result; + } + + const bool linuxPlatform = isLinuxPlatform(result.platform); + const bool windowsPlatform = isWindowsPlatform(result.platform); + if (!linuxPlatform && !windowsPlatform) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff supports only Linux and Windows in batch 28"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary( + "unsupported_platform"); + return result; + } + + result.platformAccepted = true; + result.linuxPlatformAccepted = linuxPlatform; + result.windowsPlatformAccepted = windowsPlatform; + + const auto& projection = input.readinessProjection; + if (!input.readinessProjectionAccepted || + !projection.ok || + !projection.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionReady || + projection.status != LiteBridgeRuntimeStatus::Ready || + projection.platform != result.platform || + !projection.resultHandoffAccepted || + !projection.readinessProjectionRecordAccepted || + !projection.projectionResultHandoffMatchAccepted || + !projection.disabledReadinessProjectionAccepted || + !projection.callbackInvocationRefused || + !projection.dispatchConsumptionStillGuarded || + !projection.dispatchResultExecutionBlocked || + !projection.dispatchStatusPublicationBlocked || + !projection.readinessProjectionPublicationBlocked || + !projection.platformApiPreInvocationBlocked || + !projection.disabledReadinessProjectionStateAccepted || + !projection.readinessProjectionFailureMappingAccepted || + !projection.unloadExecutionBlocked || + !projection.symbolResolutionBlocked || + !projection.productionLoaderDisabled || + !projection.realAdapterExecutionDisabled || + !projection.loadOnlyExecutionDisabled || + !projection.separateExecutionBatchRequired || + !projection.noCallbackInvocationAttempted || + !projection.noCallbackResultExecutionAttempted || + !projection.noDispatchHandoffExecutionAttempted || + !projection.noDispatchStatusPublicationAttempted || + !projection.noDispatchConsumerConsumptionAttempted || + !projection.noDispatchResultExecutionAttempted || + !projection.noResultHandoffStatusPublicationAttempted || + !projection.noReadinessProjectionStatusPublicationAttempted || + !projection.noRuntimePlatformDynamicLibraryLoaded || + !projection.noRuntimePlatformDynamicLibraryUnloaded || + !projection.noRuntimePlatformSymbolResolution) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff requires matching ready disabled readiness-projection evidence"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary( + "readiness_projection_required"); + return result; + } + result.readinessProjectionAccepted = true; + + if (!input.statusHandoffReviewed || + !input.statusHandoffRecorded || + !input.statusHandoffDisabled || + input.statusHandoffId.empty() || + input.statusConsumerName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff requires a reviewed disabled status-handoff record"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary( + "status_handoff_required"); + return result; + } + result.statusHandoffRecordAccepted = true; + + if (!input.statusHandoffOwnerMatchesReadinessProjection || + !input.statusHandoffBoundaryMatchesReadinessProjection || + !input.statusHandoffCallbackMatchesReadinessProjection || + !input.statusHandoffPreInvocationGuardMatchesReadinessProjection || + !input.statusHandoffRefusalResultMatchesReadinessProjection || + !input.statusHandoffPropagationMatchesReadinessProjection || + !input.statusHandoffDispatchHandoffMatchesReadinessProjection || + !input.statusHandoffStatusRecordMatchesReadinessProjection || + !input.statusHandoffConsumerReadinessMatchesReadinessProjection || + !input.statusHandoffConsumerNameMatchesReadinessProjection || + !input.statusHandoffDispatchConsumptionGuardMatchesReadinessProjection || + !input.statusHandoffDispatchConsumerNameMatchesReadinessProjection || + !input.statusHandoffResultHandoffMatchesReadinessProjection || + !input.statusHandoffResultConsumerNameMatchesReadinessProjection || + !input.statusHandoffReadinessProjectionMatchesReadinessProjection || + !input.statusHandoffReadinessConsumerNameMatchesReadinessProjection || + result.ownerName != projection.ownerName || + result.handoffId != projection.handoffId || + result.loadCallbackBoundaryName != projection.loadCallbackBoundaryName || + result.callbackBindingId != projection.callbackBindingId || + result.callbackName != projection.callbackName || + result.guardId != projection.guardId || + result.refusalResultId != projection.refusalResultId || + result.propagationId != projection.propagationId || + result.dispatchHandoffId != projection.dispatchHandoffId || + result.statusRecordId != projection.statusRecordId || + result.consumerReadinessId != projection.consumerReadinessId || + result.consumerName != projection.consumerName || + result.dispatchConsumptionGuardId != projection.dispatchConsumptionGuardId || + result.dispatchConsumerName != projection.dispatchConsumerName || + result.resultHandoffId != projection.resultHandoffId || + result.resultConsumerName != projection.resultConsumerName || + result.readinessProjectionId != projection.readinessProjectionId || + result.readinessConsumerName != projection.readinessConsumerName || + result.adapterName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff requires status-handoff-to-projection match evidence"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary( + "status_handoff_projection_match_required"); + return result; + } + result.statusHandoffReadinessProjectionMatchAccepted = true; + + if (!input.disabledStatusHandoffRegistered || + !input.statusHandoffAcceptsReadinessProjectionEvidence || + !input.statusHandoffReturnsDisabledStatus || + !input.statusHandoffBlocksDispatchConsumption || + !input.statusHandoffBlocksDispatchResultExecution || + !input.statusHandoffBlocksStatusPublication || + !input.statusHandoffBlocksReadinessPublication) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff requires disabled status-handoff evidence"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary( + "disabled_status_handoff_required"); + return result; + } + result.disabledStatusHandoffAccepted = true; + + if (!input.callbackInvocationStillDisabled || + !input.callbackInvocationRefused || + !input.callbackInvocationRefusalReviewed || + !input.statusHandoffStopsBeforeCallbackInvocation || + !input.statusHandoffStopsBeforeCallbackResultExecution || + !input.statusHandoffStopsBeforeDispatchConsumption || + !input.statusHandoffStopsBeforeDispatchResultExecution || + !input.statusHandoffStopsBeforeDispatchStatusPublication || + !input.statusHandoffStopsBeforeReadinessPublication || + !input.statusHandoffStopsBeforeStatusPublication || + !input.statusHandoffStopsBeforePlatformApi || + !input.statusHandoffRequiresSeparateExecutionBatch) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff must remain disabled before callback, dispatch result execution, status publication, readiness publication, and platform APIs"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary( + "status_handoff_disabled_state_required"); + return result; + } + result.callbackInvocationRefused = true; + result.dispatchConsumptionStillGuarded = true; + result.dispatchResultExecutionBlocked = true; + result.dispatchStatusPublicationBlocked = true; + result.readinessProjectionPublicationBlocked = true; + result.statusHandoffPublicationBlocked = true; + result.platformApiPreInvocationBlocked = true; + + if (!input.statusHandoffProducesNoDynamicHandle || + !input.statusHandoffStoresNoDynamicHandle || + !input.statusHandoffReleasesNoDynamicHandle || + !input.statusHandoffResolvesNoSymbols || + !input.statusHandoffStoresNoSymbolTable || + !input.statusHandoffCreatesNoRuntime) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff must not create runtime loader state"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary( + "status_handoff_runtime_state_required"); + return result; + } + result.disabledStatusHandoffStateAccepted = true; + + if (!input.statusHandoffFailureMappingReviewed) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff requires disabled status-handoff failure mapping review"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary( + "status_handoff_failure_mapping_required"); + return result; + } + result.statusHandoffFailureMappingAccepted = true; + + if (!input.unloadExecutionStillDisabled || !input.symbolResolutionStillDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff must keep unload and symbol resolution disabled"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary( + "non_load_execution_enabled"); + return result; + } + result.unloadExecutionBlocked = true; + result.symbolResolutionBlocked = true; + + if (!input.productionLoaderExecutionDisabled || + !input.realAdapterExecutionDisabled || + !input.loadOnlyExecutionDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff must keep real loader execution disabled"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary( + "production_loader_enabled"); + return result; + } + result.productionLoaderDisabled = true; + result.realAdapterExecutionDisabled = true; + result.loadOnlyExecutionDisabled = true; + + if (!input.separateExecutionBatchRequired) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff requires a separate execution batch"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary( + "separate_execution_batch_required"); + return result; + } + result.separateExecutionBatchRequired = true; + + result.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffReady = true; + result.status = LiteBridgeRuntimeStatus::Ready; + result.ok = true; + result.summary = std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_result_handoff_readiness_projection_status_handoff=ready; platform=") + + result.platform + "; scope=load-only-disabled-callback-refusal-propagation-consumer-readiness-dispatch-consumption-guard-result-handoff-readiness-projection-status-handoff; execution=disabled"; + return result; +} + +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardInput& input) +{ + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResult result; + result.status = LiteBridgeRuntimeStatus::Configured; + result.platform = normalizedPlatform( + input.platform.empty() ? input.statusHandoff.platform : input.platform); + result.adapterName = input.adapterName.empty() + ? input.statusHandoff.adapterName + : input.adapterName; + result.ownerName = input.ownerName.empty() + ? input.statusHandoff.ownerName + : input.ownerName; + result.handoffId = input.handoffId.empty() + ? input.statusHandoff.handoffId + : input.handoffId; + result.loadCallbackBoundaryName = input.loadCallbackBoundaryName.empty() + ? input.statusHandoff.loadCallbackBoundaryName + : input.loadCallbackBoundaryName; + result.callbackBindingId = input.callbackBindingId.empty() + ? input.statusHandoff.callbackBindingId + : input.callbackBindingId; + result.callbackName = input.callbackName.empty() + ? input.statusHandoff.callbackName + : input.callbackName; + result.guardId = input.guardId.empty() + ? input.statusHandoff.guardId + : input.guardId; + result.refusalResultId = input.refusalResultId.empty() + ? input.statusHandoff.refusalResultId + : input.refusalResultId; + result.propagationId = input.propagationId.empty() + ? input.statusHandoff.propagationId + : input.propagationId; + result.dispatchHandoffId = input.dispatchHandoffId.empty() + ? input.statusHandoff.dispatchHandoffId + : input.dispatchHandoffId; + result.statusRecordId = input.statusRecordId.empty() + ? input.statusHandoff.statusRecordId + : input.statusRecordId; + result.consumerReadinessId = input.consumerReadinessId.empty() + ? input.statusHandoff.consumerReadinessId + : input.consumerReadinessId; + result.consumerName = input.consumerName.empty() + ? input.statusHandoff.consumerName + : input.consumerName; + result.dispatchConsumptionGuardId = input.dispatchConsumptionGuardId.empty() + ? input.statusHandoff.dispatchConsumptionGuardId + : input.dispatchConsumptionGuardId; + result.dispatchConsumerName = input.dispatchConsumerName.empty() + ? input.statusHandoff.dispatchConsumerName + : input.dispatchConsumerName; + result.resultHandoffId = input.resultHandoffId.empty() + ? input.statusHandoff.resultHandoffId + : input.resultHandoffId; + result.resultConsumerName = input.resultConsumerName.empty() + ? input.statusHandoff.resultConsumerName + : input.resultConsumerName; + result.readinessProjectionId = input.readinessProjectionId.empty() + ? input.statusHandoff.readinessProjectionId + : input.readinessProjectionId; + result.readinessConsumerName = input.readinessConsumerName.empty() + ? input.statusHandoff.readinessConsumerName + : input.readinessConsumerName; + result.statusHandoffId = input.statusHandoffId.empty() + ? input.statusHandoff.statusHandoffId + : input.statusHandoffId; + result.statusConsumerName = input.statusConsumerName.empty() + ? input.statusHandoff.statusConsumerName + : input.statusConsumerName; + result.publicationGuardId = input.publicationGuardId; + result.publicationConsumerName = input.publicationConsumerName; + + result.noCallbackInvocationAttempted = !input.callbackInvocationAttempted; + result.noCallbackResultExecutionAttempted = !input.callbackResultExecutionAttempted; + result.noDispatchHandoffExecutionAttempted = !input.dispatchHandoffExecutionAttempted; + result.noDispatchStatusPublicationAttempted = !input.dispatchStatusPublicationAttempted; + result.noDispatchConsumerConsumptionAttempted = !input.dispatchConsumerConsumptionAttempted; + result.noDispatchResultExecutionAttempted = !input.dispatchResultExecutionAttempted; + result.noResultHandoffStatusPublicationAttempted = !input.resultHandoffStatusPublicationAttempted; + result.noReadinessProjectionStatusPublicationAttempted = !input.readinessProjectionStatusPublicationAttempted; + result.noStatusHandoffPublicationAttempted = !input.statusHandoffPublicationAttempted; + result.noPublicationGuardPublicationAttempted = !input.publicationGuardPublicationAttempted; + result.noRuntimePlatformDynamicLibraryLoaded = !input.runtimePlatformLoadAttempted; + result.noRuntimePlatformDynamicLibraryUnloaded = !input.runtimePlatformUnloadAttempted; + result.noRuntimePlatformSymbolResolution = !input.runtimePlatformSymbolResolutionAttempted; + result.noSdxlCalls = !input.sdxlCallRequested; + result.noBridgeCalls = !input.bridgeCallRequested; + result.noServerConnectivityChecked = !input.serverConnectivityCheckRequested; + result.noWalletLifecycle = !input.walletLifecycleRequested; + result.noSyncStarted = !input.syncRequested; + result.noSyncStatusPolled = !input.syncStatusPollingRequested; + result.noWorkerQueueEnqueue = !input.workerQueueRequested; + result.noWalletStateMutation = !input.walletStateMutationRequested; + result.noWalletPersistence = !input.walletPersistenceRequested; + result.noSettingsPersistence = !input.settingsWriteRequested; + result.noSendImportExportExecution = !input.sendImportExportRequested; + result.noArtifactMutation = !input.artifactMutationRequested; + + if (!result.noCallbackInvocationAttempted || + !result.noCallbackResultExecutionAttempted || + !result.noDispatchHandoffExecutionAttempted || + !result.noDispatchStatusPublicationAttempted || + !result.noDispatchConsumerConsumptionAttempted || + !result.noDispatchResultExecutionAttempted || + !result.noResultHandoffStatusPublicationAttempted || + !result.noReadinessProjectionStatusPublicationAttempted || + !result.noStatusHandoffPublicationAttempted || + !result.noPublicationGuardPublicationAttempted || + !result.noRuntimePlatformDynamicLibraryLoaded || + !result.noRuntimePlatformDynamicLibraryUnloaded || + !result.noRuntimePlatformSymbolResolution) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard must stop before callback, dispatch result execution, status publication, readiness publication, publication guard publication, and platform loader APIs"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlockedSummary( + "publication_guard_or_platform_api_attempted"); + return result; + } + + if (!result.noSdxlCalls || + !result.noBridgeCalls || + !result.noServerConnectivityChecked || + !result.noWalletLifecycle || + !result.noSyncStarted || + !result.noSyncStatusPolled || + !result.noWorkerQueueEnqueue || + !result.noWalletStateMutation || + !result.noWalletPersistence || + !result.noSettingsPersistence || + !result.noSendImportExportExecution || + !result.noArtifactMutation) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard must not request wallet runtime behavior"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlockedSummary( + "runtime_action_requested"); + return result; + } + + if (result.platform.empty()) { + result.status = LiteBridgeRuntimeStatus::Unavailable; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard requires a target platform"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlockedSummary( + "platform_missing"); + return result; + } + + if (isMacosPlatform(result.platform)) { + result.macosDeferred = true; + result.status = LiteBridgeRuntimeStatus::Unavailable; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardIssue( + result, + input.macosDeferredByOperator + ? "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard is deferred by operator request" + : "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard requires a reviewed builder before promotion"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlockedSummary( + "macos_deferred"); + return result; + } + + const bool linuxPlatform = isLinuxPlatform(result.platform); + const bool windowsPlatform = isWindowsPlatform(result.platform); + if (!linuxPlatform && !windowsPlatform) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard supports only Linux and Windows in batch 29"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlockedSummary( + "unsupported_platform"); + return result; + } + + result.platformAccepted = true; + result.linuxPlatformAccepted = linuxPlatform; + result.windowsPlatformAccepted = windowsPlatform; + + const auto& statusHandoff = input.statusHandoff; + if (!input.statusHandoffAccepted || + !statusHandoff.ok || + !statusHandoff.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffReady || + statusHandoff.status != LiteBridgeRuntimeStatus::Ready || + statusHandoff.platform != result.platform || + !statusHandoff.readinessProjectionAccepted || + !statusHandoff.statusHandoffRecordAccepted || + !statusHandoff.statusHandoffReadinessProjectionMatchAccepted || + !statusHandoff.disabledStatusHandoffAccepted || + !statusHandoff.callbackInvocationRefused || + !statusHandoff.dispatchConsumptionStillGuarded || + !statusHandoff.dispatchResultExecutionBlocked || + !statusHandoff.dispatchStatusPublicationBlocked || + !statusHandoff.readinessProjectionPublicationBlocked || + !statusHandoff.statusHandoffPublicationBlocked || + !statusHandoff.platformApiPreInvocationBlocked || + !statusHandoff.disabledStatusHandoffStateAccepted || + !statusHandoff.statusHandoffFailureMappingAccepted || + !statusHandoff.unloadExecutionBlocked || + !statusHandoff.symbolResolutionBlocked || + !statusHandoff.productionLoaderDisabled || + !statusHandoff.realAdapterExecutionDisabled || + !statusHandoff.loadOnlyExecutionDisabled || + !statusHandoff.separateExecutionBatchRequired || + !statusHandoff.noCallbackInvocationAttempted || + !statusHandoff.noCallbackResultExecutionAttempted || + !statusHandoff.noDispatchHandoffExecutionAttempted || + !statusHandoff.noDispatchStatusPublicationAttempted || + !statusHandoff.noDispatchConsumerConsumptionAttempted || + !statusHandoff.noDispatchResultExecutionAttempted || + !statusHandoff.noResultHandoffStatusPublicationAttempted || + !statusHandoff.noReadinessProjectionStatusPublicationAttempted || + !statusHandoff.noStatusHandoffPublicationAttempted || + !statusHandoff.noRuntimePlatformDynamicLibraryLoaded || + !statusHandoff.noRuntimePlatformDynamicLibraryUnloaded || + !statusHandoff.noRuntimePlatformSymbolResolution) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard requires matching ready disabled status-handoff evidence"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlockedSummary( + "status_handoff_required"); + return result; + } + result.statusHandoffAccepted = true; + + if (!input.publicationGuardReviewed || + !input.publicationGuardRecorded || + !input.publicationGuardDisabled || + input.publicationGuardId.empty() || + input.publicationConsumerName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard requires a reviewed disabled publication-guard record"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlockedSummary( + "publication_guard_required"); + return result; + } + result.publicationGuardRecordAccepted = true; + + if (!input.publicationGuardOwnerMatchesStatusHandoff || + !input.publicationGuardBoundaryMatchesStatusHandoff || + !input.publicationGuardCallbackMatchesStatusHandoff || + !input.publicationGuardPreInvocationGuardMatchesStatusHandoff || + !input.publicationGuardRefusalResultMatchesStatusHandoff || + !input.publicationGuardPropagationMatchesStatusHandoff || + !input.publicationGuardDispatchHandoffMatchesStatusHandoff || + !input.publicationGuardStatusRecordMatchesStatusHandoff || + !input.publicationGuardConsumerReadinessMatchesStatusHandoff || + !input.publicationGuardConsumerNameMatchesStatusHandoff || + !input.publicationGuardDispatchConsumptionGuardMatchesStatusHandoff || + !input.publicationGuardDispatchConsumerNameMatchesStatusHandoff || + !input.publicationGuardResultHandoffMatchesStatusHandoff || + !input.publicationGuardResultConsumerNameMatchesStatusHandoff || + !input.publicationGuardReadinessProjectionMatchesStatusHandoff || + !input.publicationGuardReadinessConsumerNameMatchesStatusHandoff || + !input.publicationGuardStatusHandoffMatchesStatusHandoff || + !input.publicationGuardStatusConsumerNameMatchesStatusHandoff || + result.ownerName != statusHandoff.ownerName || + result.handoffId != statusHandoff.handoffId || + result.loadCallbackBoundaryName != statusHandoff.loadCallbackBoundaryName || + result.callbackBindingId != statusHandoff.callbackBindingId || + result.callbackName != statusHandoff.callbackName || + result.guardId != statusHandoff.guardId || + result.refusalResultId != statusHandoff.refusalResultId || + result.propagationId != statusHandoff.propagationId || + result.dispatchHandoffId != statusHandoff.dispatchHandoffId || + result.statusRecordId != statusHandoff.statusRecordId || + result.consumerReadinessId != statusHandoff.consumerReadinessId || + result.consumerName != statusHandoff.consumerName || + result.dispatchConsumptionGuardId != statusHandoff.dispatchConsumptionGuardId || + result.dispatchConsumerName != statusHandoff.dispatchConsumerName || + result.resultHandoffId != statusHandoff.resultHandoffId || + result.resultConsumerName != statusHandoff.resultConsumerName || + result.readinessProjectionId != statusHandoff.readinessProjectionId || + result.readinessConsumerName != statusHandoff.readinessConsumerName || + result.statusHandoffId != statusHandoff.statusHandoffId || + result.statusConsumerName != statusHandoff.statusConsumerName || + result.adapterName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard requires publication-guard-to-status-handoff match evidence"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlockedSummary( + "publication_guard_status_handoff_match_required"); + return result; + } + result.publicationGuardStatusHandoffMatchAccepted = true; + + if (!input.disabledPublicationGuardRegistered || + !input.publicationGuardAcceptsStatusHandoffEvidence || + !input.publicationGuardReturnsDisabledPublication || + !input.publicationGuardBlocksDispatchConsumption || + !input.publicationGuardBlocksDispatchResultExecution || + !input.publicationGuardBlocksStatusPublication || + !input.publicationGuardBlocksReadinessPublication || + !input.publicationGuardBlocksStatusHandoffPublication) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard requires disabled publication-guard evidence"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlockedSummary( + "disabled_publication_guard_required"); + return result; + } + result.disabledPublicationGuardAccepted = true; + + if (!input.callbackInvocationStillDisabled || + !input.callbackInvocationRefused || + !input.callbackInvocationRefusalReviewed || + !input.publicationGuardStopsBeforeCallbackInvocation || + !input.publicationGuardStopsBeforeCallbackResultExecution || + !input.publicationGuardStopsBeforeDispatchConsumption || + !input.publicationGuardStopsBeforeDispatchResultExecution || + !input.publicationGuardStopsBeforeDispatchStatusPublication || + !input.publicationGuardStopsBeforeReadinessPublication || + !input.publicationGuardStopsBeforeStatusHandoffPublication || + !input.publicationGuardStopsBeforePublication || + !input.publicationGuardStopsBeforePlatformApi || + !input.publicationGuardRequiresSeparateExecutionBatch) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard must remain disabled before callback, dispatch result execution, status publication, readiness publication, publication, and platform APIs"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlockedSummary( + "publication_guard_disabled_state_required"); + return result; + } + result.callbackInvocationRefused = true; + result.dispatchConsumptionStillGuarded = true; + result.dispatchResultExecutionBlocked = true; + result.dispatchStatusPublicationBlocked = true; + result.readinessProjectionPublicationBlocked = true; + result.statusHandoffPublicationBlocked = true; + result.publicationGuardPublicationBlocked = true; + result.platformApiPreInvocationBlocked = true; + + if (!input.publicationGuardProducesNoDynamicHandle || + !input.publicationGuardStoresNoDynamicHandle || + !input.publicationGuardReleasesNoDynamicHandle || + !input.publicationGuardResolvesNoSymbols || + !input.publicationGuardStoresNoSymbolTable || + !input.publicationGuardCreatesNoRuntime) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard must not create runtime loader state"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlockedSummary( + "publication_guard_runtime_state_required"); + return result; + } + result.disabledPublicationGuardStateAccepted = true; + + if (!input.publicationGuardFailureMappingReviewed) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard requires disabled publication-guard failure mapping review"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlockedSummary( + "publication_guard_failure_mapping_required"); + return result; + } + result.publicationGuardFailureMappingAccepted = true; + + if (!input.unloadExecutionStillDisabled || !input.symbolResolutionStillDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard must keep unload and symbol resolution disabled"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlockedSummary( + "non_load_execution_enabled"); + return result; + } + result.unloadExecutionBlocked = true; + result.symbolResolutionBlocked = true; + + if (!input.productionLoaderExecutionDisabled || + !input.realAdapterExecutionDisabled || + !input.loadOnlyExecutionDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard must keep real loader execution disabled"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlockedSummary( + "production_loader_enabled"); + return result; + } + result.productionLoaderDisabled = true; + result.realAdapterExecutionDisabled = true; + result.loadOnlyExecutionDisabled = true; + + if (!input.separateExecutionBatchRequired) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard requires a separate execution batch"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlockedSummary( + "separate_execution_batch_required"); + return result; + } + result.separateExecutionBatchRequired = true; + + result.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardReady = true; + result.status = LiteBridgeRuntimeStatus::Ready; + result.ok = true; + result.summary = std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_result_handoff_readiness_projection_status_handoff_publication_guard=ready; platform=") + + result.platform + "; scope=load-only-disabled-callback-refusal-propagation-consumer-readiness-dispatch-consumption-guard-result-handoff-readiness-projection-status-handoff-publication-guard; execution=disabled"; + return result; +} + +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffInput& input) +{ + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffResult result; + result.status = LiteBridgeRuntimeStatus::Configured; + result.platform = normalizedPlatform( + input.platform.empty() ? input.publicationGuard.platform : input.platform); + result.adapterName = input.adapterName.empty() + ? input.publicationGuard.adapterName + : input.adapterName; + result.ownerName = input.ownerName.empty() + ? input.publicationGuard.ownerName + : input.ownerName; + result.handoffId = input.handoffId.empty() + ? input.publicationGuard.handoffId + : input.handoffId; + result.loadCallbackBoundaryName = input.loadCallbackBoundaryName.empty() + ? input.publicationGuard.loadCallbackBoundaryName + : input.loadCallbackBoundaryName; + result.callbackBindingId = input.callbackBindingId.empty() + ? input.publicationGuard.callbackBindingId + : input.callbackBindingId; + result.callbackName = input.callbackName.empty() + ? input.publicationGuard.callbackName + : input.callbackName; + result.guardId = input.guardId.empty() + ? input.publicationGuard.guardId + : input.guardId; + result.refusalResultId = input.refusalResultId.empty() + ? input.publicationGuard.refusalResultId + : input.refusalResultId; + result.propagationId = input.propagationId.empty() + ? input.publicationGuard.propagationId + : input.propagationId; + result.dispatchHandoffId = input.dispatchHandoffId.empty() + ? input.publicationGuard.dispatchHandoffId + : input.dispatchHandoffId; + result.statusRecordId = input.statusRecordId.empty() + ? input.publicationGuard.statusRecordId + : input.statusRecordId; + result.consumerReadinessId = input.consumerReadinessId.empty() + ? input.publicationGuard.consumerReadinessId + : input.consumerReadinessId; + result.consumerName = input.consumerName.empty() + ? input.publicationGuard.consumerName + : input.consumerName; + result.dispatchConsumptionGuardId = input.dispatchConsumptionGuardId.empty() + ? input.publicationGuard.dispatchConsumptionGuardId + : input.dispatchConsumptionGuardId; + result.dispatchConsumerName = input.dispatchConsumerName.empty() + ? input.publicationGuard.dispatchConsumerName + : input.dispatchConsumerName; + result.resultHandoffId = input.resultHandoffId.empty() + ? input.publicationGuard.resultHandoffId + : input.resultHandoffId; + result.resultConsumerName = input.resultConsumerName.empty() + ? input.publicationGuard.resultConsumerName + : input.resultConsumerName; + result.readinessProjectionId = input.readinessProjectionId.empty() + ? input.publicationGuard.readinessProjectionId + : input.readinessProjectionId; + result.readinessConsumerName = input.readinessConsumerName.empty() + ? input.publicationGuard.readinessConsumerName + : input.readinessConsumerName; + result.statusHandoffId = input.statusHandoffId.empty() + ? input.publicationGuard.statusHandoffId + : input.statusHandoffId; + result.statusConsumerName = input.statusConsumerName.empty() + ? input.publicationGuard.statusConsumerName + : input.statusConsumerName; + result.publicationGuardId = input.publicationGuardId.empty() + ? input.publicationGuard.publicationGuardId + : input.publicationGuardId; + result.publicationConsumerName = input.publicationConsumerName.empty() + ? input.publicationGuard.publicationConsumerName + : input.publicationConsumerName; + result.publicationGuardResultHandoffId = input.publicationGuardResultHandoffId; + result.publicationGuardResultConsumerName = input.publicationGuardResultConsumerName; + + result.noCallbackInvocationAttempted = !input.callbackInvocationAttempted; + result.noCallbackResultExecutionAttempted = !input.callbackResultExecutionAttempted; + result.noDispatchHandoffExecutionAttempted = !input.dispatchHandoffExecutionAttempted; + result.noDispatchStatusPublicationAttempted = !input.dispatchStatusPublicationAttempted; + result.noDispatchConsumerConsumptionAttempted = !input.dispatchConsumerConsumptionAttempted; + result.noDispatchResultExecutionAttempted = !input.dispatchResultExecutionAttempted; + result.noResultHandoffStatusPublicationAttempted = !input.resultHandoffStatusPublicationAttempted; + result.noReadinessProjectionStatusPublicationAttempted = !input.readinessProjectionStatusPublicationAttempted; + result.noStatusHandoffPublicationAttempted = !input.statusHandoffPublicationAttempted; + result.noPublicationGuardPublicationAttempted = !input.publicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffPublicationAttempted; + result.noRuntimePlatformDynamicLibraryLoaded = !input.runtimePlatformLoadAttempted; + result.noRuntimePlatformDynamicLibraryUnloaded = !input.runtimePlatformUnloadAttempted; + result.noRuntimePlatformSymbolResolution = !input.runtimePlatformSymbolResolutionAttempted; + result.noSdxlCalls = !input.sdxlCallRequested; + result.noBridgeCalls = !input.bridgeCallRequested; + result.noServerConnectivityChecked = !input.serverConnectivityCheckRequested; + result.noWalletLifecycle = !input.walletLifecycleRequested; + result.noSyncStarted = !input.syncRequested; + result.noSyncStatusPolled = !input.syncStatusPollingRequested; + result.noWorkerQueueEnqueue = !input.workerQueueRequested; + result.noWalletStateMutation = !input.walletStateMutationRequested; + result.noWalletPersistence = !input.walletPersistenceRequested; + result.noSettingsPersistence = !input.settingsWriteRequested; + result.noSendImportExportExecution = !input.sendImportExportRequested; + result.noArtifactMutation = !input.artifactMutationRequested; + + if (!result.noCallbackInvocationAttempted || + !result.noCallbackResultExecutionAttempted || + !result.noDispatchHandoffExecutionAttempted || + !result.noDispatchStatusPublicationAttempted || + !result.noDispatchConsumerConsumptionAttempted || + !result.noDispatchResultExecutionAttempted || + !result.noResultHandoffStatusPublicationAttempted || + !result.noReadinessProjectionStatusPublicationAttempted || + !result.noStatusHandoffPublicationAttempted || + !result.noPublicationGuardPublicationAttempted || + !result.noPublicationGuardResultHandoffPublicationAttempted || + !result.noRuntimePlatformDynamicLibraryLoaded || + !result.noRuntimePlatformDynamicLibraryUnloaded || + !result.noRuntimePlatformSymbolResolution) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff must stop before callback, dispatch result execution, status publication, readiness publication, publication guard result handoff publication, and platform loader APIs"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlockedSummary( + "publication_guard_result_handoff_or_platform_api_attempted"); + return result; + } + + if (!result.noSdxlCalls || + !result.noBridgeCalls || + !result.noServerConnectivityChecked || + !result.noWalletLifecycle || + !result.noSyncStarted || + !result.noSyncStatusPolled || + !result.noWorkerQueueEnqueue || + !result.noWalletStateMutation || + !result.noWalletPersistence || + !result.noSettingsPersistence || + !result.noSendImportExportExecution || + !result.noArtifactMutation) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff must not request wallet runtime behavior"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlockedSummary( + "runtime_action_requested"); + return result; + } + + if (result.platform.empty()) { + result.status = LiteBridgeRuntimeStatus::Unavailable; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff requires a target platform"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlockedSummary( + "platform_missing"); + return result; + } + + if (isMacosPlatform(result.platform)) { + result.macosDeferred = true; + result.status = LiteBridgeRuntimeStatus::Unavailable; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffIssue( + result, + input.macosDeferredByOperator + ? "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff is deferred by operator request" + : "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff requires a reviewed builder before promotion"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlockedSummary( + "macos_deferred"); + return result; + } + + const bool linuxPlatform = isLinuxPlatform(result.platform); + const bool windowsPlatform = isWindowsPlatform(result.platform); + if (!linuxPlatform && !windowsPlatform) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff supports only Linux and Windows in batch 30"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlockedSummary( + "unsupported_platform"); + return result; + } + + result.platformAccepted = true; + result.linuxPlatformAccepted = linuxPlatform; + result.windowsPlatformAccepted = windowsPlatform; + + const auto& publicationGuard = input.publicationGuard; + if (!input.publicationGuardAccepted || + !publicationGuard.ok || + !publicationGuard.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardReady || + publicationGuard.status != LiteBridgeRuntimeStatus::Ready || + publicationGuard.platform != result.platform || + !publicationGuard.statusHandoffAccepted || + !publicationGuard.publicationGuardRecordAccepted || + !publicationGuard.publicationGuardStatusHandoffMatchAccepted || + !publicationGuard.disabledPublicationGuardAccepted || + !publicationGuard.callbackInvocationRefused || + !publicationGuard.dispatchConsumptionStillGuarded || + !publicationGuard.dispatchResultExecutionBlocked || + !publicationGuard.dispatchStatusPublicationBlocked || + !publicationGuard.readinessProjectionPublicationBlocked || + !publicationGuard.statusHandoffPublicationBlocked || + !publicationGuard.publicationGuardPublicationBlocked || + !publicationGuard.platformApiPreInvocationBlocked || + !publicationGuard.disabledPublicationGuardStateAccepted || + !publicationGuard.publicationGuardFailureMappingAccepted || + !publicationGuard.unloadExecutionBlocked || + !publicationGuard.symbolResolutionBlocked || + !publicationGuard.productionLoaderDisabled || + !publicationGuard.realAdapterExecutionDisabled || + !publicationGuard.loadOnlyExecutionDisabled || + !publicationGuard.separateExecutionBatchRequired || + !publicationGuard.noCallbackInvocationAttempted || + !publicationGuard.noCallbackResultExecutionAttempted || + !publicationGuard.noDispatchHandoffExecutionAttempted || + !publicationGuard.noDispatchStatusPublicationAttempted || + !publicationGuard.noDispatchConsumerConsumptionAttempted || + !publicationGuard.noDispatchResultExecutionAttempted || + !publicationGuard.noResultHandoffStatusPublicationAttempted || + !publicationGuard.noReadinessProjectionStatusPublicationAttempted || + !publicationGuard.noStatusHandoffPublicationAttempted || + !publicationGuard.noPublicationGuardPublicationAttempted || + !publicationGuard.noRuntimePlatformDynamicLibraryLoaded || + !publicationGuard.noRuntimePlatformDynamicLibraryUnloaded || + !publicationGuard.noRuntimePlatformSymbolResolution) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff requires matching ready disabled publication-guard evidence"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlockedSummary( + "publication_guard_required"); + return result; + } + result.publicationGuardAccepted = true; + + if (!input.publicationGuardResultHandoffReviewed || + !input.publicationGuardResultHandoffRecorded || + !input.publicationGuardResultHandoffDisabled || + input.publicationGuardResultHandoffId.empty() || + input.publicationGuardResultConsumerName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff requires a reviewed disabled publication-guard result-handoff record"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlockedSummary( + "publication_guard_result_handoff_required"); + return result; + } + result.publicationGuardResultHandoffRecordAccepted = true; + + if (!input.publicationGuardResultHandoffOwnerMatchesPublicationGuard || + !input.publicationGuardResultHandoffBoundaryMatchesPublicationGuard || + !input.publicationGuardResultHandoffCallbackMatchesPublicationGuard || + !input.publicationGuardResultHandoffPreInvocationGuardMatchesPublicationGuard || + !input.publicationGuardResultHandoffRefusalResultMatchesPublicationGuard || + !input.publicationGuardResultHandoffPropagationMatchesPublicationGuard || + !input.publicationGuardResultHandoffDispatchHandoffMatchesPublicationGuard || + !input.publicationGuardResultHandoffStatusRecordMatchesPublicationGuard || + !input.publicationGuardResultHandoffConsumerReadinessMatchesPublicationGuard || + !input.publicationGuardResultHandoffConsumerNameMatchesPublicationGuard || + !input.publicationGuardResultHandoffDispatchConsumptionGuardMatchesPublicationGuard || + !input.publicationGuardResultHandoffDispatchConsumerNameMatchesPublicationGuard || + !input.publicationGuardResultHandoffResultHandoffMatchesPublicationGuard || + !input.publicationGuardResultHandoffResultConsumerNameMatchesPublicationGuard || + !input.publicationGuardResultHandoffReadinessProjectionMatchesPublicationGuard || + !input.publicationGuardResultHandoffReadinessConsumerNameMatchesPublicationGuard || + !input.publicationGuardResultHandoffStatusHandoffMatchesPublicationGuard || + !input.publicationGuardResultHandoffStatusConsumerNameMatchesPublicationGuard || + !input.publicationGuardResultHandoffPublicationGuardMatchesPublicationGuard || + !input.publicationGuardResultHandoffPublicationConsumerNameMatchesPublicationGuard || + result.ownerName != publicationGuard.ownerName || + result.handoffId != publicationGuard.handoffId || + result.loadCallbackBoundaryName != publicationGuard.loadCallbackBoundaryName || + result.callbackBindingId != publicationGuard.callbackBindingId || + result.callbackName != publicationGuard.callbackName || + result.guardId != publicationGuard.guardId || + result.refusalResultId != publicationGuard.refusalResultId || + result.propagationId != publicationGuard.propagationId || + result.dispatchHandoffId != publicationGuard.dispatchHandoffId || + result.statusRecordId != publicationGuard.statusRecordId || + result.consumerReadinessId != publicationGuard.consumerReadinessId || + result.consumerName != publicationGuard.consumerName || + result.dispatchConsumptionGuardId != publicationGuard.dispatchConsumptionGuardId || + result.dispatchConsumerName != publicationGuard.dispatchConsumerName || + result.resultHandoffId != publicationGuard.resultHandoffId || + result.resultConsumerName != publicationGuard.resultConsumerName || + result.readinessProjectionId != publicationGuard.readinessProjectionId || + result.readinessConsumerName != publicationGuard.readinessConsumerName || + result.statusHandoffId != publicationGuard.statusHandoffId || + result.statusConsumerName != publicationGuard.statusConsumerName || + result.publicationGuardId != publicationGuard.publicationGuardId || + result.publicationConsumerName != publicationGuard.publicationConsumerName || + result.adapterName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff requires result-handoff-to-publication-guard match evidence"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlockedSummary( + "publication_guard_result_handoff_publication_guard_match_required"); + return result; + } + result.publicationGuardResultHandoffPublicationGuardMatchAccepted = true; + + if (!input.disabledPublicationGuardResultHandoffRegistered || + !input.publicationGuardResultHandoffAcceptsPublicationGuardEvidence || + !input.publicationGuardResultHandoffReturnsDisabledResult || + !input.publicationGuardResultHandoffBlocksDispatchConsumption || + !input.publicationGuardResultHandoffBlocksDispatchResultExecution || + !input.publicationGuardResultHandoffBlocksStatusPublication || + !input.publicationGuardResultHandoffBlocksReadinessPublication || + !input.publicationGuardResultHandoffBlocksStatusHandoffPublication || + !input.publicationGuardResultHandoffBlocksPublicationGuardPublication) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff requires disabled result-handoff evidence"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlockedSummary( + "disabled_publication_guard_result_handoff_required"); + return result; + } + result.disabledPublicationGuardResultHandoffAccepted = true; + + if (!input.callbackInvocationStillDisabled || + !input.callbackInvocationRefused || + !input.callbackInvocationRefusalReviewed || + !input.publicationGuardResultHandoffStopsBeforeCallbackInvocation || + !input.publicationGuardResultHandoffStopsBeforeCallbackResultExecution || + !input.publicationGuardResultHandoffStopsBeforeDispatchConsumption || + !input.publicationGuardResultHandoffStopsBeforeDispatchResultExecution || + !input.publicationGuardResultHandoffStopsBeforeDispatchStatusPublication || + !input.publicationGuardResultHandoffStopsBeforeReadinessPublication || + !input.publicationGuardResultHandoffStopsBeforeStatusHandoffPublication || + !input.publicationGuardResultHandoffStopsBeforePublicationGuardPublication || + !input.publicationGuardResultHandoffStopsBeforeResultPublication || + !input.publicationGuardResultHandoffStopsBeforePlatformApi || + !input.publicationGuardResultHandoffRequiresSeparateExecutionBatch) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff must remain disabled before callback, dispatch result execution, status publication, readiness publication, result publication, and platform APIs"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlockedSummary( + "publication_guard_result_handoff_disabled_state_required"); + return result; + } + result.callbackInvocationRefused = true; + result.dispatchConsumptionStillGuarded = true; + result.dispatchResultExecutionBlocked = true; + result.dispatchStatusPublicationBlocked = true; + result.readinessProjectionPublicationBlocked = true; + result.statusHandoffPublicationBlocked = true; + result.publicationGuardPublicationBlocked = true; + result.publicationGuardResultHandoffPublicationBlocked = true; + result.platformApiPreInvocationBlocked = true; + + if (!input.publicationGuardResultHandoffProducesNoDynamicHandle || + !input.publicationGuardResultHandoffStoresNoDynamicHandle || + !input.publicationGuardResultHandoffReleasesNoDynamicHandle || + !input.publicationGuardResultHandoffResolvesNoSymbols || + !input.publicationGuardResultHandoffStoresNoSymbolTable || + !input.publicationGuardResultHandoffCreatesNoRuntime) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff must not create runtime loader state"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlockedSummary( + "publication_guard_result_handoff_runtime_state_required"); + return result; + } + result.disabledPublicationGuardResultHandoffStateAccepted = true; + + if (!input.publicationGuardResultHandoffFailureMappingReviewed) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff requires disabled result-handoff failure mapping review"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlockedSummary( + "publication_guard_result_handoff_failure_mapping_required"); + return result; + } + result.publicationGuardResultHandoffFailureMappingAccepted = true; + + if (!input.unloadExecutionStillDisabled || !input.symbolResolutionStillDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff must keep unload and symbol resolution disabled"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlockedSummary( + "non_load_execution_enabled"); + return result; + } + result.unloadExecutionBlocked = true; + result.symbolResolutionBlocked = true; + + if (!input.productionLoaderExecutionDisabled || + !input.realAdapterExecutionDisabled || + !input.loadOnlyExecutionDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff must keep real loader execution disabled"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlockedSummary( + "production_loader_enabled"); + return result; + } + result.productionLoaderDisabled = true; + result.realAdapterExecutionDisabled = true; + result.loadOnlyExecutionDisabled = true; + + if (!input.separateExecutionBatchRequired) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff requires a separate execution batch"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlockedSummary( + "separate_execution_batch_required"); + return result; + } + result.separateExecutionBatchRequired = true; + + result.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReady = true; + result.status = LiteBridgeRuntimeStatus::Ready; + result.ok = true; + result.summary = std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff=ready; platform=") + + result.platform + "; scope=load-only-disabled-callback-refusal-propagation-consumer-readiness-dispatch-consumption-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff; execution=disabled"; + return result; +} + +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionInput& input) +{ + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionResult result; + result.status = LiteBridgeRuntimeStatus::Configured; + result.platform = normalizedPlatform( + input.platform.empty() ? input.publicationGuardResultHandoff.platform : input.platform); + result.adapterName = input.adapterName.empty() + ? input.publicationGuardResultHandoff.adapterName + : input.adapterName; + result.ownerName = input.ownerName.empty() + ? input.publicationGuardResultHandoff.ownerName + : input.ownerName; + result.handoffId = input.handoffId.empty() + ? input.publicationGuardResultHandoff.handoffId + : input.handoffId; + result.loadCallbackBoundaryName = input.loadCallbackBoundaryName.empty() + ? input.publicationGuardResultHandoff.loadCallbackBoundaryName + : input.loadCallbackBoundaryName; + result.callbackBindingId = input.callbackBindingId.empty() + ? input.publicationGuardResultHandoff.callbackBindingId + : input.callbackBindingId; + result.callbackName = input.callbackName.empty() + ? input.publicationGuardResultHandoff.callbackName + : input.callbackName; + result.guardId = input.guardId.empty() + ? input.publicationGuardResultHandoff.guardId + : input.guardId; + result.refusalResultId = input.refusalResultId.empty() + ? input.publicationGuardResultHandoff.refusalResultId + : input.refusalResultId; + result.propagationId = input.propagationId.empty() + ? input.publicationGuardResultHandoff.propagationId + : input.propagationId; + result.dispatchHandoffId = input.dispatchHandoffId.empty() + ? input.publicationGuardResultHandoff.dispatchHandoffId + : input.dispatchHandoffId; + result.statusRecordId = input.statusRecordId.empty() + ? input.publicationGuardResultHandoff.statusRecordId + : input.statusRecordId; + result.consumerReadinessId = input.consumerReadinessId.empty() + ? input.publicationGuardResultHandoff.consumerReadinessId + : input.consumerReadinessId; + result.consumerName = input.consumerName.empty() + ? input.publicationGuardResultHandoff.consumerName + : input.consumerName; + result.dispatchConsumptionGuardId = input.dispatchConsumptionGuardId.empty() + ? input.publicationGuardResultHandoff.dispatchConsumptionGuardId + : input.dispatchConsumptionGuardId; + result.dispatchConsumerName = input.dispatchConsumerName.empty() + ? input.publicationGuardResultHandoff.dispatchConsumerName + : input.dispatchConsumerName; + result.resultHandoffId = input.resultHandoffId.empty() + ? input.publicationGuardResultHandoff.resultHandoffId + : input.resultHandoffId; + result.resultConsumerName = input.resultConsumerName.empty() + ? input.publicationGuardResultHandoff.resultConsumerName + : input.resultConsumerName; + result.readinessProjectionId = input.readinessProjectionId.empty() + ? input.publicationGuardResultHandoff.readinessProjectionId + : input.readinessProjectionId; + result.readinessConsumerName = input.readinessConsumerName.empty() + ? input.publicationGuardResultHandoff.readinessConsumerName + : input.readinessConsumerName; + result.statusHandoffId = input.statusHandoffId.empty() + ? input.publicationGuardResultHandoff.statusHandoffId + : input.statusHandoffId; + result.statusConsumerName = input.statusConsumerName.empty() + ? input.publicationGuardResultHandoff.statusConsumerName + : input.statusConsumerName; + result.publicationGuardId = input.publicationGuardId.empty() + ? input.publicationGuardResultHandoff.publicationGuardId + : input.publicationGuardId; + result.publicationConsumerName = input.publicationConsumerName.empty() + ? input.publicationGuardResultHandoff.publicationConsumerName + : input.publicationConsumerName; + result.publicationGuardResultHandoffId = input.publicationGuardResultHandoffId.empty() + ? input.publicationGuardResultHandoff.publicationGuardResultHandoffId + : input.publicationGuardResultHandoffId; + result.publicationGuardResultConsumerName = input.publicationGuardResultConsumerName.empty() + ? input.publicationGuardResultHandoff.publicationGuardResultConsumerName + : input.publicationGuardResultConsumerName; + result.publicationGuardResultHandoffReadinessProjectionId = input.publicationGuardResultHandoffReadinessProjectionId; + result.publicationGuardResultHandoffReadinessConsumerName = input.publicationGuardResultHandoffReadinessConsumerName; + + result.noCallbackInvocationAttempted = !input.callbackInvocationAttempted; + result.noCallbackResultExecutionAttempted = !input.callbackResultExecutionAttempted; + result.noDispatchHandoffExecutionAttempted = !input.dispatchHandoffExecutionAttempted; + result.noDispatchStatusPublicationAttempted = !input.dispatchStatusPublicationAttempted; + result.noDispatchConsumerConsumptionAttempted = !input.dispatchConsumerConsumptionAttempted; + result.noDispatchResultExecutionAttempted = !input.dispatchResultExecutionAttempted; + result.noResultHandoffStatusPublicationAttempted = !input.resultHandoffStatusPublicationAttempted; + result.noReadinessProjectionStatusPublicationAttempted = !input.readinessProjectionStatusPublicationAttempted; + result.noStatusHandoffPublicationAttempted = !input.statusHandoffPublicationAttempted; + result.noPublicationGuardPublicationAttempted = !input.publicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noRuntimePlatformDynamicLibraryLoaded = !input.runtimePlatformLoadAttempted; + result.noRuntimePlatformDynamicLibraryUnloaded = !input.runtimePlatformUnloadAttempted; + result.noRuntimePlatformSymbolResolution = !input.runtimePlatformSymbolResolutionAttempted; + result.noSdxlCalls = !input.sdxlCallRequested; + result.noBridgeCalls = !input.bridgeCallRequested; + result.noServerConnectivityChecked = !input.serverConnectivityCheckRequested; + result.noWalletLifecycle = !input.walletLifecycleRequested; + result.noSyncStarted = !input.syncRequested; + result.noSyncStatusPolled = !input.syncStatusPollingRequested; + result.noWorkerQueueEnqueue = !input.workerQueueRequested; + result.noWalletStateMutation = !input.walletStateMutationRequested; + result.noWalletPersistence = !input.walletPersistenceRequested; + result.noSettingsPersistence = !input.settingsWriteRequested; + result.noSendImportExportExecution = !input.sendImportExportRequested; + result.noArtifactMutation = !input.artifactMutationRequested; + + if (!result.noCallbackInvocationAttempted || + !result.noCallbackResultExecutionAttempted || + !result.noDispatchHandoffExecutionAttempted || + !result.noDispatchStatusPublicationAttempted || + !result.noDispatchConsumerConsumptionAttempted || + !result.noDispatchResultExecutionAttempted || + !result.noResultHandoffStatusPublicationAttempted || + !result.noReadinessProjectionStatusPublicationAttempted || + !result.noStatusHandoffPublicationAttempted || + !result.noPublicationGuardPublicationAttempted || + !result.noPublicationGuardResultHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !result.noRuntimePlatformDynamicLibraryLoaded || + !result.noRuntimePlatformDynamicLibraryUnloaded || + !result.noRuntimePlatformSymbolResolution) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection must stop before callback, dispatch result execution, status publication, readiness publication, readiness-projection publication, and platform loader APIs"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlockedSummary( + "publication_guard_result_handoff_readiness_projection_or_platform_api_attempted"); + return result; + } + + if (!result.noSdxlCalls || + !result.noBridgeCalls || + !result.noServerConnectivityChecked || + !result.noWalletLifecycle || + !result.noSyncStarted || + !result.noSyncStatusPolled || + !result.noWorkerQueueEnqueue || + !result.noWalletStateMutation || + !result.noWalletPersistence || + !result.noSettingsPersistence || + !result.noSendImportExportExecution || + !result.noArtifactMutation) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection must not request wallet runtime behavior"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlockedSummary( + "runtime_action_requested"); + return result; + } + + if (result.platform.empty()) { + result.status = LiteBridgeRuntimeStatus::Unavailable; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection requires a target platform"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlockedSummary( + "platform_missing"); + return result; + } + + if (isMacosPlatform(result.platform)) { + result.macosDeferred = true; + result.status = LiteBridgeRuntimeStatus::Unavailable; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionIssue( + result, + input.macosDeferredByOperator + ? "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection is deferred by operator request" + : "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection requires a reviewed builder before promotion"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlockedSummary( + "macos_deferred"); + return result; + } + + const bool linuxPlatform = isLinuxPlatform(result.platform); + const bool windowsPlatform = isWindowsPlatform(result.platform); + if (!linuxPlatform && !windowsPlatform) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection supports only Linux and Windows in batch 31"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlockedSummary( + "unsupported_platform"); + return result; + } + + result.platformAccepted = true; + result.linuxPlatformAccepted = linuxPlatform; + result.windowsPlatformAccepted = windowsPlatform; + + const auto& resultHandoff = input.publicationGuardResultHandoff; + if (!input.publicationGuardResultHandoffAccepted || + !resultHandoff.ok || + !resultHandoff.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReady || + resultHandoff.status != LiteBridgeRuntimeStatus::Ready || + resultHandoff.platform != result.platform || + !resultHandoff.publicationGuardAccepted || + !resultHandoff.publicationGuardResultHandoffRecordAccepted || + !resultHandoff.publicationGuardResultHandoffPublicationGuardMatchAccepted || + !resultHandoff.disabledPublicationGuardResultHandoffAccepted || + !resultHandoff.callbackInvocationRefused || + !resultHandoff.dispatchConsumptionStillGuarded || + !resultHandoff.dispatchResultExecutionBlocked || + !resultHandoff.dispatchStatusPublicationBlocked || + !resultHandoff.readinessProjectionPublicationBlocked || + !resultHandoff.statusHandoffPublicationBlocked || + !resultHandoff.publicationGuardPublicationBlocked || + !resultHandoff.publicationGuardResultHandoffPublicationBlocked || + !resultHandoff.platformApiPreInvocationBlocked || + !resultHandoff.disabledPublicationGuardResultHandoffStateAccepted || + !resultHandoff.publicationGuardResultHandoffFailureMappingAccepted || + !resultHandoff.unloadExecutionBlocked || + !resultHandoff.symbolResolutionBlocked || + !resultHandoff.productionLoaderDisabled || + !resultHandoff.realAdapterExecutionDisabled || + !resultHandoff.loadOnlyExecutionDisabled || + !resultHandoff.separateExecutionBatchRequired || + !resultHandoff.noCallbackInvocationAttempted || + !resultHandoff.noCallbackResultExecutionAttempted || + !resultHandoff.noDispatchHandoffExecutionAttempted || + !resultHandoff.noDispatchStatusPublicationAttempted || + !resultHandoff.noDispatchConsumerConsumptionAttempted || + !resultHandoff.noDispatchResultExecutionAttempted || + !resultHandoff.noResultHandoffStatusPublicationAttempted || + !resultHandoff.noReadinessProjectionStatusPublicationAttempted || + !resultHandoff.noStatusHandoffPublicationAttempted || + !resultHandoff.noPublicationGuardPublicationAttempted || + !resultHandoff.noPublicationGuardResultHandoffPublicationAttempted || + !resultHandoff.noRuntimePlatformDynamicLibraryLoaded || + !resultHandoff.noRuntimePlatformDynamicLibraryUnloaded || + !resultHandoff.noRuntimePlatformSymbolResolution) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection requires matching ready disabled publication-guard result-handoff evidence"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlockedSummary( + "publication_guard_result_handoff_required"); + return result; + } + result.publicationGuardResultHandoffAccepted = true; + + if (!input.publicationGuardResultHandoffReadinessProjectionReviewed || + !input.publicationGuardResultHandoffReadinessProjectionRecorded || + !input.publicationGuardResultHandoffReadinessProjectionDisabled || + input.publicationGuardResultHandoffReadinessProjectionId.empty() || + input.publicationGuardResultHandoffReadinessConsumerName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection requires a reviewed disabled readiness-projection record"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlockedSummary( + "publication_guard_result_handoff_readiness_projection_required"); + return result; + } + result.publicationGuardResultHandoffReadinessProjectionRecordAccepted = true; + + if (!input.projectionOwnerMatchesPublicationGuardResultHandoff || + !input.projectionBoundaryMatchesPublicationGuardResultHandoff || + !input.projectionCallbackMatchesPublicationGuardResultHandoff || + !input.projectionPreInvocationGuardMatchesPublicationGuardResultHandoff || + !input.projectionRefusalResultMatchesPublicationGuardResultHandoff || + !input.projectionPropagationMatchesPublicationGuardResultHandoff || + !input.projectionDispatchHandoffMatchesPublicationGuardResultHandoff || + !input.projectionStatusRecordMatchesPublicationGuardResultHandoff || + !input.projectionConsumerReadinessMatchesPublicationGuardResultHandoff || + !input.projectionConsumerNameMatchesPublicationGuardResultHandoff || + !input.projectionDispatchConsumptionGuardMatchesPublicationGuardResultHandoff || + !input.projectionDispatchConsumerNameMatchesPublicationGuardResultHandoff || + !input.projectionResultHandoffMatchesPublicationGuardResultHandoff || + !input.projectionResultConsumerNameMatchesPublicationGuardResultHandoff || + !input.projectionReadinessProjectionMatchesPublicationGuardResultHandoff || + !input.projectionReadinessConsumerNameMatchesPublicationGuardResultHandoff || + !input.projectionStatusHandoffMatchesPublicationGuardResultHandoff || + !input.projectionStatusConsumerNameMatchesPublicationGuardResultHandoff || + !input.projectionPublicationGuardMatchesPublicationGuardResultHandoff || + !input.projectionPublicationConsumerNameMatchesPublicationGuardResultHandoff || + !input.projectionPublicationGuardResultHandoffMatchesPublicationGuardResultHandoff || + !input.projectionPublicationGuardResultConsumerNameMatchesPublicationGuardResultHandoff || + result.ownerName != resultHandoff.ownerName || + result.handoffId != resultHandoff.handoffId || + result.loadCallbackBoundaryName != resultHandoff.loadCallbackBoundaryName || + result.callbackBindingId != resultHandoff.callbackBindingId || + result.callbackName != resultHandoff.callbackName || + result.guardId != resultHandoff.guardId || + result.refusalResultId != resultHandoff.refusalResultId || + result.propagationId != resultHandoff.propagationId || + result.dispatchHandoffId != resultHandoff.dispatchHandoffId || + result.statusRecordId != resultHandoff.statusRecordId || + result.consumerReadinessId != resultHandoff.consumerReadinessId || + result.consumerName != resultHandoff.consumerName || + result.dispatchConsumptionGuardId != resultHandoff.dispatchConsumptionGuardId || + result.dispatchConsumerName != resultHandoff.dispatchConsumerName || + result.resultHandoffId != resultHandoff.resultHandoffId || + result.resultConsumerName != resultHandoff.resultConsumerName || + result.readinessProjectionId != resultHandoff.readinessProjectionId || + result.readinessConsumerName != resultHandoff.readinessConsumerName || + result.statusHandoffId != resultHandoff.statusHandoffId || + result.statusConsumerName != resultHandoff.statusConsumerName || + result.publicationGuardId != resultHandoff.publicationGuardId || + result.publicationConsumerName != resultHandoff.publicationConsumerName || + result.publicationGuardResultHandoffId != resultHandoff.publicationGuardResultHandoffId || + result.publicationGuardResultConsumerName != resultHandoff.publicationGuardResultConsumerName || + result.adapterName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection requires readiness-projection-to-result-handoff match evidence"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlockedSummary( + "publication_guard_result_handoff_readiness_projection_match_required"); + return result; + } + result.projectionPublicationGuardResultHandoffMatchAccepted = true; + + if (!input.disabledPublicationGuardResultHandoffReadinessProjectionRegistered || + !input.publicationGuardResultHandoffReadinessProjectionAcceptsResultHandoffEvidence || + !input.publicationGuardResultHandoffReadinessProjectionReturnsDisabledReadiness || + !input.publicationGuardResultHandoffReadinessProjectionBlocksDispatchConsumption || + !input.publicationGuardResultHandoffReadinessProjectionBlocksDispatchResultExecution || + !input.publicationGuardResultHandoffReadinessProjectionBlocksStatusPublication || + !input.publicationGuardResultHandoffReadinessProjectionBlocksReadinessPublication || + !input.publicationGuardResultHandoffReadinessProjectionBlocksStatusHandoffPublication || + !input.publicationGuardResultHandoffReadinessProjectionBlocksPublicationGuardPublication || + !input.publicationGuardResultHandoffReadinessProjectionBlocksResultHandoffPublication) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection requires disabled readiness-projection evidence"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlockedSummary( + "disabled_publication_guard_result_handoff_readiness_projection_required"); + return result; + } + result.disabledPublicationGuardResultHandoffReadinessProjectionAccepted = true; + + if (!input.callbackInvocationStillDisabled || + !input.callbackInvocationRefused || + !input.callbackInvocationRefusalReviewed || + !input.projectionStopsBeforeCallbackInvocation || + !input.projectionStopsBeforeCallbackResultExecution || + !input.projectionStopsBeforeDispatchConsumption || + !input.projectionStopsBeforeDispatchResultExecution || + !input.projectionStopsBeforeDispatchStatusPublication || + !input.projectionStopsBeforeReadinessPublication || + !input.projectionStopsBeforeStatusHandoffPublication || + !input.projectionStopsBeforePublicationGuardPublication || + !input.projectionStopsBeforePublicationGuardResultHandoffPublication || + !input.projectionStopsBeforeReadinessProjectionPublication || + !input.projectionStopsBeforePlatformApi || + !input.projectionRequiresSeparateExecutionBatch) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection must remain disabled before callback, dispatch result execution, status publication, readiness publication, result-handoff publication, readiness projection publication, and platform APIs"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlockedSummary( + "publication_guard_result_handoff_readiness_projection_disabled_state_required"); + return result; + } + result.callbackInvocationRefused = true; + result.dispatchConsumptionStillGuarded = true; + result.dispatchResultExecutionBlocked = true; + result.dispatchStatusPublicationBlocked = true; + result.readinessProjectionPublicationBlocked = true; + result.statusHandoffPublicationBlocked = true; + result.publicationGuardPublicationBlocked = true; + result.publicationGuardResultHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionPublicationBlocked = true; + result.platformApiPreInvocationBlocked = true; + + if (!input.projectionProducesNoDynamicHandle || + !input.projectionStoresNoDynamicHandle || + !input.projectionReleasesNoDynamicHandle || + !input.projectionResolvesNoSymbols || + !input.projectionStoresNoSymbolTable || + !input.projectionCreatesNoRuntime) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection must not create runtime loader state"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlockedSummary( + "publication_guard_result_handoff_readiness_projection_runtime_state_required"); + return result; + } + result.disabledPublicationGuardResultHandoffReadinessProjectionStateAccepted = true; + + if (!input.publicationGuardResultHandoffReadinessProjectionFailureMappingReviewed) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection requires disabled readiness-projection failure mapping review"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlockedSummary( + "publication_guard_result_handoff_readiness_projection_failure_mapping_required"); + return result; + } + result.publicationGuardResultHandoffReadinessProjectionFailureMappingAccepted = true; + + if (!input.unloadExecutionStillDisabled || !input.symbolResolutionStillDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection must keep unload and symbol resolution disabled"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlockedSummary( + "non_load_execution_enabled"); + return result; + } + result.unloadExecutionBlocked = true; + result.symbolResolutionBlocked = true; + + if (!input.productionLoaderExecutionDisabled || + !input.realAdapterExecutionDisabled || + !input.loadOnlyExecutionDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection must keep real loader execution disabled"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlockedSummary( + "production_loader_enabled"); + return result; + } + result.productionLoaderDisabled = true; + result.realAdapterExecutionDisabled = true; + result.loadOnlyExecutionDisabled = true; + + if (!input.separateExecutionBatchRequired) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection requires a separate execution batch"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlockedSummary( + "separate_execution_batch_required"); + return result; + } + result.separateExecutionBatchRequired = true; + + result.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionReady = true; + result.status = LiteBridgeRuntimeStatus::Ready; + result.ok = true; + result.summary = std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection=ready; platform=") + + result.platform + "; scope=load-only-disabled-callback-refusal-propagation-consumer-readiness-dispatch-consumption-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection; execution=disabled"; + return result; +} + +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffInput& input) +{ + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffResult result; + result.status = LiteBridgeRuntimeStatus::Configured; + result.platform = normalizedPlatform( + input.platform.empty() ? input.publicationGuardResultHandoffReadinessProjection.platform : input.platform); + result.adapterName = input.adapterName.empty() + ? input.publicationGuardResultHandoffReadinessProjection.adapterName + : input.adapterName; + result.ownerName = input.ownerName.empty() + ? input.publicationGuardResultHandoffReadinessProjection.ownerName + : input.ownerName; + result.handoffId = input.handoffId.empty() + ? input.publicationGuardResultHandoffReadinessProjection.handoffId + : input.handoffId; + result.loadCallbackBoundaryName = input.loadCallbackBoundaryName.empty() + ? input.publicationGuardResultHandoffReadinessProjection.loadCallbackBoundaryName + : input.loadCallbackBoundaryName; + result.callbackBindingId = input.callbackBindingId.empty() + ? input.publicationGuardResultHandoffReadinessProjection.callbackBindingId + : input.callbackBindingId; + result.callbackName = input.callbackName.empty() + ? input.publicationGuardResultHandoffReadinessProjection.callbackName + : input.callbackName; + result.guardId = input.guardId.empty() + ? input.publicationGuardResultHandoffReadinessProjection.guardId + : input.guardId; + result.refusalResultId = input.refusalResultId.empty() + ? input.publicationGuardResultHandoffReadinessProjection.refusalResultId + : input.refusalResultId; + result.propagationId = input.propagationId.empty() + ? input.publicationGuardResultHandoffReadinessProjection.propagationId + : input.propagationId; + result.dispatchHandoffId = input.dispatchHandoffId.empty() + ? input.publicationGuardResultHandoffReadinessProjection.dispatchHandoffId + : input.dispatchHandoffId; + result.statusRecordId = input.statusRecordId.empty() + ? input.publicationGuardResultHandoffReadinessProjection.statusRecordId + : input.statusRecordId; + result.consumerReadinessId = input.consumerReadinessId.empty() + ? input.publicationGuardResultHandoffReadinessProjection.consumerReadinessId + : input.consumerReadinessId; + result.consumerName = input.consumerName.empty() + ? input.publicationGuardResultHandoffReadinessProjection.consumerName + : input.consumerName; + result.dispatchConsumptionGuardId = input.dispatchConsumptionGuardId.empty() + ? input.publicationGuardResultHandoffReadinessProjection.dispatchConsumptionGuardId + : input.dispatchConsumptionGuardId; + result.dispatchConsumerName = input.dispatchConsumerName.empty() + ? input.publicationGuardResultHandoffReadinessProjection.dispatchConsumerName + : input.dispatchConsumerName; + result.resultHandoffId = input.resultHandoffId.empty() + ? input.publicationGuardResultHandoffReadinessProjection.resultHandoffId + : input.resultHandoffId; + result.resultConsumerName = input.resultConsumerName.empty() + ? input.publicationGuardResultHandoffReadinessProjection.resultConsumerName + : input.resultConsumerName; + result.readinessProjectionId = input.readinessProjectionId.empty() + ? input.publicationGuardResultHandoffReadinessProjection.readinessProjectionId + : input.readinessProjectionId; + result.readinessConsumerName = input.readinessConsumerName.empty() + ? input.publicationGuardResultHandoffReadinessProjection.readinessConsumerName + : input.readinessConsumerName; + result.statusHandoffId = input.statusHandoffId.empty() + ? input.publicationGuardResultHandoffReadinessProjection.statusHandoffId + : input.statusHandoffId; + result.statusConsumerName = input.statusConsumerName.empty() + ? input.publicationGuardResultHandoffReadinessProjection.statusConsumerName + : input.statusConsumerName; + result.publicationGuardId = input.publicationGuardId.empty() + ? input.publicationGuardResultHandoffReadinessProjection.publicationGuardId + : input.publicationGuardId; + result.publicationConsumerName = input.publicationConsumerName.empty() + ? input.publicationGuardResultHandoffReadinessProjection.publicationConsumerName + : input.publicationConsumerName; + result.publicationGuardResultHandoffId = input.publicationGuardResultHandoffId.empty() + ? input.publicationGuardResultHandoffReadinessProjection.publicationGuardResultHandoffId + : input.publicationGuardResultHandoffId; + result.publicationGuardResultConsumerName = input.publicationGuardResultConsumerName.empty() + ? input.publicationGuardResultHandoffReadinessProjection.publicationGuardResultConsumerName + : input.publicationGuardResultConsumerName; + result.publicationGuardResultHandoffReadinessProjectionId = input.publicationGuardResultHandoffReadinessProjectionId.empty() + ? input.publicationGuardResultHandoffReadinessProjection.publicationGuardResultHandoffReadinessProjectionId + : input.publicationGuardResultHandoffReadinessProjectionId; + result.publicationGuardResultHandoffReadinessConsumerName = input.publicationGuardResultHandoffReadinessConsumerName.empty() + ? input.publicationGuardResultHandoffReadinessProjection.publicationGuardResultHandoffReadinessConsumerName + : input.publicationGuardResultHandoffReadinessConsumerName; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffId = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffId; + result.publicationGuardResultHandoffReadinessProjectionStatusConsumerName = input.publicationGuardResultHandoffReadinessProjectionStatusConsumerName; + + result.noCallbackInvocationAttempted = !input.callbackInvocationAttempted; + result.noCallbackResultExecutionAttempted = !input.callbackResultExecutionAttempted; + result.noDispatchHandoffExecutionAttempted = !input.dispatchHandoffExecutionAttempted; + result.noDispatchStatusPublicationAttempted = !input.dispatchStatusPublicationAttempted; + result.noDispatchConsumerConsumptionAttempted = !input.dispatchConsumerConsumptionAttempted; + result.noDispatchResultExecutionAttempted = !input.dispatchResultExecutionAttempted; + result.noResultHandoffStatusPublicationAttempted = !input.resultHandoffStatusPublicationAttempted; + result.noReadinessProjectionStatusPublicationAttempted = !input.readinessProjectionStatusPublicationAttempted; + result.noStatusHandoffPublicationAttempted = !input.statusHandoffPublicationAttempted; + result.noPublicationGuardPublicationAttempted = !input.publicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noRuntimePlatformDynamicLibraryLoaded = !input.runtimePlatformLoadAttempted; + result.noRuntimePlatformDynamicLibraryUnloaded = !input.runtimePlatformUnloadAttempted; + result.noRuntimePlatformSymbolResolution = !input.runtimePlatformSymbolResolutionAttempted; + result.noSdxlCalls = !input.sdxlCallRequested; + result.noBridgeCalls = !input.bridgeCallRequested; + result.noServerConnectivityChecked = !input.serverConnectivityCheckRequested; + result.noWalletLifecycle = !input.walletLifecycleRequested; + result.noSyncStarted = !input.syncRequested; + result.noSyncStatusPolled = !input.syncStatusPollingRequested; + result.noWorkerQueueEnqueue = !input.workerQueueRequested; + result.noWalletStateMutation = !input.walletStateMutationRequested; + result.noWalletPersistence = !input.walletPersistenceRequested; + result.noSettingsPersistence = !input.settingsWriteRequested; + result.noSendImportExportExecution = !input.sendImportExportRequested; + result.noArtifactMutation = !input.artifactMutationRequested; + + if (!result.noCallbackInvocationAttempted || + !result.noCallbackResultExecutionAttempted || + !result.noDispatchHandoffExecutionAttempted || + !result.noDispatchStatusPublicationAttempted || + !result.noDispatchConsumerConsumptionAttempted || + !result.noDispatchResultExecutionAttempted || + !result.noResultHandoffStatusPublicationAttempted || + !result.noReadinessProjectionStatusPublicationAttempted || + !result.noStatusHandoffPublicationAttempted || + !result.noPublicationGuardPublicationAttempted || + !result.noPublicationGuardResultHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !result.noRuntimePlatformDynamicLibraryLoaded || + !result.noRuntimePlatformDynamicLibraryUnloaded || + !result.noRuntimePlatformSymbolResolution) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff must stop before callback, dispatch result execution, status publication, readiness publication, status-handoff publication, and platform loader APIs"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_or_platform_api_attempted"); + return result; + } + + if (!result.noSdxlCalls || + !result.noBridgeCalls || + !result.noServerConnectivityChecked || + !result.noWalletLifecycle || + !result.noSyncStarted || + !result.noSyncStatusPolled || + !result.noWorkerQueueEnqueue || + !result.noWalletStateMutation || + !result.noWalletPersistence || + !result.noSettingsPersistence || + !result.noSendImportExportExecution || + !result.noArtifactMutation) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff must not request wallet runtime behavior"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary( + "runtime_action_requested"); + return result; + } + + if (result.platform.empty()) { + result.status = LiteBridgeRuntimeStatus::Unavailable; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff requires a target platform"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary( + "platform_missing"); + return result; + } + + if (isMacosPlatform(result.platform)) { + result.macosDeferred = true; + result.status = LiteBridgeRuntimeStatus::Unavailable; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffIssue( + result, + input.macosDeferredByOperator + ? "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff is deferred by operator request" + : "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff requires a reviewed builder before promotion"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary( + "macos_deferred"); + return result; + } + + const bool linuxPlatform = isLinuxPlatform(result.platform); + const bool windowsPlatform = isWindowsPlatform(result.platform); + if (!linuxPlatform && !windowsPlatform) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff supports only Linux and Windows in batch 32"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary( + "unsupported_platform"); + return result; + } + + result.platformAccepted = true; + result.linuxPlatformAccepted = linuxPlatform; + result.windowsPlatformAccepted = windowsPlatform; + + const auto& readinessProjection = input.publicationGuardResultHandoffReadinessProjection; + if (!input.publicationGuardResultHandoffReadinessProjectionAccepted || + !readinessProjection.ok || + !readinessProjection.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionReady || + readinessProjection.status != LiteBridgeRuntimeStatus::Ready || + readinessProjection.platform != result.platform || + !readinessProjection.publicationGuardResultHandoffAccepted || + !readinessProjection.publicationGuardResultHandoffReadinessProjectionRecordAccepted || + !readinessProjection.projectionPublicationGuardResultHandoffMatchAccepted || + !readinessProjection.disabledPublicationGuardResultHandoffReadinessProjectionAccepted || + !readinessProjection.callbackInvocationRefused || + !readinessProjection.dispatchConsumptionStillGuarded || + !readinessProjection.dispatchResultExecutionBlocked || + !readinessProjection.dispatchStatusPublicationBlocked || + !readinessProjection.readinessProjectionPublicationBlocked || + !readinessProjection.statusHandoffPublicationBlocked || + !readinessProjection.publicationGuardPublicationBlocked || + !readinessProjection.publicationGuardResultHandoffPublicationBlocked || + !readinessProjection.publicationGuardResultHandoffReadinessProjectionPublicationBlocked || + !readinessProjection.platformApiPreInvocationBlocked || + !readinessProjection.disabledPublicationGuardResultHandoffReadinessProjectionStateAccepted || + !readinessProjection.publicationGuardResultHandoffReadinessProjectionFailureMappingAccepted || + !readinessProjection.unloadExecutionBlocked || + !readinessProjection.symbolResolutionBlocked || + !readinessProjection.productionLoaderDisabled || + !readinessProjection.realAdapterExecutionDisabled || + !readinessProjection.loadOnlyExecutionDisabled || + !readinessProjection.separateExecutionBatchRequired || + !readinessProjection.noCallbackInvocationAttempted || + !readinessProjection.noCallbackResultExecutionAttempted || + !readinessProjection.noDispatchHandoffExecutionAttempted || + !readinessProjection.noDispatchStatusPublicationAttempted || + !readinessProjection.noDispatchConsumerConsumptionAttempted || + !readinessProjection.noDispatchResultExecutionAttempted || + !readinessProjection.noResultHandoffStatusPublicationAttempted || + !readinessProjection.noReadinessProjectionStatusPublicationAttempted || + !readinessProjection.noStatusHandoffPublicationAttempted || + !readinessProjection.noPublicationGuardPublicationAttempted || + !readinessProjection.noPublicationGuardResultHandoffPublicationAttempted || + !readinessProjection.noPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !readinessProjection.noRuntimePlatformDynamicLibraryLoaded || + !readinessProjection.noRuntimePlatformDynamicLibraryUnloaded || + !readinessProjection.noRuntimePlatformSymbolResolution) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff requires matching ready disabled publication-guard result-handoff readiness-projection evidence"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_required"); + return result; + } + result.publicationGuardResultHandoffReadinessProjectionAccepted = true; + + if (!input.publicationGuardResultHandoffReadinessProjectionStatusHandoffReviewed || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffRecorded || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffDisabled || + input.publicationGuardResultHandoffReadinessProjectionStatusHandoffId.empty() || + input.publicationGuardResultHandoffReadinessProjectionStatusConsumerName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff requires a reviewed disabled status-handoff record"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_required"); + return result; + } + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffRecordAccepted = true; + + if (!input.statusHandoffOwnerMatchesPublicationGuardResultHandoffReadinessProjection || + !input.statusHandoffBoundaryMatchesPublicationGuardResultHandoffReadinessProjection || + !input.statusHandoffCallbackMatchesPublicationGuardResultHandoffReadinessProjection || + !input.statusHandoffPreInvocationGuardMatchesPublicationGuardResultHandoffReadinessProjection || + !input.statusHandoffRefusalResultMatchesPublicationGuardResultHandoffReadinessProjection || + !input.statusHandoffPropagationMatchesPublicationGuardResultHandoffReadinessProjection || + !input.statusHandoffDispatchHandoffMatchesPublicationGuardResultHandoffReadinessProjection || + !input.statusHandoffStatusRecordMatchesPublicationGuardResultHandoffReadinessProjection || + !input.statusHandoffConsumerReadinessMatchesPublicationGuardResultHandoffReadinessProjection || + !input.statusHandoffConsumerNameMatchesPublicationGuardResultHandoffReadinessProjection || + !input.statusHandoffDispatchConsumptionGuardMatchesPublicationGuardResultHandoffReadinessProjection || + !input.statusHandoffDispatchConsumerNameMatchesPublicationGuardResultHandoffReadinessProjection || + !input.statusHandoffResultHandoffMatchesPublicationGuardResultHandoffReadinessProjection || + !input.statusHandoffResultConsumerNameMatchesPublicationGuardResultHandoffReadinessProjection || + !input.statusHandoffReadinessProjectionMatchesPublicationGuardResultHandoffReadinessProjection || + !input.statusHandoffReadinessConsumerNameMatchesPublicationGuardResultHandoffReadinessProjection || + !input.statusHandoffStatusHandoffMatchesPublicationGuardResultHandoffReadinessProjection || + !input.statusHandoffStatusConsumerNameMatchesPublicationGuardResultHandoffReadinessProjection || + !input.statusHandoffPublicationGuardMatchesPublicationGuardResultHandoffReadinessProjection || + !input.statusHandoffPublicationConsumerNameMatchesPublicationGuardResultHandoffReadinessProjection || + !input.statusHandoffPublicationGuardResultHandoffMatchesPublicationGuardResultHandoffReadinessProjection || + !input.statusHandoffPublicationGuardResultConsumerNameMatchesPublicationGuardResultHandoffReadinessProjection || + !input.statusHandoffPublicationGuardResultHandoffReadinessProjectionMatchesPublicationGuardResultHandoffReadinessProjection || + !input.statusHandoffPublicationGuardResultHandoffReadinessConsumerNameMatchesPublicationGuardResultHandoffReadinessProjection || + result.ownerName != readinessProjection.ownerName || + result.handoffId != readinessProjection.handoffId || + result.loadCallbackBoundaryName != readinessProjection.loadCallbackBoundaryName || + result.callbackBindingId != readinessProjection.callbackBindingId || + result.callbackName != readinessProjection.callbackName || + result.guardId != readinessProjection.guardId || + result.refusalResultId != readinessProjection.refusalResultId || + result.propagationId != readinessProjection.propagationId || + result.dispatchHandoffId != readinessProjection.dispatchHandoffId || + result.statusRecordId != readinessProjection.statusRecordId || + result.consumerReadinessId != readinessProjection.consumerReadinessId || + result.consumerName != readinessProjection.consumerName || + result.dispatchConsumptionGuardId != readinessProjection.dispatchConsumptionGuardId || + result.dispatchConsumerName != readinessProjection.dispatchConsumerName || + result.resultHandoffId != readinessProjection.resultHandoffId || + result.resultConsumerName != readinessProjection.resultConsumerName || + result.readinessProjectionId != readinessProjection.readinessProjectionId || + result.readinessConsumerName != readinessProjection.readinessConsumerName || + result.statusHandoffId != readinessProjection.statusHandoffId || + result.statusConsumerName != readinessProjection.statusConsumerName || + result.publicationGuardId != readinessProjection.publicationGuardId || + result.publicationConsumerName != readinessProjection.publicationConsumerName || + result.publicationGuardResultHandoffId != readinessProjection.publicationGuardResultHandoffId || + result.publicationGuardResultConsumerName != readinessProjection.publicationGuardResultConsumerName || + result.publicationGuardResultHandoffReadinessProjectionId != readinessProjection.publicationGuardResultHandoffReadinessProjectionId || + result.publicationGuardResultHandoffReadinessConsumerName != readinessProjection.publicationGuardResultHandoffReadinessConsumerName || + result.adapterName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff requires status-handoff-to-readiness-projection match evidence"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_match_required"); + return result; + } + result.statusHandoffPublicationGuardResultHandoffReadinessProjectionMatchAccepted = true; + + if (!input.disabledPublicationGuardResultHandoffReadinessProjectionStatusHandoffRegistered || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffAcceptsReadinessProjectionEvidence || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffReturnsDisabledStatus || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffBlocksDispatchConsumption || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffBlocksDispatchResultExecution || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffBlocksStatusPublication || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffBlocksReadinessPublication || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffBlocksStatusHandoffPublication || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffBlocksPublicationGuardPublication || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffBlocksResultHandoffPublication || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffBlocksReadinessProjectionPublication) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff requires disabled status-handoff evidence"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary( + "disabled_publication_guard_result_handoff_readiness_projection_status_handoff_required"); + return result; + } + result.disabledPublicationGuardResultHandoffReadinessProjectionStatusHandoffAccepted = true; + + if (!input.callbackInvocationStillDisabled || + !input.callbackInvocationRefused || + !input.callbackInvocationRefusalReviewed || + !input.statusHandoffStopsBeforeCallbackInvocation || + !input.statusHandoffStopsBeforeCallbackResultExecution || + !input.statusHandoffStopsBeforeDispatchConsumption || + !input.statusHandoffStopsBeforeDispatchResultExecution || + !input.statusHandoffStopsBeforeDispatchStatusPublication || + !input.statusHandoffStopsBeforeReadinessPublication || + !input.statusHandoffStopsBeforeStatusHandoffPublication || + !input.statusHandoffStopsBeforePublicationGuardPublication || + !input.statusHandoffStopsBeforePublicationGuardResultHandoffPublication || + !input.statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionPublication || + !input.statusHandoffStopsBeforeStatusPublication || + !input.statusHandoffStopsBeforePlatformApi || + !input.statusHandoffRequiresSeparateExecutionBatch) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff must remain disabled before callback, dispatch result execution, status publication, readiness publication, status-handoff publication, readiness-projection publication, and platform APIs"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_disabled_state_required"); + return result; + } + result.callbackInvocationRefused = true; + result.dispatchConsumptionStillGuarded = true; + result.dispatchResultExecutionBlocked = true; + result.dispatchStatusPublicationBlocked = true; + result.readinessProjectionPublicationBlocked = true; + result.statusHandoffPublicationBlocked = true; + result.publicationGuardPublicationBlocked = true; + result.publicationGuardResultHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked = true; + result.platformApiPreInvocationBlocked = true; + + if (!input.statusHandoffProducesNoDynamicHandle || + !input.statusHandoffStoresNoDynamicHandle || + !input.statusHandoffReleasesNoDynamicHandle || + !input.statusHandoffResolvesNoSymbols || + !input.statusHandoffStoresNoSymbolTable || + !input.statusHandoffCreatesNoRuntime) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff must not create runtime loader state"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_runtime_state_required"); + return result; + } + result.disabledPublicationGuardResultHandoffReadinessProjectionStatusHandoffStateAccepted = true; + + if (!input.publicationGuardResultHandoffReadinessProjectionStatusHandoffFailureMappingReviewed) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff requires disabled status-handoff failure mapping review"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_failure_mapping_required"); + return result; + } + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffFailureMappingAccepted = true; + + if (!input.unloadExecutionStillDisabled || !input.symbolResolutionStillDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff must keep unload and symbol resolution disabled"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary( + "non_load_execution_enabled"); + return result; + } + result.unloadExecutionBlocked = true; + result.symbolResolutionBlocked = true; + + if (!input.productionLoaderExecutionDisabled || + !input.realAdapterExecutionDisabled || + !input.loadOnlyExecutionDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff must keep real loader execution disabled"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary( + "production_loader_enabled"); + return result; + } + result.productionLoaderDisabled = true; + result.realAdapterExecutionDisabled = true; + result.loadOnlyExecutionDisabled = true; + + if (!input.separateExecutionBatchRequired) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff requires a separate execution batch"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary( + "separate_execution_batch_required"); + return result; + } + result.separateExecutionBatchRequired = true; + + result.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffReady = true; + result.status = LiteBridgeRuntimeStatus::Ready; + result.ok = true; + result.summary = std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff=ready; platform=") + + result.platform + "; scope=load-only-disabled-callback-refusal-propagation-consumer-readiness-dispatch-consumption-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff; execution=disabled"; + return result; +} + +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardInput& input) +{ + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResult result; + result.status = LiteBridgeRuntimeStatus::Configured; + result.platform = normalizedPlatform( + input.platform.empty() ? input.publicationGuardResultHandoffReadinessProjectionStatusHandoff.platform : input.platform); + result.adapterName = input.adapterName.empty() + ? input.publicationGuardResultHandoffReadinessProjectionStatusHandoff.adapterName + : input.adapterName; + result.ownerName = input.ownerName.empty() + ? input.publicationGuardResultHandoffReadinessProjectionStatusHandoff.ownerName + : input.ownerName; + result.handoffId = input.handoffId.empty() + ? input.publicationGuardResultHandoffReadinessProjectionStatusHandoff.handoffId + : input.handoffId; + result.loadCallbackBoundaryName = input.loadCallbackBoundaryName.empty() + ? input.publicationGuardResultHandoffReadinessProjectionStatusHandoff.loadCallbackBoundaryName + : input.loadCallbackBoundaryName; + result.callbackBindingId = input.callbackBindingId.empty() + ? input.publicationGuardResultHandoffReadinessProjectionStatusHandoff.callbackBindingId + : input.callbackBindingId; + result.callbackName = input.callbackName.empty() + ? input.publicationGuardResultHandoffReadinessProjectionStatusHandoff.callbackName + : input.callbackName; + result.guardId = input.guardId.empty() + ? input.publicationGuardResultHandoffReadinessProjectionStatusHandoff.guardId + : input.guardId; + result.refusalResultId = input.refusalResultId.empty() + ? input.publicationGuardResultHandoffReadinessProjectionStatusHandoff.refusalResultId + : input.refusalResultId; + result.propagationId = input.propagationId.empty() + ? input.publicationGuardResultHandoffReadinessProjectionStatusHandoff.propagationId + : input.propagationId; + result.dispatchHandoffId = input.dispatchHandoffId.empty() + ? input.publicationGuardResultHandoffReadinessProjectionStatusHandoff.dispatchHandoffId + : input.dispatchHandoffId; + result.statusRecordId = input.statusRecordId.empty() + ? input.publicationGuardResultHandoffReadinessProjectionStatusHandoff.statusRecordId + : input.statusRecordId; + result.consumerReadinessId = input.consumerReadinessId.empty() + ? input.publicationGuardResultHandoffReadinessProjectionStatusHandoff.consumerReadinessId + : input.consumerReadinessId; + result.consumerName = input.consumerName.empty() + ? input.publicationGuardResultHandoffReadinessProjectionStatusHandoff.consumerName + : input.consumerName; + result.dispatchConsumptionGuardId = input.dispatchConsumptionGuardId.empty() + ? input.publicationGuardResultHandoffReadinessProjectionStatusHandoff.dispatchConsumptionGuardId + : input.dispatchConsumptionGuardId; + result.dispatchConsumerName = input.dispatchConsumerName.empty() + ? input.publicationGuardResultHandoffReadinessProjectionStatusHandoff.dispatchConsumerName + : input.dispatchConsumerName; + result.resultHandoffId = input.resultHandoffId.empty() + ? input.publicationGuardResultHandoffReadinessProjectionStatusHandoff.resultHandoffId + : input.resultHandoffId; + result.resultConsumerName = input.resultConsumerName.empty() + ? input.publicationGuardResultHandoffReadinessProjectionStatusHandoff.resultConsumerName + : input.resultConsumerName; + result.readinessProjectionId = input.readinessProjectionId.empty() + ? input.publicationGuardResultHandoffReadinessProjectionStatusHandoff.readinessProjectionId + : input.readinessProjectionId; + result.readinessConsumerName = input.readinessConsumerName.empty() + ? input.publicationGuardResultHandoffReadinessProjectionStatusHandoff.readinessConsumerName + : input.readinessConsumerName; + result.statusHandoffId = input.statusHandoffId.empty() + ? input.publicationGuardResultHandoffReadinessProjectionStatusHandoff.statusHandoffId + : input.statusHandoffId; + result.statusConsumerName = input.statusConsumerName.empty() + ? input.publicationGuardResultHandoffReadinessProjectionStatusHandoff.statusConsumerName + : input.statusConsumerName; + result.publicationGuardId = input.publicationGuardId.empty() + ? input.publicationGuardResultHandoffReadinessProjectionStatusHandoff.publicationGuardId + : input.publicationGuardId; + result.publicationConsumerName = input.publicationConsumerName.empty() + ? input.publicationGuardResultHandoffReadinessProjectionStatusHandoff.publicationConsumerName + : input.publicationConsumerName; + result.publicationGuardResultHandoffId = input.publicationGuardResultHandoffId.empty() + ? input.publicationGuardResultHandoffReadinessProjectionStatusHandoff.publicationGuardResultHandoffId + : input.publicationGuardResultHandoffId; + result.publicationGuardResultConsumerName = input.publicationGuardResultConsumerName.empty() + ? input.publicationGuardResultHandoffReadinessProjectionStatusHandoff.publicationGuardResultConsumerName + : input.publicationGuardResultConsumerName; + result.publicationGuardResultHandoffReadinessProjectionId = input.publicationGuardResultHandoffReadinessProjectionId.empty() + ? input.publicationGuardResultHandoffReadinessProjectionStatusHandoff.publicationGuardResultHandoffReadinessProjectionId + : input.publicationGuardResultHandoffReadinessProjectionId; + result.publicationGuardResultHandoffReadinessConsumerName = input.publicationGuardResultHandoffReadinessConsumerName.empty() + ? input.publicationGuardResultHandoffReadinessProjectionStatusHandoff.publicationGuardResultHandoffReadinessConsumerName + : input.publicationGuardResultHandoffReadinessConsumerName; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffId = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffId.empty() + ? input.publicationGuardResultHandoffReadinessProjectionStatusHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffId + : input.publicationGuardResultHandoffReadinessProjectionStatusHandoffId; + result.publicationGuardResultHandoffReadinessProjectionStatusConsumerName = input.publicationGuardResultHandoffReadinessProjectionStatusConsumerName.empty() + ? input.publicationGuardResultHandoffReadinessProjectionStatusHandoff.publicationGuardResultHandoffReadinessProjectionStatusConsumerName + : input.publicationGuardResultHandoffReadinessProjectionStatusConsumerName; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName; + + result.noCallbackInvocationAttempted = !input.callbackInvocationAttempted; + result.noCallbackResultExecutionAttempted = !input.callbackResultExecutionAttempted; + result.noDispatchHandoffExecutionAttempted = !input.dispatchHandoffExecutionAttempted; + result.noDispatchStatusPublicationAttempted = !input.dispatchStatusPublicationAttempted; + result.noDispatchConsumerConsumptionAttempted = !input.dispatchConsumerConsumptionAttempted; + result.noDispatchResultExecutionAttempted = !input.dispatchResultExecutionAttempted; + result.noResultHandoffStatusPublicationAttempted = !input.resultHandoffStatusPublicationAttempted; + result.noReadinessProjectionStatusPublicationAttempted = !input.readinessProjectionStatusPublicationAttempted; + result.noStatusHandoffPublicationAttempted = !input.statusHandoffPublicationAttempted; + result.noPublicationGuardPublicationAttempted = !input.publicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted; + result.noRuntimePlatformDynamicLibraryLoaded = !input.runtimePlatformLoadAttempted; + result.noRuntimePlatformDynamicLibraryUnloaded = !input.runtimePlatformUnloadAttempted; + result.noRuntimePlatformSymbolResolution = !input.runtimePlatformSymbolResolutionAttempted; + result.noSdxlCalls = !input.sdxlCallRequested; + result.noBridgeCalls = !input.bridgeCallRequested; + result.noServerConnectivityChecked = !input.serverConnectivityCheckRequested; + result.noWalletLifecycle = !input.walletLifecycleRequested; + result.noSyncStarted = !input.syncRequested; + result.noSyncStatusPolled = !input.syncStatusPollingRequested; + result.noWorkerQueueEnqueue = !input.workerQueueRequested; + result.noWalletStateMutation = !input.walletStateMutationRequested; + result.noWalletPersistence = !input.walletPersistenceRequested; + result.noSettingsPersistence = !input.settingsWriteRequested; + result.noSendImportExportExecution = !input.sendImportExportRequested; + result.noArtifactMutation = !input.artifactMutationRequested; + + if (!result.noCallbackInvocationAttempted || + !result.noCallbackResultExecutionAttempted || + !result.noDispatchHandoffExecutionAttempted || + !result.noDispatchStatusPublicationAttempted || + !result.noDispatchConsumerConsumptionAttempted || + !result.noDispatchResultExecutionAttempted || + !result.noResultHandoffStatusPublicationAttempted || + !result.noReadinessProjectionStatusPublicationAttempted || + !result.noStatusHandoffPublicationAttempted || + !result.noPublicationGuardPublicationAttempted || + !result.noPublicationGuardResultHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted || + !result.noRuntimePlatformDynamicLibraryLoaded || + !result.noRuntimePlatformDynamicLibraryUnloaded || + !result.noRuntimePlatformSymbolResolution) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard must stop before callback, dispatch result execution, status publication, readiness publication, publication guard publication, and platform loader APIs"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_or_platform_api_attempted"); + return result; + } + + if (!result.noSdxlCalls || + !result.noBridgeCalls || + !result.noServerConnectivityChecked || + !result.noWalletLifecycle || + !result.noSyncStarted || + !result.noSyncStatusPolled || + !result.noWorkerQueueEnqueue || + !result.noWalletStateMutation || + !result.noWalletPersistence || + !result.noSettingsPersistence || + !result.noSendImportExportExecution || + !result.noArtifactMutation) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard must not request wallet runtime behavior"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlockedSummary( + "runtime_action_requested"); + return result; + } + + if (result.platform.empty()) { + result.status = LiteBridgeRuntimeStatus::Unavailable; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard requires a target platform"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlockedSummary( + "platform_missing"); + return result; + } + + if (isMacosPlatform(result.platform)) { + result.macosDeferred = true; + result.status = LiteBridgeRuntimeStatus::Unavailable; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardIssue( + result, + input.macosDeferredByOperator + ? "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard is deferred by operator request" + : "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard requires a reviewed builder before promotion"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlockedSummary( + "macos_deferred"); + return result; + } + + const bool linuxPlatform = isLinuxPlatform(result.platform); + const bool windowsPlatform = isWindowsPlatform(result.platform); + if (!linuxPlatform && !windowsPlatform) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard supports only Linux and Windows in batch 33"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlockedSummary( + "unsupported_platform"); + return result; + } + + result.platformAccepted = true; + result.linuxPlatformAccepted = linuxPlatform; + result.windowsPlatformAccepted = windowsPlatform; + + const auto& statusHandoff = input.publicationGuardResultHandoffReadinessProjectionStatusHandoff; + if (!input.publicationGuardResultHandoffReadinessProjectionStatusHandoffAccepted || + !statusHandoff.ok || + !statusHandoff.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffReady || + statusHandoff.status != LiteBridgeRuntimeStatus::Ready || + statusHandoff.platform != result.platform || + !statusHandoff.publicationGuardResultHandoffReadinessProjectionAccepted || + !statusHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffRecordAccepted || + !statusHandoff.statusHandoffPublicationGuardResultHandoffReadinessProjectionMatchAccepted || + !statusHandoff.disabledPublicationGuardResultHandoffReadinessProjectionStatusHandoffAccepted || + !statusHandoff.callbackInvocationRefused || + !statusHandoff.dispatchConsumptionStillGuarded || + !statusHandoff.dispatchResultExecutionBlocked || + !statusHandoff.dispatchStatusPublicationBlocked || + !statusHandoff.readinessProjectionPublicationBlocked || + !statusHandoff.statusHandoffPublicationBlocked || + !statusHandoff.publicationGuardPublicationBlocked || + !statusHandoff.publicationGuardResultHandoffPublicationBlocked || + !statusHandoff.publicationGuardResultHandoffReadinessProjectionPublicationBlocked || + !statusHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked || + !statusHandoff.platformApiPreInvocationBlocked || + !statusHandoff.disabledPublicationGuardResultHandoffReadinessProjectionStatusHandoffStateAccepted || + !statusHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffFailureMappingAccepted || + !statusHandoff.unloadExecutionBlocked || + !statusHandoff.symbolResolutionBlocked || + !statusHandoff.productionLoaderDisabled || + !statusHandoff.realAdapterExecutionDisabled || + !statusHandoff.loadOnlyExecutionDisabled || + !statusHandoff.separateExecutionBatchRequired || + !statusHandoff.noCallbackInvocationAttempted || + !statusHandoff.noCallbackResultExecutionAttempted || + !statusHandoff.noDispatchHandoffExecutionAttempted || + !statusHandoff.noDispatchStatusPublicationAttempted || + !statusHandoff.noDispatchConsumerConsumptionAttempted || + !statusHandoff.noDispatchResultExecutionAttempted || + !statusHandoff.noResultHandoffStatusPublicationAttempted || + !statusHandoff.noReadinessProjectionStatusPublicationAttempted || + !statusHandoff.noStatusHandoffPublicationAttempted || + !statusHandoff.noPublicationGuardPublicationAttempted || + !statusHandoff.noPublicationGuardResultHandoffPublicationAttempted || + !statusHandoff.noPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !statusHandoff.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !statusHandoff.noRuntimePlatformDynamicLibraryLoaded || + !statusHandoff.noRuntimePlatformDynamicLibraryUnloaded || + !statusHandoff.noRuntimePlatformSymbolResolution) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard requires matching ready disabled publication-guard result-handoff readiness-projection status-handoff evidence"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_required"); + return result; + } + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffAccepted = true; + + if (!input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardReviewed || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardRecorded || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardDisabled || + input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId.empty() || + input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard requires a reviewed disabled publication-guard record"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_required"); + return result; + } + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardRecordAccepted = true; + + if (!input.publicationGuardOwnerMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoff || + !input.publicationGuardBoundaryMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoff || + !input.publicationGuardCallbackMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoff || + !input.publicationGuardPreInvocationGuardMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoff || + !input.publicationGuardRefusalResultMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoff || + !input.publicationGuardPropagationMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoff || + !input.publicationGuardDispatchHandoffMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoff || + !input.publicationGuardStatusRecordMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoff || + !input.publicationGuardConsumerReadinessMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoff || + !input.publicationGuardConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoff || + !input.publicationGuardDispatchConsumptionGuardMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoff || + !input.publicationGuardDispatchConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoff || + !input.publicationGuardResultHandoffMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoff || + !input.publicationGuardResultConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoff || + !input.publicationGuardReadinessProjectionMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoff || + !input.publicationGuardReadinessConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoff || + !input.publicationGuardStatusHandoffMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoff || + !input.publicationGuardStatusConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoff || + !input.publicationGuardPublicationGuardMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoff || + !input.publicationGuardPublicationConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoff || + !input.publicationGuardPublicationGuardResultHandoffMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoff || + !input.publicationGuardPublicationGuardResultConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoff || + !input.publicationGuardPublicationGuardResultHandoffReadinessProjectionMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoff || + !input.publicationGuardPublicationGuardResultHandoffReadinessConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoff || + !input.publicationGuardPublicationGuardResultHandoffReadinessProjectionStatusHandoffMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoff || + !input.publicationGuardPublicationGuardResultHandoffReadinessProjectionStatusConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoff || + result.ownerName != statusHandoff.ownerName || + result.handoffId != statusHandoff.handoffId || + result.loadCallbackBoundaryName != statusHandoff.loadCallbackBoundaryName || + result.callbackBindingId != statusHandoff.callbackBindingId || + result.callbackName != statusHandoff.callbackName || + result.guardId != statusHandoff.guardId || + result.refusalResultId != statusHandoff.refusalResultId || + result.propagationId != statusHandoff.propagationId || + result.dispatchHandoffId != statusHandoff.dispatchHandoffId || + result.statusRecordId != statusHandoff.statusRecordId || + result.consumerReadinessId != statusHandoff.consumerReadinessId || + result.consumerName != statusHandoff.consumerName || + result.dispatchConsumptionGuardId != statusHandoff.dispatchConsumptionGuardId || + result.dispatchConsumerName != statusHandoff.dispatchConsumerName || + result.resultHandoffId != statusHandoff.resultHandoffId || + result.resultConsumerName != statusHandoff.resultConsumerName || + result.readinessProjectionId != statusHandoff.readinessProjectionId || + result.readinessConsumerName != statusHandoff.readinessConsumerName || + result.statusHandoffId != statusHandoff.statusHandoffId || + result.statusConsumerName != statusHandoff.statusConsumerName || + result.publicationGuardId != statusHandoff.publicationGuardId || + result.publicationConsumerName != statusHandoff.publicationConsumerName || + result.publicationGuardResultHandoffId != statusHandoff.publicationGuardResultHandoffId || + result.publicationGuardResultConsumerName != statusHandoff.publicationGuardResultConsumerName || + result.publicationGuardResultHandoffReadinessProjectionId != statusHandoff.publicationGuardResultHandoffReadinessProjectionId || + result.publicationGuardResultHandoffReadinessConsumerName != statusHandoff.publicationGuardResultHandoffReadinessConsumerName || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffId != statusHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffId || + result.publicationGuardResultHandoffReadinessProjectionStatusConsumerName != statusHandoff.publicationGuardResultHandoffReadinessProjectionStatusConsumerName || + result.adapterName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard requires publication-guard-to-status-handoff match evidence"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_match_required"); + return result; + } + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardMatchAccepted = true; + + if (!input.disabledPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardRegistered || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardAcceptsStatusHandoffEvidence || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardReturnsDisabledPublication || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlocksDispatchConsumption || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlocksDispatchResultExecution || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlocksStatusPublication || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlocksReadinessPublication || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlocksStatusHandoffPublication || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlocksPublicationGuardPublication || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlocksResultHandoffPublication || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlocksReadinessProjectionPublication || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlocksStatusHandoffResultPublication) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard requires disabled publication-guard evidence"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlockedSummary( + "disabled_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_required"); + return result; + } + result.disabledPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardAccepted = true; + + if (!input.callbackInvocationStillDisabled || + !input.callbackInvocationRefused || + !input.callbackInvocationRefusalReviewed || + !input.publicationGuardStopsBeforeCallbackInvocation || + !input.publicationGuardStopsBeforeCallbackResultExecution || + !input.publicationGuardStopsBeforeDispatchConsumption || + !input.publicationGuardStopsBeforeDispatchResultExecution || + !input.publicationGuardStopsBeforeDispatchStatusPublication || + !input.publicationGuardStopsBeforeReadinessPublication || + !input.publicationGuardStopsBeforeStatusHandoffPublication || + !input.publicationGuardStopsBeforePublicationGuardPublication || + !input.publicationGuardStopsBeforePublicationGuardResultHandoffPublication || + !input.publicationGuardStopsBeforePublicationGuardResultHandoffReadinessProjectionPublication || + !input.publicationGuardStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication || + !input.publicationGuardStopsBeforePublication || + !input.publicationGuardStopsBeforePlatformApi || + !input.publicationGuardRequiresSeparateExecutionBatch) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard must remain disabled before callback, dispatch result execution, status publication, readiness publication, publication, and platform APIs"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_disabled_state_required"); + return result; + } + result.callbackInvocationRefused = true; + result.dispatchConsumptionStillGuarded = true; + result.dispatchResultExecutionBlocked = true; + result.dispatchStatusPublicationBlocked = true; + result.readinessProjectionPublicationBlocked = true; + result.statusHandoffPublicationBlocked = true; + result.publicationGuardPublicationBlocked = true; + result.publicationGuardResultHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked = true; + result.platformApiPreInvocationBlocked = true; + + if (!input.publicationGuardProducesNoDynamicHandle || + !input.publicationGuardStoresNoDynamicHandle || + !input.publicationGuardReleasesNoDynamicHandle || + !input.publicationGuardResolvesNoSymbols || + !input.publicationGuardStoresNoSymbolTable || + !input.publicationGuardCreatesNoRuntime) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard must not create runtime loader state"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_runtime_state_required"); + return result; + } + result.disabledPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardStateAccepted = true; + + if (!input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardFailureMappingReviewed) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard requires disabled publication-guard failure mapping review"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_failure_mapping_required"); + return result; + } + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardFailureMappingAccepted = true; + + if (!input.unloadExecutionStillDisabled || !input.symbolResolutionStillDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard must keep unload and symbol resolution disabled"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlockedSummary( + "non_load_execution_enabled"); + return result; + } + result.unloadExecutionBlocked = true; + result.symbolResolutionBlocked = true; + + if (!input.productionLoaderExecutionDisabled || + !input.realAdapterExecutionDisabled || + !input.loadOnlyExecutionDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard must keep real loader execution disabled"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlockedSummary( + "production_loader_enabled"); + return result; + } + result.productionLoaderDisabled = true; + result.realAdapterExecutionDisabled = true; + result.loadOnlyExecutionDisabled = true; + + if (!input.separateExecutionBatchRequired) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard requires a separate execution batch"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlockedSummary( + "separate_execution_batch_required"); + return result; + } + result.separateExecutionBatchRequired = true; + + result.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardReady = true; + result.status = LiteBridgeRuntimeStatus::Ready; + result.ok = true; + result.summary = std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard=ready; platform=") + + result.platform + "; scope=load-only-disabled-callback-refusal-propagation-consumer-readiness-dispatch-consumption-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard; execution=disabled"; + return result; +} + +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffInput& input) +{ + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffResult result; + result.status = LiteBridgeRuntimeStatus::Configured; + result.platform = normalizedPlatform( + input.platform.empty() ? input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard.platform : input.platform); + result.adapterName = input.adapterName.empty() + ? input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard.adapterName + : input.adapterName; + result.ownerName = input.ownerName.empty() + ? input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard.ownerName + : input.ownerName; + result.handoffId = input.handoffId.empty() + ? input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard.handoffId + : input.handoffId; + result.loadCallbackBoundaryName = input.loadCallbackBoundaryName.empty() + ? input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard.loadCallbackBoundaryName + : input.loadCallbackBoundaryName; + result.callbackBindingId = input.callbackBindingId.empty() + ? input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard.callbackBindingId + : input.callbackBindingId; + result.callbackName = input.callbackName.empty() + ? input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard.callbackName + : input.callbackName; + result.guardId = input.guardId.empty() + ? input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard.guardId + : input.guardId; + result.refusalResultId = input.refusalResultId.empty() + ? input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard.refusalResultId + : input.refusalResultId; + result.propagationId = input.propagationId.empty() + ? input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard.propagationId + : input.propagationId; + result.dispatchHandoffId = input.dispatchHandoffId.empty() + ? input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard.dispatchHandoffId + : input.dispatchHandoffId; + result.statusRecordId = input.statusRecordId.empty() + ? input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard.statusRecordId + : input.statusRecordId; + result.consumerReadinessId = input.consumerReadinessId.empty() + ? input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard.consumerReadinessId + : input.consumerReadinessId; + result.consumerName = input.consumerName.empty() + ? input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard.consumerName + : input.consumerName; + result.dispatchConsumptionGuardId = input.dispatchConsumptionGuardId.empty() + ? input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard.dispatchConsumptionGuardId + : input.dispatchConsumptionGuardId; + result.dispatchConsumerName = input.dispatchConsumerName.empty() + ? input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard.dispatchConsumerName + : input.dispatchConsumerName; + result.resultHandoffId = input.resultHandoffId.empty() + ? input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard.resultHandoffId + : input.resultHandoffId; + result.resultConsumerName = input.resultConsumerName.empty() + ? input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard.resultConsumerName + : input.resultConsumerName; + result.readinessProjectionId = input.readinessProjectionId.empty() + ? input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard.readinessProjectionId + : input.readinessProjectionId; + result.readinessConsumerName = input.readinessConsumerName.empty() + ? input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard.readinessConsumerName + : input.readinessConsumerName; + result.statusHandoffId = input.statusHandoffId.empty() + ? input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard.statusHandoffId + : input.statusHandoffId; + result.statusConsumerName = input.statusConsumerName.empty() + ? input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard.statusConsumerName + : input.statusConsumerName; + result.publicationGuardId = input.publicationGuardId.empty() + ? input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard.publicationGuardId + : input.publicationGuardId; + result.publicationConsumerName = input.publicationConsumerName.empty() + ? input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard.publicationConsumerName + : input.publicationConsumerName; + result.publicationGuardResultHandoffId = input.publicationGuardResultHandoffId.empty() + ? input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard.publicationGuardResultHandoffId + : input.publicationGuardResultHandoffId; + result.publicationGuardResultConsumerName = input.publicationGuardResultConsumerName.empty() + ? input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard.publicationGuardResultConsumerName + : input.publicationGuardResultConsumerName; + result.publicationGuardResultHandoffReadinessProjectionId = input.publicationGuardResultHandoffReadinessProjectionId.empty() + ? input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard.publicationGuardResultHandoffReadinessProjectionId + : input.publicationGuardResultHandoffReadinessProjectionId; + result.publicationGuardResultHandoffReadinessConsumerName = input.publicationGuardResultHandoffReadinessConsumerName.empty() + ? input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard.publicationGuardResultHandoffReadinessConsumerName + : input.publicationGuardResultHandoffReadinessConsumerName; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffId = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffId.empty() + ? input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard.publicationGuardResultHandoffReadinessProjectionStatusHandoffId + : input.publicationGuardResultHandoffReadinessProjectionStatusHandoffId; + result.publicationGuardResultHandoffReadinessProjectionStatusConsumerName = input.publicationGuardResultHandoffReadinessProjectionStatusConsumerName.empty() + ? input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard.publicationGuardResultHandoffReadinessProjectionStatusConsumerName + : input.publicationGuardResultHandoffReadinessProjectionStatusConsumerName; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId.empty() + ? input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId + : input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName.empty() + ? input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName + : input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName; + + result.noCallbackInvocationAttempted = !input.callbackInvocationAttempted; + result.noCallbackResultExecutionAttempted = !input.callbackResultExecutionAttempted; + result.noDispatchHandoffExecutionAttempted = !input.dispatchHandoffExecutionAttempted; + result.noDispatchStatusPublicationAttempted = !input.dispatchStatusPublicationAttempted; + result.noDispatchConsumerConsumptionAttempted = !input.dispatchConsumerConsumptionAttempted; + result.noDispatchResultExecutionAttempted = !input.dispatchResultExecutionAttempted; + result.noResultHandoffStatusPublicationAttempted = !input.resultHandoffStatusPublicationAttempted; + result.noReadinessProjectionStatusPublicationAttempted = !input.readinessProjectionStatusPublicationAttempted; + result.noStatusHandoffPublicationAttempted = !input.statusHandoffPublicationAttempted; + result.noPublicationGuardPublicationAttempted = !input.publicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted; + result.noRuntimePlatformDynamicLibraryLoaded = !input.runtimePlatformLoadAttempted; + result.noRuntimePlatformDynamicLibraryUnloaded = !input.runtimePlatformUnloadAttempted; + result.noRuntimePlatformSymbolResolution = !input.runtimePlatformSymbolResolutionAttempted; + result.noSdxlCalls = !input.sdxlCallRequested; + result.noBridgeCalls = !input.bridgeCallRequested; + result.noServerConnectivityChecked = !input.serverConnectivityCheckRequested; + result.noWalletLifecycle = !input.walletLifecycleRequested; + result.noSyncStarted = !input.syncRequested; + result.noSyncStatusPolled = !input.syncStatusPollingRequested; + result.noWorkerQueueEnqueue = !input.workerQueueRequested; + result.noWalletStateMutation = !input.walletStateMutationRequested; + result.noWalletPersistence = !input.walletPersistenceRequested; + result.noSettingsPersistence = !input.settingsWriteRequested; + result.noSendImportExportExecution = !input.sendImportExportRequested; + result.noArtifactMutation = !input.artifactMutationRequested; + + if (!result.noCallbackInvocationAttempted || + !result.noCallbackResultExecutionAttempted || + !result.noDispatchHandoffExecutionAttempted || + !result.noDispatchStatusPublicationAttempted || + !result.noDispatchConsumerConsumptionAttempted || + !result.noDispatchResultExecutionAttempted || + !result.noResultHandoffStatusPublicationAttempted || + !result.noReadinessProjectionStatusPublicationAttempted || + !result.noStatusHandoffPublicationAttempted || + !result.noPublicationGuardPublicationAttempted || + !result.noPublicationGuardResultHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted || + !result.noRuntimePlatformDynamicLibraryLoaded || + !result.noRuntimePlatformDynamicLibraryUnloaded || + !result.noRuntimePlatformSymbolResolution) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff must stop before callback, dispatch result execution, status publication, readiness publication, publication guard result handoff publication, and platform loader APIs"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_or_platform_api_attempted"); + return result; + } + + if (!result.noSdxlCalls || + !result.noBridgeCalls || + !result.noServerConnectivityChecked || + !result.noWalletLifecycle || + !result.noSyncStarted || + !result.noSyncStatusPolled || + !result.noWorkerQueueEnqueue || + !result.noWalletStateMutation || + !result.noWalletPersistence || + !result.noSettingsPersistence || + !result.noSendImportExportExecution || + !result.noArtifactMutation) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff must not request wallet runtime behavior"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlockedSummary( + "runtime_action_requested"); + return result; + } + + if (result.platform.empty()) { + result.status = LiteBridgeRuntimeStatus::Unavailable; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff requires a target platform"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlockedSummary( + "platform_missing"); + return result; + } + + if (isMacosPlatform(result.platform)) { + result.macosDeferred = true; + result.status = LiteBridgeRuntimeStatus::Unavailable; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffIssue( + result, + input.macosDeferredByOperator + ? "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff is deferred by operator request" + : "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff requires a reviewed builder before promotion"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlockedSummary( + "macos_deferred"); + return result; + } + + const bool linuxPlatform = isLinuxPlatform(result.platform); + const bool windowsPlatform = isWindowsPlatform(result.platform); + if (!linuxPlatform && !windowsPlatform) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff supports only Linux and Windows in batch 34"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlockedSummary( + "unsupported_platform"); + return result; + } + + result.platformAccepted = true; + result.linuxPlatformAccepted = linuxPlatform; + result.windowsPlatformAccepted = windowsPlatform; + + const auto& publicationGuard = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard; + if (!input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardAccepted || + !publicationGuard.ok || + !publicationGuard.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardReady || + publicationGuard.status != LiteBridgeRuntimeStatus::Ready || + publicationGuard.platform != result.platform || + !publicationGuard.publicationGuardResultHandoffReadinessProjectionStatusHandoffAccepted || + !publicationGuard.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardRecordAccepted || + !publicationGuard.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardMatchAccepted || + !publicationGuard.disabledPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardAccepted || + !publicationGuard.callbackInvocationRefused || + !publicationGuard.dispatchConsumptionStillGuarded || + !publicationGuard.dispatchResultExecutionBlocked || + !publicationGuard.dispatchStatusPublicationBlocked || + !publicationGuard.readinessProjectionPublicationBlocked || + !publicationGuard.statusHandoffPublicationBlocked || + !publicationGuard.publicationGuardPublicationBlocked || + !publicationGuard.publicationGuardResultHandoffPublicationBlocked || + !publicationGuard.publicationGuardResultHandoffReadinessProjectionPublicationBlocked || + !publicationGuard.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked || + !publicationGuard.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked || + !publicationGuard.platformApiPreInvocationBlocked || + !publicationGuard.disabledPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardStateAccepted || + !publicationGuard.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardFailureMappingAccepted || + !publicationGuard.unloadExecutionBlocked || + !publicationGuard.symbolResolutionBlocked || + !publicationGuard.productionLoaderDisabled || + !publicationGuard.realAdapterExecutionDisabled || + !publicationGuard.loadOnlyExecutionDisabled || + !publicationGuard.separateExecutionBatchRequired || + !publicationGuard.noCallbackInvocationAttempted || + !publicationGuard.noCallbackResultExecutionAttempted || + !publicationGuard.noDispatchHandoffExecutionAttempted || + !publicationGuard.noDispatchStatusPublicationAttempted || + !publicationGuard.noDispatchConsumerConsumptionAttempted || + !publicationGuard.noDispatchResultExecutionAttempted || + !publicationGuard.noResultHandoffStatusPublicationAttempted || + !publicationGuard.noReadinessProjectionStatusPublicationAttempted || + !publicationGuard.noStatusHandoffPublicationAttempted || + !publicationGuard.noPublicationGuardPublicationAttempted || + !publicationGuard.noPublicationGuardResultHandoffPublicationAttempted || + !publicationGuard.noPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !publicationGuard.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !publicationGuard.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted || + !publicationGuard.noRuntimePlatformDynamicLibraryLoaded || + !publicationGuard.noRuntimePlatformDynamicLibraryUnloaded || + !publicationGuard.noRuntimePlatformSymbolResolution) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff requires matching ready disabled publication-guard evidence"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_required"); + return result; + } + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardAccepted = true; + + if (!input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReviewed || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffRecorded || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffDisabled || + input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId.empty() || + input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff requires a reviewed disabled result-handoff record"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_required"); + return result; + } + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffRecordAccepted = true; + + if (!input.resultHandoffOwnerMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard || + !input.resultHandoffBoundaryMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard || + !input.resultHandoffCallbackMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard || + !input.resultHandoffPreInvocationGuardMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard || + !input.resultHandoffRefusalResultMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard || + !input.resultHandoffPropagationMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard || + !input.resultHandoffDispatchHandoffMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard || + !input.resultHandoffStatusRecordMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard || + !input.resultHandoffConsumerReadinessMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard || + !input.resultHandoffConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard || + !input.resultHandoffDispatchConsumptionGuardMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard || + !input.resultHandoffDispatchConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard || + !input.resultHandoffResultHandoffMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard || + !input.resultHandoffResultConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard || + !input.resultHandoffReadinessProjectionMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard || + !input.resultHandoffReadinessConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard || + !input.resultHandoffStatusHandoffMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard || + !input.resultHandoffStatusConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard || + !input.resultHandoffPublicationGuardMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard || + !input.resultHandoffPublicationConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard || + !input.resultHandoffPublicationGuardResultHandoffMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard || + !input.resultHandoffPublicationGuardResultConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard || + !input.resultHandoffPublicationGuardResultHandoffReadinessProjectionMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard || + !input.resultHandoffPublicationGuardResultHandoffReadinessConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard || + !input.resultHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard || + !input.resultHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard || + !input.resultHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard || + !input.resultHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard || + result.ownerName != publicationGuard.ownerName || + result.handoffId != publicationGuard.handoffId || + result.loadCallbackBoundaryName != publicationGuard.loadCallbackBoundaryName || + result.callbackBindingId != publicationGuard.callbackBindingId || + result.callbackName != publicationGuard.callbackName || + result.guardId != publicationGuard.guardId || + result.refusalResultId != publicationGuard.refusalResultId || + result.propagationId != publicationGuard.propagationId || + result.dispatchHandoffId != publicationGuard.dispatchHandoffId || + result.statusRecordId != publicationGuard.statusRecordId || + result.consumerReadinessId != publicationGuard.consumerReadinessId || + result.consumerName != publicationGuard.consumerName || + result.dispatchConsumptionGuardId != publicationGuard.dispatchConsumptionGuardId || + result.dispatchConsumerName != publicationGuard.dispatchConsumerName || + result.resultHandoffId != publicationGuard.resultHandoffId || + result.resultConsumerName != publicationGuard.resultConsumerName || + result.readinessProjectionId != publicationGuard.readinessProjectionId || + result.readinessConsumerName != publicationGuard.readinessConsumerName || + result.statusHandoffId != publicationGuard.statusHandoffId || + result.statusConsumerName != publicationGuard.statusConsumerName || + result.publicationGuardId != publicationGuard.publicationGuardId || + result.publicationConsumerName != publicationGuard.publicationConsumerName || + result.publicationGuardResultHandoffId != publicationGuard.publicationGuardResultHandoffId || + result.publicationGuardResultConsumerName != publicationGuard.publicationGuardResultConsumerName || + result.publicationGuardResultHandoffReadinessProjectionId != publicationGuard.publicationGuardResultHandoffReadinessProjectionId || + result.publicationGuardResultHandoffReadinessConsumerName != publicationGuard.publicationGuardResultHandoffReadinessConsumerName || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffId != publicationGuard.publicationGuardResultHandoffReadinessProjectionStatusHandoffId || + result.publicationGuardResultHandoffReadinessProjectionStatusConsumerName != publicationGuard.publicationGuardResultHandoffReadinessProjectionStatusConsumerName || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId != publicationGuard.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName != publicationGuard.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName || + result.adapterName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff requires result-handoff-to-publication-guard match evidence"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_match_required"); + return result; + } + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffMatchAccepted = true; + + if (!input.disabledPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffRegistered || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffAcceptsPublicationGuardEvidence || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReturnsDisabledResult || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlocksDispatchConsumption || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlocksDispatchResultExecution || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlocksStatusPublication || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlocksReadinessPublication || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlocksStatusHandoffPublication || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlocksPublicationGuardPublication || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlocksPublicationGuardResultHandoffPublication || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlocksReadinessProjectionPublication || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlocksStatusHandoffResultPublication || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlocksPublicationGuardResultPublication) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff requires disabled result-handoff evidence"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlockedSummary( + "disabled_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_required"); + return result; + } + result.disabledPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffAccepted = true; + + if (!input.callbackInvocationStillDisabled || + !input.callbackInvocationRefused || + !input.callbackInvocationRefusalReviewed || + !input.resultHandoffStopsBeforeCallbackInvocation || + !input.resultHandoffStopsBeforeCallbackResultExecution || + !input.resultHandoffStopsBeforeDispatchConsumption || + !input.resultHandoffStopsBeforeDispatchResultExecution || + !input.resultHandoffStopsBeforeDispatchStatusPublication || + !input.resultHandoffStopsBeforeReadinessPublication || + !input.resultHandoffStopsBeforeStatusHandoffPublication || + !input.resultHandoffStopsBeforePublicationGuardPublication || + !input.resultHandoffStopsBeforePublicationGuardResultHandoffPublication || + !input.resultHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionPublication || + !input.resultHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication || + !input.resultHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication || + !input.resultHandoffStopsBeforeResultPublication || + !input.resultHandoffStopsBeforePlatformApi || + !input.resultHandoffRequiresSeparateExecutionBatch) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff must remain disabled before callback, dispatch result execution, status publication, readiness publication, result publication, and platform APIs"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_disabled_state_required"); + return result; + } + result.callbackInvocationRefused = true; + result.dispatchConsumptionStillGuarded = true; + result.dispatchResultExecutionBlocked = true; + result.dispatchStatusPublicationBlocked = true; + result.readinessProjectionPublicationBlocked = true; + result.statusHandoffPublicationBlocked = true; + result.publicationGuardPublicationBlocked = true; + result.publicationGuardResultHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationBlocked = true; + result.platformApiPreInvocationBlocked = true; + + if (!input.resultHandoffProducesNoDynamicHandle || + !input.resultHandoffStoresNoDynamicHandle || + !input.resultHandoffReleasesNoDynamicHandle || + !input.resultHandoffResolvesNoSymbols || + !input.resultHandoffStoresNoSymbolTable || + !input.resultHandoffCreatesNoRuntime) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff must not create runtime loader state"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_runtime_state_required"); + return result; + } + result.disabledPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffStateAccepted = true; + + if (!input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffFailureMappingReviewed) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff requires disabled result-handoff failure mapping review"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_failure_mapping_required"); + return result; + } + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffFailureMappingAccepted = true; + + if (!input.unloadExecutionStillDisabled || !input.symbolResolutionStillDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff must keep unload and symbol resolution disabled"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlockedSummary( + "non_load_execution_enabled"); + return result; + } + result.unloadExecutionBlocked = true; + result.symbolResolutionBlocked = true; + + if (!input.productionLoaderExecutionDisabled || + !input.realAdapterExecutionDisabled || + !input.loadOnlyExecutionDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff must keep real loader execution disabled"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlockedSummary( + "production_loader_enabled"); + return result; + } + result.productionLoaderDisabled = true; + result.realAdapterExecutionDisabled = true; + result.loadOnlyExecutionDisabled = true; + + if (!input.separateExecutionBatchRequired) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff requires a separate execution batch"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlockedSummary( + "separate_execution_batch_required"); + return result; + } + result.separateExecutionBatchRequired = true; + + result.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReady = true; + result.status = LiteBridgeRuntimeStatus::Ready; + result.ok = true; + result.summary = std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff=ready; platform=") + + result.platform + "; scope=load-only-disabled-callback-refusal-propagation-consumer-readiness-dispatch-consumption-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff; execution=disabled"; + return result; +} + +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionInput& input) +{ + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionResult result; + result.status = LiteBridgeRuntimeStatus::Configured; + const auto& resultHandoff = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff; + result.platform = normalizedPlatform(input.platform.empty() ? resultHandoff.platform : input.platform); + result.adapterName = input.adapterName.empty() ? resultHandoff.adapterName : input.adapterName; + result.ownerName = input.ownerName.empty() ? resultHandoff.ownerName : input.ownerName; + result.handoffId = input.handoffId.empty() ? resultHandoff.handoffId : input.handoffId; + result.loadCallbackBoundaryName = input.loadCallbackBoundaryName.empty() ? resultHandoff.loadCallbackBoundaryName : input.loadCallbackBoundaryName; + result.callbackBindingId = input.callbackBindingId.empty() ? resultHandoff.callbackBindingId : input.callbackBindingId; + result.callbackName = input.callbackName.empty() ? resultHandoff.callbackName : input.callbackName; + result.guardId = input.guardId.empty() ? resultHandoff.guardId : input.guardId; + result.refusalResultId = input.refusalResultId.empty() ? resultHandoff.refusalResultId : input.refusalResultId; + result.propagationId = input.propagationId.empty() ? resultHandoff.propagationId : input.propagationId; + result.dispatchHandoffId = input.dispatchHandoffId.empty() ? resultHandoff.dispatchHandoffId : input.dispatchHandoffId; + result.statusRecordId = input.statusRecordId.empty() ? resultHandoff.statusRecordId : input.statusRecordId; + result.consumerReadinessId = input.consumerReadinessId.empty() ? resultHandoff.consumerReadinessId : input.consumerReadinessId; + result.consumerName = input.consumerName.empty() ? resultHandoff.consumerName : input.consumerName; + result.dispatchConsumptionGuardId = input.dispatchConsumptionGuardId.empty() ? resultHandoff.dispatchConsumptionGuardId : input.dispatchConsumptionGuardId; + result.dispatchConsumerName = input.dispatchConsumerName.empty() ? resultHandoff.dispatchConsumerName : input.dispatchConsumerName; + result.resultHandoffId = input.resultHandoffId.empty() ? resultHandoff.resultHandoffId : input.resultHandoffId; + result.resultConsumerName = input.resultConsumerName.empty() ? resultHandoff.resultConsumerName : input.resultConsumerName; + result.readinessProjectionId = input.readinessProjectionId.empty() ? resultHandoff.readinessProjectionId : input.readinessProjectionId; + result.readinessConsumerName = input.readinessConsumerName.empty() ? resultHandoff.readinessConsumerName : input.readinessConsumerName; + result.statusHandoffId = input.statusHandoffId.empty() ? resultHandoff.statusHandoffId : input.statusHandoffId; + result.statusConsumerName = input.statusConsumerName.empty() ? resultHandoff.statusConsumerName : input.statusConsumerName; + result.publicationGuardId = input.publicationGuardId.empty() ? resultHandoff.publicationGuardId : input.publicationGuardId; + result.publicationConsumerName = input.publicationConsumerName.empty() ? resultHandoff.publicationConsumerName : input.publicationConsumerName; + result.publicationGuardResultHandoffId = input.publicationGuardResultHandoffId.empty() ? resultHandoff.publicationGuardResultHandoffId : input.publicationGuardResultHandoffId; + result.publicationGuardResultConsumerName = input.publicationGuardResultConsumerName.empty() ? resultHandoff.publicationGuardResultConsumerName : input.publicationGuardResultConsumerName; + result.publicationGuardResultHandoffReadinessProjectionId = input.publicationGuardResultHandoffReadinessProjectionId.empty() ? resultHandoff.publicationGuardResultHandoffReadinessProjectionId : input.publicationGuardResultHandoffReadinessProjectionId; + result.publicationGuardResultHandoffReadinessConsumerName = input.publicationGuardResultHandoffReadinessConsumerName.empty() ? resultHandoff.publicationGuardResultHandoffReadinessConsumerName : input.publicationGuardResultHandoffReadinessConsumerName; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffId = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffId.empty() ? resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffId : input.publicationGuardResultHandoffReadinessProjectionStatusHandoffId; + result.publicationGuardResultHandoffReadinessProjectionStatusConsumerName = input.publicationGuardResultHandoffReadinessProjectionStatusConsumerName.empty() ? resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusConsumerName : input.publicationGuardResultHandoffReadinessProjectionStatusConsumerName; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId.empty() ? resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId : input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName.empty() ? resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName : input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId.empty() ? resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId : input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName.empty() ? resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName : input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName; + + result.noCallbackInvocationAttempted = !input.callbackInvocationAttempted; + result.noCallbackResultExecutionAttempted = !input.callbackResultExecutionAttempted; + result.noDispatchHandoffExecutionAttempted = !input.dispatchHandoffExecutionAttempted; + result.noDispatchStatusPublicationAttempted = !input.dispatchStatusPublicationAttempted; + result.noDispatchConsumerConsumptionAttempted = !input.dispatchConsumerConsumptionAttempted; + result.noDispatchResultExecutionAttempted = !input.dispatchResultExecutionAttempted; + result.noResultHandoffStatusPublicationAttempted = !input.resultHandoffStatusPublicationAttempted; + result.noReadinessProjectionStatusPublicationAttempted = !input.readinessProjectionStatusPublicationAttempted; + result.noStatusHandoffPublicationAttempted = !input.statusHandoffPublicationAttempted; + result.noPublicationGuardPublicationAttempted = !input.publicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noRuntimePlatformDynamicLibraryLoaded = !input.runtimePlatformLoadAttempted; + result.noRuntimePlatformDynamicLibraryUnloaded = !input.runtimePlatformUnloadAttempted; + result.noRuntimePlatformSymbolResolution = !input.runtimePlatformSymbolResolutionAttempted; + result.noSdxlCalls = !input.sdxlCallRequested; + result.noBridgeCalls = !input.bridgeCallRequested; + result.noServerConnectivityChecked = !input.serverConnectivityCheckRequested; + result.noWalletLifecycle = !input.walletLifecycleRequested; + result.noSyncStarted = !input.syncRequested; + result.noSyncStatusPolled = !input.syncStatusPollingRequested; + result.noWorkerQueueEnqueue = !input.workerQueueRequested; + result.noWalletStateMutation = !input.walletStateMutationRequested; + result.noWalletPersistence = !input.walletPersistenceRequested; + result.noSettingsPersistence = !input.settingsWriteRequested; + result.noSendImportExportExecution = !input.sendImportExportRequested; + result.noArtifactMutation = !input.artifactMutationRequested; + + if (!result.noCallbackInvocationAttempted || + !result.noCallbackResultExecutionAttempted || + !result.noDispatchHandoffExecutionAttempted || + !result.noDispatchStatusPublicationAttempted || + !result.noDispatchConsumerConsumptionAttempted || + !result.noDispatchResultExecutionAttempted || + !result.noResultHandoffStatusPublicationAttempted || + !result.noReadinessProjectionStatusPublicationAttempted || + !result.noStatusHandoffPublicationAttempted || + !result.noPublicationGuardPublicationAttempted || + !result.noPublicationGuardResultHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !result.noRuntimePlatformDynamicLibraryLoaded || + !result.noRuntimePlatformDynamicLibraryUnloaded || + !result.noRuntimePlatformSymbolResolution) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection must stop before callback, dispatch result execution, status publication, readiness publication, readiness-projection publication, and platform loader APIs"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_or_platform_api_attempted"); + return result; + } + + if (!result.noSdxlCalls || !result.noBridgeCalls || !result.noServerConnectivityChecked || + !result.noWalletLifecycle || !result.noSyncStarted || !result.noSyncStatusPolled || + !result.noWorkerQueueEnqueue || !result.noWalletStateMutation || !result.noWalletPersistence || + !result.noSettingsPersistence || !result.noSendImportExportExecution || !result.noArtifactMutation) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection must not request wallet runtime behavior"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlockedSummary("runtime_action_requested"); + return result; + } + + if (result.platform.empty()) { + result.status = LiteBridgeRuntimeStatus::Unavailable; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection requires a target platform"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlockedSummary("platform_missing"); + return result; + } + + if (isMacosPlatform(result.platform)) { + result.macosDeferred = true; + result.status = LiteBridgeRuntimeStatus::Unavailable; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionIssue( + result, + input.macosDeferredByOperator + ? "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection is deferred by operator request" + : "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection requires a reviewed builder before promotion"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlockedSummary("macos_deferred"); + return result; + } + + const bool linuxPlatform = isLinuxPlatform(result.platform); + const bool windowsPlatform = isWindowsPlatform(result.platform); + if (!linuxPlatform && !windowsPlatform) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection supports only Linux and Windows in batch 35"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlockedSummary("unsupported_platform"); + return result; + } + + result.platformAccepted = true; + result.linuxPlatformAccepted = linuxPlatform; + result.windowsPlatformAccepted = windowsPlatform; + + if (!input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffAccepted || + !resultHandoff.ok || + !resultHandoff.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReady || + resultHandoff.status != LiteBridgeRuntimeStatus::Ready || + resultHandoff.platform != result.platform || + !resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardAccepted || + !resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffRecordAccepted || + !resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffMatchAccepted || + !resultHandoff.disabledPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffAccepted || + !resultHandoff.callbackInvocationRefused || !resultHandoff.dispatchConsumptionStillGuarded || + !resultHandoff.dispatchResultExecutionBlocked || !resultHandoff.dispatchStatusPublicationBlocked || + !resultHandoff.readinessProjectionPublicationBlocked || !resultHandoff.statusHandoffPublicationBlocked || + !resultHandoff.publicationGuardPublicationBlocked || !resultHandoff.publicationGuardResultHandoffPublicationBlocked || + !resultHandoff.publicationGuardResultHandoffReadinessProjectionPublicationBlocked || + !resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked || + !resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked || + !resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationBlocked || + !resultHandoff.platformApiPreInvocationBlocked || + !resultHandoff.disabledPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffStateAccepted || + !resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffFailureMappingAccepted || + !resultHandoff.unloadExecutionBlocked || !resultHandoff.symbolResolutionBlocked || + !resultHandoff.productionLoaderDisabled || !resultHandoff.realAdapterExecutionDisabled || + !resultHandoff.loadOnlyExecutionDisabled || !resultHandoff.separateExecutionBatchRequired || + !resultHandoff.noCallbackInvocationAttempted || !resultHandoff.noCallbackResultExecutionAttempted || + !resultHandoff.noDispatchHandoffExecutionAttempted || !resultHandoff.noDispatchStatusPublicationAttempted || + !resultHandoff.noDispatchConsumerConsumptionAttempted || !resultHandoff.noDispatchResultExecutionAttempted || + !resultHandoff.noResultHandoffStatusPublicationAttempted || !resultHandoff.noReadinessProjectionStatusPublicationAttempted || + !resultHandoff.noStatusHandoffPublicationAttempted || !resultHandoff.noPublicationGuardPublicationAttempted || + !resultHandoff.noPublicationGuardResultHandoffPublicationAttempted || + !resultHandoff.noPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !resultHandoff.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !resultHandoff.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted || + !resultHandoff.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted || + !resultHandoff.noRuntimePlatformDynamicLibraryLoaded || !resultHandoff.noRuntimePlatformDynamicLibraryUnloaded || + !resultHandoff.noRuntimePlatformSymbolResolution) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection requires matching ready disabled publication-guard result-handoff evidence"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_required"); + return result; + } + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffAccepted = true; + + if (!input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionReviewed || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionRecorded || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionDisabled || + input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId.empty() || + input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection requires a reviewed disabled readiness-projection record"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_required"); + return result; + } + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionRecordAccepted = true; + + if (!input.projectionOwnerMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff || + !input.projectionBoundaryMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff || + !input.projectionCallbackMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff || + !input.projectionPreInvocationGuardMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff || + !input.projectionRefusalResultMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff || + !input.projectionPropagationMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff || + !input.projectionDispatchHandoffMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff || + !input.projectionStatusRecordMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff || + !input.projectionConsumerReadinessMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff || + !input.projectionConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff || + !input.projectionDispatchConsumptionGuardMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff || + !input.projectionDispatchConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff || + !input.projectionResultHandoffMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff || + !input.projectionResultConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff || + !input.projectionReadinessProjectionMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff || + !input.projectionReadinessConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff || + !input.projectionStatusHandoffMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff || + !input.projectionStatusConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff || + !input.projectionPublicationGuardMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff || + !input.projectionPublicationConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff || + !input.projectionPublicationGuardResultHandoffMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff || + !input.projectionPublicationGuardResultConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff || + !input.projectionPublicationGuardResultHandoffReadinessProjectionMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff || + !input.projectionPublicationGuardResultHandoffReadinessConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff || + !input.projectionPublicationGuardResultHandoffReadinessProjectionStatusHandoffMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff || + !input.projectionPublicationGuardResultHandoffReadinessProjectionStatusConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff || + !input.projectionPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff || + !input.projectionPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff || + !input.projectionPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff || + !input.projectionPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff || + result.ownerName != resultHandoff.ownerName || result.handoffId != resultHandoff.handoffId || + result.loadCallbackBoundaryName != resultHandoff.loadCallbackBoundaryName || + result.callbackBindingId != resultHandoff.callbackBindingId || result.callbackName != resultHandoff.callbackName || + result.guardId != resultHandoff.guardId || result.refusalResultId != resultHandoff.refusalResultId || + result.propagationId != resultHandoff.propagationId || result.dispatchHandoffId != resultHandoff.dispatchHandoffId || + result.statusRecordId != resultHandoff.statusRecordId || result.consumerReadinessId != resultHandoff.consumerReadinessId || + result.consumerName != resultHandoff.consumerName || result.dispatchConsumptionGuardId != resultHandoff.dispatchConsumptionGuardId || + result.dispatchConsumerName != resultHandoff.dispatchConsumerName || result.resultHandoffId != resultHandoff.resultHandoffId || + result.resultConsumerName != resultHandoff.resultConsumerName || result.readinessProjectionId != resultHandoff.readinessProjectionId || + result.readinessConsumerName != resultHandoff.readinessConsumerName || result.statusHandoffId != resultHandoff.statusHandoffId || + result.statusConsumerName != resultHandoff.statusConsumerName || result.publicationGuardId != resultHandoff.publicationGuardId || + result.publicationConsumerName != resultHandoff.publicationConsumerName || + result.publicationGuardResultHandoffId != resultHandoff.publicationGuardResultHandoffId || + result.publicationGuardResultConsumerName != resultHandoff.publicationGuardResultConsumerName || + result.publicationGuardResultHandoffReadinessProjectionId != resultHandoff.publicationGuardResultHandoffReadinessProjectionId || + result.publicationGuardResultHandoffReadinessConsumerName != resultHandoff.publicationGuardResultHandoffReadinessConsumerName || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffId != resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffId || + result.publicationGuardResultHandoffReadinessProjectionStatusConsumerName != resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusConsumerName || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId != resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName != resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId != resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName != resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName || + result.adapterName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection requires readiness-projection-to-result-handoff match evidence"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_match_required"); + return result; + } + result.projectionPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffMatchAccepted = true; + + if (!input.disabledPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionRegistered || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionAcceptsResultHandoffEvidence || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionReturnsDisabledReadiness || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlocksDispatchConsumption || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlocksDispatchResultExecution || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlocksStatusPublication || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlocksReadinessPublication || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlocksStatusHandoffPublication || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlocksPublicationGuardPublication || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlocksPublicationGuardResultHandoffPublication || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlocksReadinessProjectionPublication || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlocksStatusHandoffResultPublication || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlocksPublicationGuardResultPublication || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlocksPublicationGuardResultHandoffResultPublication) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection requires disabled readiness-projection evidence"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlockedSummary( + "disabled_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_required"); + return result; + } + result.disabledPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionAccepted = true; + + if (!input.callbackInvocationStillDisabled || !input.callbackInvocationRefused || !input.callbackInvocationRefusalReviewed || + !input.projectionStopsBeforeCallbackInvocation || !input.projectionStopsBeforeCallbackResultExecution || + !input.projectionStopsBeforeDispatchConsumption || !input.projectionStopsBeforeDispatchResultExecution || + !input.projectionStopsBeforeDispatchStatusPublication || !input.projectionStopsBeforeReadinessPublication || + !input.projectionStopsBeforeStatusHandoffPublication || !input.projectionStopsBeforePublicationGuardPublication || + !input.projectionStopsBeforePublicationGuardResultHandoffPublication || + !input.projectionStopsBeforePublicationGuardResultHandoffReadinessProjectionPublication || + !input.projectionStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication || + !input.projectionStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication || + !input.projectionStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication || + !input.projectionStopsBeforeReadinessProjectionPublication || !input.projectionStopsBeforePlatformApi || + !input.projectionRequiresSeparateExecutionBatch) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection must remain disabled before callback, dispatch result execution, status publication, readiness publication, and platform APIs"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_disabled_state_required"); + return result; + } + result.callbackInvocationRefused = true; + result.dispatchConsumptionStillGuarded = true; + result.dispatchResultExecutionBlocked = true; + result.dispatchStatusPublicationBlocked = true; + result.readinessProjectionPublicationBlocked = true; + result.statusHandoffPublicationBlocked = true; + result.publicationGuardPublicationBlocked = true; + result.publicationGuardResultHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationBlocked = true; + result.platformApiPreInvocationBlocked = true; + + if (!input.projectionProducesNoDynamicHandle || !input.projectionStoresNoDynamicHandle || + !input.projectionReleasesNoDynamicHandle || !input.projectionResolvesNoSymbols || + !input.projectionStoresNoSymbolTable || !input.projectionCreatesNoRuntime) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection must not create runtime loader state"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_runtime_state_required"); + return result; + } + result.disabledPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStateAccepted = true; + + if (!input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionFailureMappingReviewed) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection requires disabled readiness-projection failure mapping review"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_failure_mapping_required"); + return result; + } + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionFailureMappingAccepted = true; + + if (!input.unloadExecutionStillDisabled || !input.symbolResolutionStillDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection must keep unload and symbol resolution disabled"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlockedSummary("non_load_execution_enabled"); + return result; + } + result.unloadExecutionBlocked = true; + result.symbolResolutionBlocked = true; + + if (!input.productionLoaderExecutionDisabled || !input.realAdapterExecutionDisabled || !input.loadOnlyExecutionDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection must keep real loader execution disabled"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlockedSummary("production_loader_enabled"); + return result; + } + result.productionLoaderDisabled = true; + result.realAdapterExecutionDisabled = true; + result.loadOnlyExecutionDisabled = true; + + if (!input.separateExecutionBatchRequired) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection requires a separate execution batch"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlockedSummary("separate_execution_batch_required"); + return result; + } + result.separateExecutionBatchRequired = true; + + result.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionReady = true; + result.status = LiteBridgeRuntimeStatus::Ready; + result.ok = true; + result.summary = std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection=ready; platform=") + + result.platform + "; scope=load-only-disabled-callback-refusal-propagation-consumer-readiness-dispatch-consumption-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection; execution=disabled"; + return result; +} + +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffInput& input) +{ + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffResult result; + result.status = LiteBridgeRuntimeStatus::Configured; + const auto& readinessProjection = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection; + result.platform = normalizedPlatform(input.platform.empty() ? readinessProjection.platform : input.platform); + result.adapterName = input.adapterName.empty() ? readinessProjection.adapterName : input.adapterName; + result.ownerName = input.ownerName.empty() ? readinessProjection.ownerName : input.ownerName; + result.handoffId = input.handoffId.empty() ? readinessProjection.handoffId : input.handoffId; + result.loadCallbackBoundaryName = input.loadCallbackBoundaryName.empty() ? readinessProjection.loadCallbackBoundaryName : input.loadCallbackBoundaryName; + result.callbackBindingId = input.callbackBindingId.empty() ? readinessProjection.callbackBindingId : input.callbackBindingId; + result.callbackName = input.callbackName.empty() ? readinessProjection.callbackName : input.callbackName; + result.guardId = input.guardId.empty() ? readinessProjection.guardId : input.guardId; + result.refusalResultId = input.refusalResultId.empty() ? readinessProjection.refusalResultId : input.refusalResultId; + result.propagationId = input.propagationId.empty() ? readinessProjection.propagationId : input.propagationId; + result.dispatchHandoffId = input.dispatchHandoffId.empty() ? readinessProjection.dispatchHandoffId : input.dispatchHandoffId; + result.statusRecordId = input.statusRecordId.empty() ? readinessProjection.statusRecordId : input.statusRecordId; + result.consumerReadinessId = input.consumerReadinessId.empty() ? readinessProjection.consumerReadinessId : input.consumerReadinessId; + result.consumerName = input.consumerName.empty() ? readinessProjection.consumerName : input.consumerName; + result.dispatchConsumptionGuardId = input.dispatchConsumptionGuardId.empty() ? readinessProjection.dispatchConsumptionGuardId : input.dispatchConsumptionGuardId; + result.dispatchConsumerName = input.dispatchConsumerName.empty() ? readinessProjection.dispatchConsumerName : input.dispatchConsumerName; + result.resultHandoffId = input.resultHandoffId.empty() ? readinessProjection.resultHandoffId : input.resultHandoffId; + result.resultConsumerName = input.resultConsumerName.empty() ? readinessProjection.resultConsumerName : input.resultConsumerName; + result.readinessProjectionId = input.readinessProjectionId.empty() ? readinessProjection.readinessProjectionId : input.readinessProjectionId; + result.readinessConsumerName = input.readinessConsumerName.empty() ? readinessProjection.readinessConsumerName : input.readinessConsumerName; + result.statusHandoffId = input.statusHandoffId.empty() ? readinessProjection.statusHandoffId : input.statusHandoffId; + result.statusConsumerName = input.statusConsumerName.empty() ? readinessProjection.statusConsumerName : input.statusConsumerName; + result.publicationGuardId = input.publicationGuardId.empty() ? readinessProjection.publicationGuardId : input.publicationGuardId; + result.publicationConsumerName = input.publicationConsumerName.empty() ? readinessProjection.publicationConsumerName : input.publicationConsumerName; + result.publicationGuardResultHandoffId = input.publicationGuardResultHandoffId.empty() ? readinessProjection.publicationGuardResultHandoffId : input.publicationGuardResultHandoffId; + result.publicationGuardResultConsumerName = input.publicationGuardResultConsumerName.empty() ? readinessProjection.publicationGuardResultConsumerName : input.publicationGuardResultConsumerName; + result.publicationGuardResultHandoffReadinessProjectionId = input.publicationGuardResultHandoffReadinessProjectionId.empty() ? readinessProjection.publicationGuardResultHandoffReadinessProjectionId : input.publicationGuardResultHandoffReadinessProjectionId; + result.publicationGuardResultHandoffReadinessConsumerName = input.publicationGuardResultHandoffReadinessConsumerName.empty() ? readinessProjection.publicationGuardResultHandoffReadinessConsumerName : input.publicationGuardResultHandoffReadinessConsumerName; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffId = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffId.empty() ? readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffId : input.publicationGuardResultHandoffReadinessProjectionStatusHandoffId; + result.publicationGuardResultHandoffReadinessProjectionStatusConsumerName = input.publicationGuardResultHandoffReadinessProjectionStatusConsumerName.empty() ? readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusConsumerName : input.publicationGuardResultHandoffReadinessProjectionStatusConsumerName; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId.empty() ? readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId : input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName.empty() ? readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName : input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId.empty() ? readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId : input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName.empty() ? readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName : input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId.empty() ? readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId : input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName.empty() ? readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName : input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName; + + result.noCallbackInvocationAttempted = !input.callbackInvocationAttempted; + result.noCallbackResultExecutionAttempted = !input.callbackResultExecutionAttempted; + result.noDispatchHandoffExecutionAttempted = !input.dispatchHandoffExecutionAttempted; + result.noDispatchStatusPublicationAttempted = !input.dispatchStatusPublicationAttempted; + result.noDispatchConsumerConsumptionAttempted = !input.dispatchConsumerConsumptionAttempted; + result.noDispatchResultExecutionAttempted = !input.dispatchResultExecutionAttempted; + result.noResultHandoffStatusPublicationAttempted = !input.resultHandoffStatusPublicationAttempted; + result.noReadinessProjectionStatusPublicationAttempted = !input.readinessProjectionStatusPublicationAttempted; + result.noStatusHandoffPublicationAttempted = !input.statusHandoffPublicationAttempted; + result.noPublicationGuardPublicationAttempted = !input.publicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noRuntimePlatformDynamicLibraryLoaded = !input.runtimePlatformLoadAttempted; + result.noRuntimePlatformDynamicLibraryUnloaded = !input.runtimePlatformUnloadAttempted; + result.noRuntimePlatformSymbolResolution = !input.runtimePlatformSymbolResolutionAttempted; + result.noSdxlCalls = !input.sdxlCallRequested; + result.noBridgeCalls = !input.bridgeCallRequested; + result.noServerConnectivityChecked = !input.serverConnectivityCheckRequested; + result.noWalletLifecycle = !input.walletLifecycleRequested; + result.noSyncStarted = !input.syncRequested; + result.noSyncStatusPolled = !input.syncStatusPollingRequested; + result.noWorkerQueueEnqueue = !input.workerQueueRequested; + result.noWalletStateMutation = !input.walletStateMutationRequested; + result.noWalletPersistence = !input.walletPersistenceRequested; + result.noSettingsPersistence = !input.settingsWriteRequested; + result.noSendImportExportExecution = !input.sendImportExportRequested; + result.noArtifactMutation = !input.artifactMutationRequested; + + if (!result.noCallbackInvocationAttempted || !result.noCallbackResultExecutionAttempted || + !result.noDispatchHandoffExecutionAttempted || !result.noDispatchStatusPublicationAttempted || + !result.noDispatchConsumerConsumptionAttempted || !result.noDispatchResultExecutionAttempted || + !result.noResultHandoffStatusPublicationAttempted || !result.noReadinessProjectionStatusPublicationAttempted || + !result.noStatusHandoffPublicationAttempted || !result.noPublicationGuardPublicationAttempted || + !result.noPublicationGuardResultHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !result.noRuntimePlatformDynamicLibraryLoaded || !result.noRuntimePlatformDynamicLibraryUnloaded || + !result.noRuntimePlatformSymbolResolution) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff must stop before callback, dispatch result execution, status publication, readiness publication, status-handoff publication, and platform loader APIs"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_or_platform_api_attempted"); + return result; + } + + if (!result.noSdxlCalls || !result.noBridgeCalls || !result.noServerConnectivityChecked || + !result.noWalletLifecycle || !result.noSyncStarted || !result.noSyncStatusPolled || + !result.noWorkerQueueEnqueue || !result.noWalletStateMutation || !result.noWalletPersistence || + !result.noSettingsPersistence || !result.noSendImportExportExecution || !result.noArtifactMutation) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff must not request wallet runtime behavior"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary("runtime_action_requested"); + return result; + } + + if (result.platform.empty()) { + result.status = LiteBridgeRuntimeStatus::Unavailable; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff requires a target platform"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary("platform_missing"); + return result; + } + + if (isMacosPlatform(result.platform)) { + result.macosDeferred = true; + result.status = LiteBridgeRuntimeStatus::Unavailable; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffIssue( + result, + input.macosDeferredByOperator + ? "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff is deferred by operator request" + : "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff requires a reviewed builder before promotion"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary("macos_deferred"); + return result; + } + + const bool linuxPlatform = isLinuxPlatform(result.platform); + const bool windowsPlatform = isWindowsPlatform(result.platform); + if (!linuxPlatform && !windowsPlatform) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff supports only Linux and Windows in batch 36"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary("unsupported_platform"); + return result; + } + result.platformAccepted = true; + result.linuxPlatformAccepted = linuxPlatform; + result.windowsPlatformAccepted = windowsPlatform; + + if (!input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionAccepted || + !readinessProjection.ok || + !readinessProjection.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionReady || + readinessProjection.status != LiteBridgeRuntimeStatus::Ready || + readinessProjection.platform != result.platform || + !readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffAccepted || + !readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionRecordAccepted || + !readinessProjection.projectionPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffMatchAccepted || + !readinessProjection.disabledPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionAccepted || + !readinessProjection.callbackInvocationRefused || !readinessProjection.dispatchConsumptionStillGuarded || + !readinessProjection.dispatchResultExecutionBlocked || !readinessProjection.dispatchStatusPublicationBlocked || + !readinessProjection.readinessProjectionPublicationBlocked || !readinessProjection.statusHandoffPublicationBlocked || + !readinessProjection.publicationGuardPublicationBlocked || !readinessProjection.publicationGuardResultHandoffPublicationBlocked || + !readinessProjection.publicationGuardResultHandoffReadinessProjectionPublicationBlocked || + !readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked || + !readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked || + !readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationBlocked || + !readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationBlocked || + !readinessProjection.platformApiPreInvocationBlocked || + !readinessProjection.disabledPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStateAccepted || + !readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionFailureMappingAccepted || + !readinessProjection.unloadExecutionBlocked || !readinessProjection.symbolResolutionBlocked || + !readinessProjection.productionLoaderDisabled || !readinessProjection.realAdapterExecutionDisabled || + !readinessProjection.loadOnlyExecutionDisabled || !readinessProjection.separateExecutionBatchRequired || + !readinessProjection.noCallbackInvocationAttempted || !readinessProjection.noCallbackResultExecutionAttempted || + !readinessProjection.noDispatchHandoffExecutionAttempted || !readinessProjection.noDispatchStatusPublicationAttempted || + !readinessProjection.noDispatchConsumerConsumptionAttempted || !readinessProjection.noDispatchResultExecutionAttempted || + !readinessProjection.noResultHandoffStatusPublicationAttempted || !readinessProjection.noReadinessProjectionStatusPublicationAttempted || + !readinessProjection.noStatusHandoffPublicationAttempted || !readinessProjection.noPublicationGuardPublicationAttempted || + !readinessProjection.noPublicationGuardResultHandoffPublicationAttempted || + !readinessProjection.noPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !readinessProjection.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !readinessProjection.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted || + !readinessProjection.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted || + !readinessProjection.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !readinessProjection.noRuntimePlatformDynamicLibraryLoaded || !readinessProjection.noRuntimePlatformDynamicLibraryUnloaded || + !readinessProjection.noRuntimePlatformSymbolResolution) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff requires matching ready disabled readiness-projection evidence"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_required"); + return result; + } + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionAccepted = true; + + if (!input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffReviewed || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffRecorded || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffDisabled || + input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId.empty() || + input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff requires a reviewed disabled status-handoff record"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_required"); + return result; + } + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffRecordAccepted = true; + + if (!input.statusHandoffOwnerMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection || + !input.statusHandoffBoundaryMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection || + !input.statusHandoffCallbackMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection || + !input.statusHandoffPreInvocationGuardMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection || + !input.statusHandoffRefusalResultMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection || + !input.statusHandoffPropagationMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection || + !input.statusHandoffDispatchHandoffMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection || + !input.statusHandoffStatusRecordMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection || + !input.statusHandoffConsumerReadinessMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection || + !input.statusHandoffConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection || + !input.statusHandoffDispatchConsumptionGuardMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection || + !input.statusHandoffDispatchConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection || + !input.statusHandoffResultHandoffMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection || + !input.statusHandoffResultConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection || + !input.statusHandoffReadinessProjectionMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection || + !input.statusHandoffReadinessConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection || + !input.statusHandoffStatusHandoffMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection || + !input.statusHandoffStatusConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection || + !input.statusHandoffPublicationGuardMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection || + !input.statusHandoffPublicationConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection || + !input.statusHandoffPublicationGuardResultHandoffMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection || + !input.statusHandoffPublicationGuardResultConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection || + !input.statusHandoffPublicationGuardResultHandoffReadinessProjectionMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection || + !input.statusHandoffPublicationGuardResultHandoffReadinessConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection || + !input.statusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection || + !input.statusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection || + !input.statusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection || + !input.statusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection || + !input.statusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection || + !input.statusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection || + !input.statusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection || + !input.statusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection || + result.ownerName != readinessProjection.ownerName || result.handoffId != readinessProjection.handoffId || + result.loadCallbackBoundaryName != readinessProjection.loadCallbackBoundaryName || + result.callbackBindingId != readinessProjection.callbackBindingId || result.callbackName != readinessProjection.callbackName || + result.guardId != readinessProjection.guardId || result.refusalResultId != readinessProjection.refusalResultId || + result.propagationId != readinessProjection.propagationId || result.dispatchHandoffId != readinessProjection.dispatchHandoffId || + result.statusRecordId != readinessProjection.statusRecordId || result.consumerReadinessId != readinessProjection.consumerReadinessId || + result.consumerName != readinessProjection.consumerName || result.dispatchConsumptionGuardId != readinessProjection.dispatchConsumptionGuardId || + result.dispatchConsumerName != readinessProjection.dispatchConsumerName || result.resultHandoffId != readinessProjection.resultHandoffId || + result.resultConsumerName != readinessProjection.resultConsumerName || result.readinessProjectionId != readinessProjection.readinessProjectionId || + result.readinessConsumerName != readinessProjection.readinessConsumerName || result.statusHandoffId != readinessProjection.statusHandoffId || + result.statusConsumerName != readinessProjection.statusConsumerName || result.publicationGuardId != readinessProjection.publicationGuardId || + result.publicationConsumerName != readinessProjection.publicationConsumerName || + result.publicationGuardResultHandoffId != readinessProjection.publicationGuardResultHandoffId || + result.publicationGuardResultConsumerName != readinessProjection.publicationGuardResultConsumerName || + result.publicationGuardResultHandoffReadinessProjectionId != readinessProjection.publicationGuardResultHandoffReadinessProjectionId || + result.publicationGuardResultHandoffReadinessConsumerName != readinessProjection.publicationGuardResultHandoffReadinessConsumerName || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffId != readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffId || + result.publicationGuardResultHandoffReadinessProjectionStatusConsumerName != readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusConsumerName || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId != readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName != readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId != readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName != readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId != readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName != readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName || + result.adapterName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff requires status-handoff-to-readiness-projection match evidence"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_match_required"); + return result; + } + result.statusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionMatchAccepted = true; + + if (!input.disabledPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffRegistered || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffAcceptsReadinessProjectionEvidence || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffReturnsDisabledStatus || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlocksDispatchConsumption || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlocksDispatchResultExecution || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlocksStatusPublication || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlocksReadinessPublication || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlocksStatusHandoffPublication || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlocksPublicationGuardPublication || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlocksPublicationGuardResultHandoffPublication || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlocksReadinessProjectionPublication || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlocksStatusHandoffResultPublication || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlocksPublicationGuardResultPublication || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlocksPublicationGuardResultHandoffResultPublication || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlocksPublicationGuardResultHandoffReadinessProjectionPublication) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff requires disabled status-handoff evidence"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary( + "disabled_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_required"); + return result; + } + result.disabledPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffAccepted = true; + + if (!input.callbackInvocationStillDisabled || !input.callbackInvocationRefused || !input.callbackInvocationRefusalReviewed || + !input.statusHandoffStopsBeforeCallbackInvocation || !input.statusHandoffStopsBeforeCallbackResultExecution || + !input.statusHandoffStopsBeforeDispatchConsumption || !input.statusHandoffStopsBeforeDispatchResultExecution || + !input.statusHandoffStopsBeforeDispatchStatusPublication || !input.statusHandoffStopsBeforeReadinessPublication || + !input.statusHandoffStopsBeforeStatusHandoffPublication || !input.statusHandoffStopsBeforePublicationGuardPublication || + !input.statusHandoffStopsBeforePublicationGuardResultHandoffPublication || + !input.statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionPublication || + !input.statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication || + !input.statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication || + !input.statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication || + !input.statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication || + !input.statusHandoffStopsBeforeStatusPublication || !input.statusHandoffStopsBeforePlatformApi || + !input.statusHandoffRequiresSeparateExecutionBatch) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff must remain disabled before callback, dispatch result execution, status publication, readiness publication, and platform APIs"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_disabled_state_required"); + return result; + } + result.callbackInvocationRefused = true; + result.dispatchConsumptionStillGuarded = true; + result.dispatchResultExecutionBlocked = true; + result.dispatchStatusPublicationBlocked = true; + result.readinessProjectionPublicationBlocked = true; + result.statusHandoffPublicationBlocked = true; + result.publicationGuardPublicationBlocked = true; + result.publicationGuardResultHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked = true; + result.platformApiPreInvocationBlocked = true; + + if (!input.statusHandoffProducesNoDynamicHandle || !input.statusHandoffStoresNoDynamicHandle || + !input.statusHandoffReleasesNoDynamicHandle || !input.statusHandoffResolvesNoSymbols || + !input.statusHandoffStoresNoSymbolTable || !input.statusHandoffCreatesNoRuntime) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff must not create runtime loader state"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_runtime_state_required"); + return result; + } + result.disabledPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffStateAccepted = true; + + if (!input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffFailureMappingReviewed) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff requires disabled status-handoff failure mapping review"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_failure_mapping_required"); + return result; + } + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffFailureMappingAccepted = true; + + if (!input.unloadExecutionStillDisabled || !input.symbolResolutionStillDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff must keep unload and symbol resolution disabled"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary("non_load_execution_enabled"); + return result; + } + result.unloadExecutionBlocked = true; + result.symbolResolutionBlocked = true; + + if (!input.productionLoaderExecutionDisabled || !input.realAdapterExecutionDisabled || !input.loadOnlyExecutionDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff must keep real loader execution disabled"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary("production_loader_enabled"); + return result; + } + result.productionLoaderDisabled = true; + result.realAdapterExecutionDisabled = true; + result.loadOnlyExecutionDisabled = true; + + if (!input.separateExecutionBatchRequired) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff requires a separate execution batch"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary("separate_execution_batch_required"); + return result; + } + result.separateExecutionBatchRequired = true; + + result.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffReady = true; + result.status = LiteBridgeRuntimeStatus::Ready; + result.ok = true; + result.summary = std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff=ready; platform=") + + result.platform + "; scope=load-only-disabled-callback-refusal-propagation-consumer-readiness-dispatch-consumption-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff; execution=disabled"; + return result; +} + +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardInput& input) +{ + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResult result; + result.status = LiteBridgeRuntimeStatus::Configured; + const auto& statusHandoff = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff; + const auto select = [](const std::string& inputValue, const std::string& upstreamValue) { + return inputValue.empty() ? upstreamValue : inputValue; + }; + + result.platform = normalizedPlatform(input.platform.empty() ? statusHandoff.platform : input.platform); + result.adapterName = select(input.adapterName, statusHandoff.adapterName); + result.ownerName = select(input.ownerName, statusHandoff.ownerName); + result.handoffId = select(input.handoffId, statusHandoff.handoffId); + result.loadCallbackBoundaryName = select(input.loadCallbackBoundaryName, statusHandoff.loadCallbackBoundaryName); + result.callbackBindingId = select(input.callbackBindingId, statusHandoff.callbackBindingId); + result.callbackName = select(input.callbackName, statusHandoff.callbackName); + result.guardId = select(input.guardId, statusHandoff.guardId); + result.refusalResultId = select(input.refusalResultId, statusHandoff.refusalResultId); + result.propagationId = select(input.propagationId, statusHandoff.propagationId); + result.dispatchHandoffId = select(input.dispatchHandoffId, statusHandoff.dispatchHandoffId); + result.statusRecordId = select(input.statusRecordId, statusHandoff.statusRecordId); + result.consumerReadinessId = select(input.consumerReadinessId, statusHandoff.consumerReadinessId); + result.consumerName = select(input.consumerName, statusHandoff.consumerName); + result.dispatchConsumptionGuardId = select(input.dispatchConsumptionGuardId, statusHandoff.dispatchConsumptionGuardId); + result.dispatchConsumerName = select(input.dispatchConsumerName, statusHandoff.dispatchConsumerName); + result.resultHandoffId = select(input.resultHandoffId, statusHandoff.resultHandoffId); + result.resultConsumerName = select(input.resultConsumerName, statusHandoff.resultConsumerName); + result.readinessProjectionId = select(input.readinessProjectionId, statusHandoff.readinessProjectionId); + result.readinessConsumerName = select(input.readinessConsumerName, statusHandoff.readinessConsumerName); + result.statusHandoffId = select(input.statusHandoffId, statusHandoff.statusHandoffId); + result.statusConsumerName = select(input.statusConsumerName, statusHandoff.statusConsumerName); + result.publicationGuardId = select(input.publicationGuardId, statusHandoff.publicationGuardId); + result.publicationConsumerName = select(input.publicationConsumerName, statusHandoff.publicationConsumerName); + result.publicationGuardResultHandoffId = select(input.publicationGuardResultHandoffId, statusHandoff.publicationGuardResultHandoffId); + result.publicationGuardResultConsumerName = select(input.publicationGuardResultConsumerName, statusHandoff.publicationGuardResultConsumerName); + result.publicationGuardResultHandoffReadinessProjectionId = select(input.publicationGuardResultHandoffReadinessProjectionId, statusHandoff.publicationGuardResultHandoffReadinessProjectionId); + result.publicationGuardResultHandoffReadinessConsumerName = select(input.publicationGuardResultHandoffReadinessConsumerName, statusHandoff.publicationGuardResultHandoffReadinessConsumerName); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffId = select(input.publicationGuardResultHandoffReadinessProjectionStatusHandoffId, statusHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffId); + result.publicationGuardResultHandoffReadinessProjectionStatusConsumerName = select(input.publicationGuardResultHandoffReadinessProjectionStatusConsumerName, statusHandoff.publicationGuardResultHandoffReadinessProjectionStatusConsumerName); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId = select(input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId, statusHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName = select(input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName, statusHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId = select(input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId, statusHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName = select(input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName, statusHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId = select(input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId, statusHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName = select(input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName, statusHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId = select(input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId, statusHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName = select(input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName, statusHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName; + + result.noCallbackInvocationAttempted = !input.callbackInvocationAttempted; + result.noCallbackResultExecutionAttempted = !input.callbackResultExecutionAttempted; + result.noDispatchHandoffExecutionAttempted = !input.dispatchHandoffExecutionAttempted; + result.noDispatchStatusPublicationAttempted = !input.dispatchStatusPublicationAttempted; + result.noDispatchConsumerConsumptionAttempted = !input.dispatchConsumerConsumptionAttempted; + result.noDispatchResultExecutionAttempted = !input.dispatchResultExecutionAttempted; + result.noResultHandoffStatusPublicationAttempted = !input.resultHandoffStatusPublicationAttempted; + result.noReadinessProjectionStatusPublicationAttempted = !input.readinessProjectionStatusPublicationAttempted; + result.noStatusHandoffPublicationAttempted = !input.statusHandoffPublicationAttempted; + result.noPublicationGuardPublicationAttempted = !input.publicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted; + result.noRuntimePlatformDynamicLibraryLoaded = !input.runtimePlatformLoadAttempted; + result.noRuntimePlatformDynamicLibraryUnloaded = !input.runtimePlatformUnloadAttempted; + result.noRuntimePlatformSymbolResolution = !input.runtimePlatformSymbolResolutionAttempted; + result.noSdxlCalls = !input.sdxlCallRequested; + result.noBridgeCalls = !input.bridgeCallRequested; + result.noServerConnectivityChecked = !input.serverConnectivityCheckRequested; + result.noWalletLifecycle = !input.walletLifecycleRequested; + result.noSyncStarted = !input.syncRequested; + result.noSyncStatusPolled = !input.syncStatusPollingRequested; + result.noWorkerQueueEnqueue = !input.workerQueueRequested; + result.noWalletStateMutation = !input.walletStateMutationRequested; + result.noWalletPersistence = !input.walletPersistenceRequested; + result.noSettingsPersistence = !input.settingsWriteRequested; + result.noSendImportExportExecution = !input.sendImportExportRequested; + result.noArtifactMutation = !input.artifactMutationRequested; + + if (!result.noCallbackInvocationAttempted || !result.noCallbackResultExecutionAttempted || + !result.noDispatchHandoffExecutionAttempted || !result.noDispatchStatusPublicationAttempted || + !result.noDispatchConsumerConsumptionAttempted || !result.noDispatchResultExecutionAttempted || + !result.noResultHandoffStatusPublicationAttempted || !result.noReadinessProjectionStatusPublicationAttempted || + !result.noStatusHandoffPublicationAttempted || !result.noPublicationGuardPublicationAttempted || + !result.noPublicationGuardResultHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted || + !result.noRuntimePlatformDynamicLibraryLoaded || !result.noRuntimePlatformDynamicLibraryUnloaded || + !result.noRuntimePlatformSymbolResolution) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard must stop before callback, dispatch result execution, status publication, readiness publication, publication-guard publication, and platform loader APIs"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_or_platform_api_attempted"); + return result; + } + + if (!result.noSdxlCalls || !result.noBridgeCalls || !result.noServerConnectivityChecked || + !result.noWalletLifecycle || !result.noSyncStarted || !result.noSyncStatusPolled || + !result.noWorkerQueueEnqueue || !result.noWalletStateMutation || !result.noWalletPersistence || + !result.noSettingsPersistence || !result.noSendImportExportExecution || !result.noArtifactMutation) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard must not request wallet runtime behavior"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlockedSummary("runtime_action_requested"); + return result; + } + + if (result.platform.empty()) { + result.status = LiteBridgeRuntimeStatus::Unavailable; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard requires a target platform"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlockedSummary("platform_missing"); + return result; + } + + if (isMacosPlatform(result.platform)) { + result.macosDeferred = true; + result.status = LiteBridgeRuntimeStatus::Unavailable; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardIssue( + result, + input.macosDeferredByOperator + ? "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard is deferred by operator request" + : "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard requires a reviewed builder before promotion"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlockedSummary("macos_deferred"); + return result; + } + + const bool linuxPlatform = isLinuxPlatform(result.platform); + const bool windowsPlatform = isWindowsPlatform(result.platform); + if (!linuxPlatform && !windowsPlatform) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard supports only Linux and Windows in batch 37"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlockedSummary("unsupported_platform"); + return result; + } + result.platformAccepted = true; + result.linuxPlatformAccepted = linuxPlatform; + result.windowsPlatformAccepted = windowsPlatform; + + if (!input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffAccepted || + !statusHandoff.ok || + !statusHandoff.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffReady || + statusHandoff.status != LiteBridgeRuntimeStatus::Ready || + statusHandoff.platform != result.platform || + !statusHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionAccepted || + !statusHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffRecordAccepted || + !statusHandoff.statusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionMatchAccepted || + !statusHandoff.disabledPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffAccepted || + !statusHandoff.callbackInvocationRefused || !statusHandoff.dispatchConsumptionStillGuarded || + !statusHandoff.dispatchResultExecutionBlocked || !statusHandoff.dispatchStatusPublicationBlocked || + !statusHandoff.readinessProjectionPublicationBlocked || !statusHandoff.statusHandoffPublicationBlocked || + !statusHandoff.publicationGuardPublicationBlocked || !statusHandoff.publicationGuardResultHandoffPublicationBlocked || + !statusHandoff.publicationGuardResultHandoffReadinessProjectionPublicationBlocked || + !statusHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked || + !statusHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked || + !statusHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationBlocked || + !statusHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationBlocked || + !statusHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked || + !statusHandoff.platformApiPreInvocationBlocked || + !statusHandoff.disabledPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffStateAccepted || + !statusHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffFailureMappingAccepted || + !statusHandoff.unloadExecutionBlocked || !statusHandoff.symbolResolutionBlocked || + !statusHandoff.productionLoaderDisabled || !statusHandoff.realAdapterExecutionDisabled || + !statusHandoff.loadOnlyExecutionDisabled || !statusHandoff.separateExecutionBatchRequired || + !statusHandoff.noCallbackInvocationAttempted || !statusHandoff.noCallbackResultExecutionAttempted || + !statusHandoff.noDispatchHandoffExecutionAttempted || !statusHandoff.noDispatchStatusPublicationAttempted || + !statusHandoff.noDispatchConsumerConsumptionAttempted || !statusHandoff.noDispatchResultExecutionAttempted || + !statusHandoff.noResultHandoffStatusPublicationAttempted || !statusHandoff.noReadinessProjectionStatusPublicationAttempted || + !statusHandoff.noStatusHandoffPublicationAttempted || !statusHandoff.noPublicationGuardPublicationAttempted || + !statusHandoff.noPublicationGuardResultHandoffPublicationAttempted || + !statusHandoff.noPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !statusHandoff.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !statusHandoff.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted || + !statusHandoff.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted || + !statusHandoff.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !statusHandoff.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !statusHandoff.noRuntimePlatformDynamicLibraryLoaded || !statusHandoff.noRuntimePlatformDynamicLibraryUnloaded || + !statusHandoff.noRuntimePlatformSymbolResolution) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard requires matching ready disabled status-handoff evidence"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_required"); + return result; + } + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffAccepted = true; + + if (!input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardReviewed || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardRecorded || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardDisabled || + input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId.empty() || + input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard requires a reviewed disabled publication-guard record"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_required"); + return result; + } + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardRecordAccepted = true; + + if (!input.publicationGuardOwnerMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff || + !input.publicationGuardBoundaryMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff || + !input.publicationGuardCallbackMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff || + !input.publicationGuardPreInvocationGuardMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff || + !input.publicationGuardRefusalResultMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff || + !input.publicationGuardPropagationMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff || + !input.publicationGuardDispatchHandoffMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff || + !input.publicationGuardStatusRecordMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff || + !input.publicationGuardConsumerReadinessMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff || + !input.publicationGuardConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff || + !input.publicationGuardDispatchConsumptionGuardMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff || + !input.publicationGuardDispatchConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff || + !input.publicationGuardResultHandoffMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff || + !input.publicationGuardResultConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff || + !input.publicationGuardReadinessProjectionMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff || + !input.publicationGuardReadinessConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff || + !input.publicationGuardStatusHandoffMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff || + !input.publicationGuardStatusConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff || + !input.publicationGuardPublicationGuardMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff || + !input.publicationGuardPublicationConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff || + !input.publicationGuardPublicationGuardResultHandoffMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff || + !input.publicationGuardPublicationGuardResultConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff || + !input.publicationGuardPublicationGuardResultHandoffReadinessProjectionMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff || + !input.publicationGuardPublicationGuardResultHandoffReadinessConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff || + !input.publicationGuardPublicationGuardResultHandoffReadinessProjectionStatusHandoffMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff || + !input.publicationGuardPublicationGuardResultHandoffReadinessProjectionStatusConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff || + !input.publicationGuardPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff || + !input.publicationGuardPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff || + !input.publicationGuardPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff || + !input.publicationGuardPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff || + !input.publicationGuardPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff || + !input.publicationGuardPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff || + !input.publicationGuardPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff || + !input.publicationGuardPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff || + result.ownerName != statusHandoff.ownerName || result.handoffId != statusHandoff.handoffId || + result.loadCallbackBoundaryName != statusHandoff.loadCallbackBoundaryName || + result.callbackBindingId != statusHandoff.callbackBindingId || result.callbackName != statusHandoff.callbackName || + result.guardId != statusHandoff.guardId || result.refusalResultId != statusHandoff.refusalResultId || + result.propagationId != statusHandoff.propagationId || result.dispatchHandoffId != statusHandoff.dispatchHandoffId || + result.statusRecordId != statusHandoff.statusRecordId || result.consumerReadinessId != statusHandoff.consumerReadinessId || + result.consumerName != statusHandoff.consumerName || result.dispatchConsumptionGuardId != statusHandoff.dispatchConsumptionGuardId || + result.dispatchConsumerName != statusHandoff.dispatchConsumerName || result.resultHandoffId != statusHandoff.resultHandoffId || + result.resultConsumerName != statusHandoff.resultConsumerName || result.readinessProjectionId != statusHandoff.readinessProjectionId || + result.readinessConsumerName != statusHandoff.readinessConsumerName || result.statusHandoffId != statusHandoff.statusHandoffId || + result.statusConsumerName != statusHandoff.statusConsumerName || result.publicationGuardId != statusHandoff.publicationGuardId || + result.publicationConsumerName != statusHandoff.publicationConsumerName || + result.publicationGuardResultHandoffId != statusHandoff.publicationGuardResultHandoffId || + result.publicationGuardResultConsumerName != statusHandoff.publicationGuardResultConsumerName || + result.publicationGuardResultHandoffReadinessProjectionId != statusHandoff.publicationGuardResultHandoffReadinessProjectionId || + result.publicationGuardResultHandoffReadinessConsumerName != statusHandoff.publicationGuardResultHandoffReadinessConsumerName || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffId != statusHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffId || + result.publicationGuardResultHandoffReadinessProjectionStatusConsumerName != statusHandoff.publicationGuardResultHandoffReadinessProjectionStatusConsumerName || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId != statusHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName != statusHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId != statusHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName != statusHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId != statusHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName != statusHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId != statusHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName != statusHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName || + result.adapterName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard requires publication-guard-to-status-handoff match evidence"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_match_required"); + return result; + } + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardMatchAccepted = true; + + if (!input.disabledPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardRegistered || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardAcceptsStatusHandoffEvidence || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardReturnsDisabledPublication || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlocksDispatchConsumption || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlocksDispatchResultExecution || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlocksStatusPublication || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlocksReadinessPublication || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlocksStatusHandoffPublication || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlocksPublicationGuardPublication || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlocksPublicationGuardResultHandoffPublication || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlocksPublicationGuardResultHandoffReadinessProjectionPublication || + !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard requires disabled publication-guard evidence"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlockedSummary( + "disabled_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_required"); + return result; + } + result.disabledPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardAccepted = true; + + if (!input.callbackInvocationStillDisabled || !input.callbackInvocationRefused || !input.callbackInvocationRefusalReviewed || + !input.publicationGuardStopsBeforeCallbackInvocation || !input.publicationGuardStopsBeforeCallbackResultExecution || + !input.publicationGuardStopsBeforeDispatchConsumption || !input.publicationGuardStopsBeforeDispatchResultExecution || + !input.publicationGuardStopsBeforeDispatchStatusPublication || !input.publicationGuardStopsBeforeReadinessPublication || + !input.publicationGuardStopsBeforeStatusHandoffPublication || !input.publicationGuardStopsBeforePublicationGuardPublication || + !input.publicationGuardStopsBeforePublicationGuardResultHandoffPublication || + !input.publicationGuardStopsBeforePublicationGuardResultHandoffReadinessProjectionPublication || + !input.publicationGuardStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication || + !input.publicationGuardStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication || + !input.publicationGuardStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication || + !input.publicationGuardStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication || + !input.publicationGuardStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication || + !input.publicationGuardStopsBeforePublication || !input.publicationGuardStopsBeforePlatformApi || + !input.publicationGuardRequiresSeparateExecutionBatch) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard must remain disabled before callback, dispatch result execution, status publication, readiness publication, publication, and platform APIs"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_disabled_state_required"); + return result; + } + result.callbackInvocationRefused = true; + result.dispatchConsumptionStillGuarded = true; + result.dispatchResultExecutionBlocked = true; + result.dispatchStatusPublicationBlocked = true; + result.readinessProjectionPublicationBlocked = true; + result.statusHandoffPublicationBlocked = true; + result.publicationGuardPublicationBlocked = true; + result.publicationGuardResultHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked = true; + result.platformApiPreInvocationBlocked = true; + + if (!input.publicationGuardProducesNoDynamicHandle || !input.publicationGuardStoresNoDynamicHandle || + !input.publicationGuardReleasesNoDynamicHandle || !input.publicationGuardResolvesNoSymbols || + !input.publicationGuardStoresNoSymbolTable || !input.publicationGuardCreatesNoRuntime) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard must not create runtime loader state"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_runtime_state_required"); + return result; + } + result.disabledPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardStateAccepted = true; + + if (!input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardFailureMappingReviewed) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard requires disabled publication-guard failure mapping review"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_failure_mapping_required"); + return result; + } + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardFailureMappingAccepted = true; + + if (!input.unloadExecutionStillDisabled || !input.symbolResolutionStillDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard must keep unload and symbol resolution disabled"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlockedSummary("non_load_execution_enabled"); + return result; + } + result.unloadExecutionBlocked = true; + result.symbolResolutionBlocked = true; + + if (!input.productionLoaderExecutionDisabled || !input.realAdapterExecutionDisabled || !input.loadOnlyExecutionDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard must keep real loader execution disabled"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlockedSummary("production_loader_enabled"); + return result; + } + result.productionLoaderDisabled = true; + result.realAdapterExecutionDisabled = true; + result.loadOnlyExecutionDisabled = true; + + if (!input.separateExecutionBatchRequired) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard requires a separate execution batch"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlockedSummary("separate_execution_batch_required"); + return result; + } + result.separateExecutionBatchRequired = true; + + result.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardReady = true; + result.status = LiteBridgeRuntimeStatus::Ready; + result.ok = true; + result.summary = std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard=ready; platform=") + + result.platform + "; scope=load-only-disabled-callback-refusal-propagation-consumer-readiness-dispatch-consumption-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard; execution=disabled"; + return result; +} + +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffInput& input) +{ + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffResult result; + result.status = LiteBridgeRuntimeStatus::Configured; + const auto& publicationGuard = input.publicationGuard; + const auto select = [](const std::string& inputValue, const std::string& upstreamValue) { + return inputValue.empty() ? upstreamValue : inputValue; + }; + + result.platform = normalizedPlatform(input.platform.empty() ? publicationGuard.platform : input.platform); + result.adapterName = select(input.adapterName, publicationGuard.adapterName); + result.ownerName = select(input.ownerName, publicationGuard.ownerName); + result.handoffId = select(input.handoffId, publicationGuard.handoffId); + result.loadCallbackBoundaryName = select(input.loadCallbackBoundaryName, publicationGuard.loadCallbackBoundaryName); + result.callbackBindingId = select(input.callbackBindingId, publicationGuard.callbackBindingId); + result.callbackName = select(input.callbackName, publicationGuard.callbackName); + result.guardId = select(input.guardId, publicationGuard.guardId); + result.refusalResultId = select(input.refusalResultId, publicationGuard.refusalResultId); + result.propagationId = select(input.propagationId, publicationGuard.propagationId); + result.dispatchHandoffId = select(input.dispatchHandoffId, publicationGuard.dispatchHandoffId); + result.statusRecordId = select(input.statusRecordId, publicationGuard.statusRecordId); + result.consumerReadinessId = select(input.consumerReadinessId, publicationGuard.consumerReadinessId); + result.consumerName = select(input.consumerName, publicationGuard.consumerName); + result.dispatchConsumptionGuardId = select(input.dispatchConsumptionGuardId, publicationGuard.dispatchConsumptionGuardId); + result.dispatchConsumerName = select(input.dispatchConsumerName, publicationGuard.dispatchConsumerName); + result.resultHandoffId = select(input.resultHandoffId, publicationGuard.resultHandoffId); + result.resultConsumerName = select(input.resultConsumerName, publicationGuard.resultConsumerName); + result.readinessProjectionId = select(input.readinessProjectionId, publicationGuard.readinessProjectionId); + result.readinessConsumerName = select(input.readinessConsumerName, publicationGuard.readinessConsumerName); + result.statusHandoffId = select(input.statusHandoffId, publicationGuard.statusHandoffId); + result.statusConsumerName = select(input.statusConsumerName, publicationGuard.statusConsumerName); + result.publicationGuardId = select(input.publicationGuardId, publicationGuard.publicationGuardId); + result.publicationConsumerName = select(input.publicationConsumerName, publicationGuard.publicationConsumerName); + result.publicationGuardResultHandoffId = select(input.publicationGuardResultHandoffId, publicationGuard.publicationGuardResultHandoffId); + result.publicationGuardResultConsumerName = select(input.publicationGuardResultConsumerName, publicationGuard.publicationGuardResultConsumerName); + result.publicationGuardResultHandoffReadinessProjectionId = select(input.publicationGuardResultHandoffReadinessProjectionId, publicationGuard.publicationGuardResultHandoffReadinessProjectionId); + result.publicationGuardResultHandoffReadinessConsumerName = select(input.publicationGuardResultHandoffReadinessConsumerName, publicationGuard.publicationGuardResultHandoffReadinessConsumerName); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffId = select(input.publicationGuardResultHandoffReadinessProjectionStatusHandoffId, publicationGuard.publicationGuardResultHandoffReadinessProjectionStatusHandoffId); + result.publicationGuardResultHandoffReadinessProjectionStatusConsumerName = select(input.publicationGuardResultHandoffReadinessProjectionStatusConsumerName, publicationGuard.publicationGuardResultHandoffReadinessProjectionStatusConsumerName); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId = select(input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId, publicationGuard.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName = select(input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName, publicationGuard.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId = select(input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId, publicationGuard.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName = select(input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName, publicationGuard.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId = select(input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId, publicationGuard.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName = select(input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName, publicationGuard.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId = select(input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId, publicationGuard.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName = select(input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName, publicationGuard.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId = select(input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId, publicationGuard.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName = select(input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName, publicationGuard.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName; + + result.noCallbackInvocationAttempted = !input.callbackInvocationAttempted; + result.noCallbackResultExecutionAttempted = !input.callbackResultExecutionAttempted; + result.noDispatchHandoffExecutionAttempted = !input.dispatchHandoffExecutionAttempted; + result.noDispatchStatusPublicationAttempted = !input.dispatchStatusPublicationAttempted; + result.noDispatchConsumerConsumptionAttempted = !input.dispatchConsumerConsumptionAttempted; + result.noDispatchResultExecutionAttempted = !input.dispatchResultExecutionAttempted; + result.noResultHandoffStatusPublicationAttempted = !input.resultHandoffStatusPublicationAttempted; + result.noReadinessProjectionStatusPublicationAttempted = !input.readinessProjectionStatusPublicationAttempted; + result.noStatusHandoffPublicationAttempted = !input.statusHandoffPublicationAttempted; + result.noPublicationGuardPublicationAttempted = !input.publicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted; + result.noRuntimePlatformDynamicLibraryLoaded = !input.runtimePlatformLoadAttempted; + result.noRuntimePlatformDynamicLibraryUnloaded = !input.runtimePlatformUnloadAttempted; + result.noRuntimePlatformSymbolResolution = !input.runtimePlatformSymbolResolutionAttempted; + result.noSdxlCalls = !input.sdxlCallRequested; + result.noBridgeCalls = !input.bridgeCallRequested; + result.noServerConnectivityChecked = !input.serverConnectivityCheckRequested; + result.noWalletLifecycle = !input.walletLifecycleRequested; + result.noSyncStarted = !input.syncRequested; + result.noSyncStatusPolled = !input.syncStatusPollingRequested; + result.noWorkerQueueEnqueue = !input.workerQueueRequested; + result.noWalletStateMutation = !input.walletStateMutationRequested; + result.noWalletPersistence = !input.walletPersistenceRequested; + result.noSettingsPersistence = !input.settingsWriteRequested; + result.noSendImportExportExecution = !input.sendImportExportRequested; + result.noArtifactMutation = !input.artifactMutationRequested; + + if (!result.noCallbackInvocationAttempted || !result.noCallbackResultExecutionAttempted || + !result.noDispatchHandoffExecutionAttempted || !result.noDispatchStatusPublicationAttempted || + !result.noDispatchConsumerConsumptionAttempted || !result.noDispatchResultExecutionAttempted || + !result.noResultHandoffStatusPublicationAttempted || !result.noReadinessProjectionStatusPublicationAttempted || + !result.noStatusHandoffPublicationAttempted || !result.noPublicationGuardPublicationAttempted || + !result.noPublicationGuardResultHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted || + !result.noRuntimePlatformDynamicLibraryLoaded || !result.noRuntimePlatformDynamicLibraryUnloaded || + !result.noRuntimePlatformSymbolResolution) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff must stop before callback, dispatch result execution, status publication, readiness publication, result-handoff publication, and platform loader APIs"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_or_platform_api_attempted"); + return result; + } + + if (!result.noSdxlCalls || !result.noBridgeCalls || !result.noServerConnectivityChecked || + !result.noWalletLifecycle || !result.noSyncStarted || !result.noSyncStatusPolled || + !result.noWorkerQueueEnqueue || !result.noWalletStateMutation || !result.noWalletPersistence || + !result.noSettingsPersistence || !result.noSendImportExportExecution || !result.noArtifactMutation) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff must not request wallet runtime behavior"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlockedSummary("runtime_action_requested"); + return result; + } + + if (result.platform.empty()) { + result.status = LiteBridgeRuntimeStatus::Unavailable; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff requires a target platform"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlockedSummary("platform_missing"); + return result; + } + + if (isMacosPlatform(result.platform)) { + result.macosDeferred = true; + result.status = LiteBridgeRuntimeStatus::Unavailable; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffIssue( + result, + input.macosDeferredByOperator + ? "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff is deferred by operator request" + : "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff requires a reviewed builder before promotion"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlockedSummary("macos_deferred"); + return result; + } + + const bool linuxPlatform = isLinuxPlatform(result.platform); + const bool windowsPlatform = isWindowsPlatform(result.platform); + if (!linuxPlatform && !windowsPlatform) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff supports only Linux and Windows in batch 38"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlockedSummary("unsupported_platform"); + return result; + } + result.platformAccepted = true; + result.linuxPlatformAccepted = linuxPlatform; + result.windowsPlatformAccepted = windowsPlatform; + + if (!input.publicationGuardAccepted || !publicationGuard.ok || + !publicationGuard.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardReady || + publicationGuard.status != LiteBridgeRuntimeStatus::Ready || publicationGuard.platform != result.platform || + !publicationGuard.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffAccepted || + !publicationGuard.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardRecordAccepted || + !publicationGuard.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardMatchAccepted || + !publicationGuard.disabledPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardAccepted || + !publicationGuard.callbackInvocationRefused || !publicationGuard.dispatchConsumptionStillGuarded || + !publicationGuard.dispatchResultExecutionBlocked || !publicationGuard.dispatchStatusPublicationBlocked || + !publicationGuard.readinessProjectionPublicationBlocked || !publicationGuard.statusHandoffPublicationBlocked || + !publicationGuard.publicationGuardPublicationBlocked || !publicationGuard.publicationGuardResultHandoffPublicationBlocked || + !publicationGuard.publicationGuardResultHandoffReadinessProjectionPublicationBlocked || + !publicationGuard.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked || + !publicationGuard.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked || + !publicationGuard.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationBlocked || + !publicationGuard.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationBlocked || + !publicationGuard.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked || + !publicationGuard.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked || + !publicationGuard.platformApiPreInvocationBlocked || + !publicationGuard.disabledPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardStateAccepted || + !publicationGuard.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardFailureMappingAccepted || + !publicationGuard.unloadExecutionBlocked || !publicationGuard.symbolResolutionBlocked || + !publicationGuard.productionLoaderDisabled || !publicationGuard.realAdapterExecutionDisabled || + !publicationGuard.loadOnlyExecutionDisabled || !publicationGuard.separateExecutionBatchRequired || + !publicationGuard.noCallbackInvocationAttempted || !publicationGuard.noCallbackResultExecutionAttempted || + !publicationGuard.noDispatchHandoffExecutionAttempted || !publicationGuard.noDispatchStatusPublicationAttempted || + !publicationGuard.noDispatchConsumerConsumptionAttempted || !publicationGuard.noDispatchResultExecutionAttempted || + !publicationGuard.noResultHandoffStatusPublicationAttempted || !publicationGuard.noReadinessProjectionStatusPublicationAttempted || + !publicationGuard.noStatusHandoffPublicationAttempted || !publicationGuard.noPublicationGuardPublicationAttempted || + !publicationGuard.noPublicationGuardResultHandoffPublicationAttempted || + !publicationGuard.noPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !publicationGuard.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !publicationGuard.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted || + !publicationGuard.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted || + !publicationGuard.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !publicationGuard.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !publicationGuard.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted || + !publicationGuard.noRuntimePlatformDynamicLibraryLoaded || !publicationGuard.noRuntimePlatformDynamicLibraryUnloaded || + !publicationGuard.noRuntimePlatformSymbolResolution) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff requires matching ready disabled publication-guard evidence"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_required"); + return result; + } + result.publicationGuardAccepted = true; + + if (!input.resultHandoffReviewed || !input.resultHandoffRecorded || !input.resultHandoffDisabled || + input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId.empty() || + input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff requires a reviewed disabled result-handoff record"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_required"); + return result; + } + result.resultHandoffRecordAccepted = true; + + if (!input.resultHandoffMatchesPublicationGuardEvidence || result.adapterName.empty() || + result.ownerName != publicationGuard.ownerName || result.handoffId != publicationGuard.handoffId || + result.loadCallbackBoundaryName != publicationGuard.loadCallbackBoundaryName || + result.callbackBindingId != publicationGuard.callbackBindingId || result.callbackName != publicationGuard.callbackName || + result.guardId != publicationGuard.guardId || result.refusalResultId != publicationGuard.refusalResultId || + result.propagationId != publicationGuard.propagationId || result.dispatchHandoffId != publicationGuard.dispatchHandoffId || + result.statusRecordId != publicationGuard.statusRecordId || result.consumerReadinessId != publicationGuard.consumerReadinessId || + result.consumerName != publicationGuard.consumerName || result.dispatchConsumptionGuardId != publicationGuard.dispatchConsumptionGuardId || + result.dispatchConsumerName != publicationGuard.dispatchConsumerName || result.resultHandoffId != publicationGuard.resultHandoffId || + result.resultConsumerName != publicationGuard.resultConsumerName || result.readinessProjectionId != publicationGuard.readinessProjectionId || + result.readinessConsumerName != publicationGuard.readinessConsumerName || result.statusHandoffId != publicationGuard.statusHandoffId || + result.statusConsumerName != publicationGuard.statusConsumerName || result.publicationGuardId != publicationGuard.publicationGuardId || + result.publicationConsumerName != publicationGuard.publicationConsumerName || + result.publicationGuardResultHandoffId != publicationGuard.publicationGuardResultHandoffId || + result.publicationGuardResultConsumerName != publicationGuard.publicationGuardResultConsumerName || + result.publicationGuardResultHandoffReadinessProjectionId != publicationGuard.publicationGuardResultHandoffReadinessProjectionId || + result.publicationGuardResultHandoffReadinessConsumerName != publicationGuard.publicationGuardResultHandoffReadinessConsumerName || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffId != publicationGuard.publicationGuardResultHandoffReadinessProjectionStatusHandoffId || + result.publicationGuardResultHandoffReadinessProjectionStatusConsumerName != publicationGuard.publicationGuardResultHandoffReadinessProjectionStatusConsumerName || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId != publicationGuard.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName != publicationGuard.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId != publicationGuard.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName != publicationGuard.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId != publicationGuard.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName != publicationGuard.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId != publicationGuard.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName != publicationGuard.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId != publicationGuard.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName != publicationGuard.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff requires result-handoff-to-publication-guard match evidence"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_match_required"); + return result; + } + result.resultHandoffPublicationGuardMatchAccepted = true; + + if (!input.disabledResultHandoffRegistered || !input.resultHandoffAcceptsPublicationGuardEvidence || + !input.resultHandoffReturnsDisabledResult || !input.resultHandoffBlocksDispatchConsumption || + !input.resultHandoffBlocksDispatchResultExecution || !input.resultHandoffBlocksStatusPublication || + !input.resultHandoffBlocksReadinessPublication || !input.resultHandoffBlocksStatusHandoffPublication || + !input.resultHandoffBlocksPublicationGuardPublication || !input.resultHandoffBlocksPublicationGuardResultHandoffPublication || + !input.resultHandoffBlocksPublicationGuardResultHandoffReadinessProjectionPublication || + !input.resultHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication || + !input.resultHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication || + !input.resultHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication || + !input.resultHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication || + !input.resultHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication || + !input.resultHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication || + !input.resultHandoffBlocksResultHandoffPublication) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff requires disabled result-handoff evidence"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlockedSummary( + "disabled_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_required"); + return result; + } + result.disabledResultHandoffAccepted = true; + + if (!input.callbackInvocationStillDisabled || !input.callbackInvocationRefused || !input.callbackInvocationRefusalReviewed || + !input.resultHandoffStopsBeforeCallbackInvocation || !input.resultHandoffStopsBeforeCallbackResultExecution || + !input.resultHandoffStopsBeforeDispatchConsumption || !input.resultHandoffStopsBeforeDispatchResultExecution || + !input.resultHandoffStopsBeforeDispatchStatusPublication || !input.resultHandoffStopsBeforeReadinessPublication || + !input.resultHandoffStopsBeforeStatusHandoffPublication || !input.resultHandoffStopsBeforePublicationGuardPublication || + !input.resultHandoffStopsBeforePublicationGuardResultHandoffPublication || + !input.resultHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionPublication || + !input.resultHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication || + !input.resultHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication || + !input.resultHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication || + !input.resultHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication || + !input.resultHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication || + !input.resultHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication || + !input.resultHandoffStopsBeforeResultPublication || !input.resultHandoffStopsBeforePlatformApi || + !input.resultHandoffRequiresSeparateExecutionBatch) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff must remain disabled before callback, dispatch result execution, status publication, readiness publication, result publication, and platform APIs"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_disabled_state_required"); + return result; + } + result.callbackInvocationRefused = true; + result.dispatchConsumptionStillGuarded = true; + result.dispatchResultExecutionBlocked = true; + result.dispatchStatusPublicationBlocked = true; + result.readinessProjectionPublicationBlocked = true; + result.statusHandoffPublicationBlocked = true; + result.publicationGuardPublicationBlocked = true; + result.publicationGuardResultHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationBlocked = true; + result.platformApiPreInvocationBlocked = true; + + if (!input.resultHandoffProducesNoDynamicHandle || !input.resultHandoffStoresNoDynamicHandle || + !input.resultHandoffReleasesNoDynamicHandle || !input.resultHandoffResolvesNoSymbols || + !input.resultHandoffStoresNoSymbolTable || !input.resultHandoffCreatesNoRuntime) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff must not create runtime loader state"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_runtime_state_required"); + return result; + } + result.disabledResultHandoffStateAccepted = true; + + if (!input.resultHandoffFailureMappingReviewed) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff requires disabled result-handoff failure mapping review"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_failure_mapping_required"); + return result; + } + result.resultHandoffFailureMappingAccepted = true; + + if (!input.unloadExecutionStillDisabled || !input.symbolResolutionStillDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff must keep unload and symbol resolution disabled"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlockedSummary("non_load_execution_enabled"); + return result; + } + result.unloadExecutionBlocked = true; + result.symbolResolutionBlocked = true; + + if (!input.productionLoaderExecutionDisabled || !input.realAdapterExecutionDisabled || !input.loadOnlyExecutionDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff must keep real loader execution disabled"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlockedSummary("production_loader_enabled"); + return result; + } + result.productionLoaderDisabled = true; + result.realAdapterExecutionDisabled = true; + result.loadOnlyExecutionDisabled = true; + + if (!input.separateExecutionBatchRequired) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff requires a separate execution batch"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlockedSummary("separate_execution_batch_required"); + return result; + } + result.separateExecutionBatchRequired = true; + + result.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReady = true; + result.status = LiteBridgeRuntimeStatus::Ready; + result.ok = true; + result.summary = std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff=ready; platform=") + + result.platform + "; scope=load-only-disabled-callback-refusal-propagation-consumer-readiness-dispatch-consumption-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff; execution=disabled"; + return result; +} + +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionInput& input) +{ + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionResult result; + result.status = LiteBridgeRuntimeStatus::Configured; + const auto& resultHandoff = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff; + const auto select = [](const std::string& inputValue, const std::string& upstreamValue) { + return inputValue.empty() ? upstreamValue : inputValue; + }; + + result.platform = normalizedPlatform(input.platform.empty() ? resultHandoff.platform : input.platform); + result.adapterName = select(input.adapterName, resultHandoff.adapterName); + result.ownerName = select(input.ownerName, resultHandoff.ownerName); + result.handoffId = select(input.handoffId, resultHandoff.handoffId); + result.loadCallbackBoundaryName = select(input.loadCallbackBoundaryName, resultHandoff.loadCallbackBoundaryName); + result.callbackBindingId = select(input.callbackBindingId, resultHandoff.callbackBindingId); + result.callbackName = select(input.callbackName, resultHandoff.callbackName); + result.guardId = select(input.guardId, resultHandoff.guardId); + result.refusalResultId = select(input.refusalResultId, resultHandoff.refusalResultId); + result.propagationId = select(input.propagationId, resultHandoff.propagationId); + result.dispatchHandoffId = select(input.dispatchHandoffId, resultHandoff.dispatchHandoffId); + result.statusRecordId = select(input.statusRecordId, resultHandoff.statusRecordId); + result.consumerReadinessId = select(input.consumerReadinessId, resultHandoff.consumerReadinessId); + result.consumerName = select(input.consumerName, resultHandoff.consumerName); + result.dispatchConsumptionGuardId = select(input.dispatchConsumptionGuardId, resultHandoff.dispatchConsumptionGuardId); + result.dispatchConsumerName = select(input.dispatchConsumerName, resultHandoff.dispatchConsumerName); + result.resultHandoffId = select(input.resultHandoffId, resultHandoff.resultHandoffId); + result.resultConsumerName = select(input.resultConsumerName, resultHandoff.resultConsumerName); + result.readinessProjectionId = select(input.readinessProjectionId, resultHandoff.readinessProjectionId); + result.readinessConsumerName = select(input.readinessConsumerName, resultHandoff.readinessConsumerName); + result.statusHandoffId = select(input.statusHandoffId, resultHandoff.statusHandoffId); + result.statusConsumerName = select(input.statusConsumerName, resultHandoff.statusConsumerName); + result.publicationGuardId = select(input.publicationGuardId, resultHandoff.publicationGuardId); + result.publicationConsumerName = select(input.publicationConsumerName, resultHandoff.publicationConsumerName); + result.publicationGuardResultHandoffId = select(input.publicationGuardResultHandoffId, resultHandoff.publicationGuardResultHandoffId); + result.publicationGuardResultConsumerName = select(input.publicationGuardResultConsumerName, resultHandoff.publicationGuardResultConsumerName); + result.publicationGuardResultHandoffReadinessProjectionId = select(input.publicationGuardResultHandoffReadinessProjectionId, resultHandoff.publicationGuardResultHandoffReadinessProjectionId); + result.publicationGuardResultHandoffReadinessConsumerName = select(input.publicationGuardResultHandoffReadinessConsumerName, resultHandoff.publicationGuardResultHandoffReadinessConsumerName); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffId = select(input.publicationGuardResultHandoffReadinessProjectionStatusHandoffId, resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffId); + result.publicationGuardResultHandoffReadinessProjectionStatusConsumerName = select(input.publicationGuardResultHandoffReadinessProjectionStatusConsumerName, resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusConsumerName); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId = select(input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId, resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName = select(input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName, resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId = select(input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId, resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName = select(input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName, resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId = select(input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId, resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName = select(input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName, resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId = select(input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId, resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName = select(input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName, resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId = select(input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId, resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName = select(input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName, resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId = select(input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId, resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName = select(input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName, resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName; + + result.noCallbackInvocationAttempted = !input.callbackInvocationAttempted; + result.noCallbackResultExecutionAttempted = !input.callbackResultExecutionAttempted; + result.noDispatchHandoffExecutionAttempted = !input.dispatchHandoffExecutionAttempted; + result.noDispatchStatusPublicationAttempted = !input.dispatchStatusPublicationAttempted; + result.noDispatchConsumerConsumptionAttempted = !input.dispatchConsumerConsumptionAttempted; + result.noDispatchResultExecutionAttempted = !input.dispatchResultExecutionAttempted; + result.noResultHandoffStatusPublicationAttempted = !input.resultHandoffStatusPublicationAttempted; + result.noReadinessProjectionStatusPublicationAttempted = !input.readinessProjectionStatusPublicationAttempted; + result.noStatusHandoffPublicationAttempted = !input.statusHandoffPublicationAttempted; + result.noPublicationGuardPublicationAttempted = !input.publicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noRuntimePlatformDynamicLibraryLoaded = !input.runtimePlatformLoadAttempted; + result.noRuntimePlatformDynamicLibraryUnloaded = !input.runtimePlatformUnloadAttempted; + result.noRuntimePlatformSymbolResolution = !input.runtimePlatformSymbolResolutionAttempted; + result.noSdxlCalls = !input.sdxlCallRequested; + result.noBridgeCalls = !input.bridgeCallRequested; + result.noServerConnectivityChecked = !input.serverConnectivityCheckRequested; + result.noWalletLifecycle = !input.walletLifecycleRequested; + result.noSyncStarted = !input.syncRequested; + result.noSyncStatusPolled = !input.syncStatusPollingRequested; + result.noWorkerQueueEnqueue = !input.workerQueueRequested; + result.noWalletStateMutation = !input.walletStateMutationRequested; + result.noWalletPersistence = !input.walletPersistenceRequested; + result.noSettingsPersistence = !input.settingsWriteRequested; + result.noSendImportExportExecution = !input.sendImportExportRequested; + result.noArtifactMutation = !input.artifactMutationRequested; + + if (!result.noCallbackInvocationAttempted || !result.noCallbackResultExecutionAttempted || + !result.noDispatchHandoffExecutionAttempted || !result.noDispatchStatusPublicationAttempted || + !result.noDispatchConsumerConsumptionAttempted || !result.noDispatchResultExecutionAttempted || + !result.noResultHandoffStatusPublicationAttempted || !result.noReadinessProjectionStatusPublicationAttempted || + !result.noStatusHandoffPublicationAttempted || !result.noPublicationGuardPublicationAttempted || + !result.noPublicationGuardResultHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !result.noRuntimePlatformDynamicLibraryLoaded || !result.noRuntimePlatformDynamicLibraryUnloaded || + !result.noRuntimePlatformSymbolResolution) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection must stop before callback, dispatch result execution, readiness publication, result handoff readiness projection publication, and platform loader APIs"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_or_platform_api_attempted"); + return result; + } + + if (!result.noSdxlCalls || !result.noBridgeCalls || !result.noServerConnectivityChecked || + !result.noWalletLifecycle || !result.noSyncStarted || !result.noSyncStatusPolled || + !result.noWorkerQueueEnqueue || !result.noWalletStateMutation || !result.noWalletPersistence || + !result.noSettingsPersistence || !result.noSendImportExportExecution || !result.noArtifactMutation) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection must not request wallet runtime behavior"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlockedSummary("runtime_action_requested"); + return result; + } + + if (result.platform.empty()) { + result.status = LiteBridgeRuntimeStatus::Unavailable; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection requires a target platform"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlockedSummary("platform_missing"); + return result; + } + + if (isMacosPlatform(result.platform)) { + result.macosDeferred = true; + result.status = LiteBridgeRuntimeStatus::Unavailable; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionIssue( + result, + input.macosDeferredByOperator + ? "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection is deferred by operator request" + : "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection requires a reviewed builder before promotion"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlockedSummary("macos_deferred"); + return result; + } + + const bool linuxPlatform = isLinuxPlatform(result.platform); + const bool windowsPlatform = isWindowsPlatform(result.platform); + if (!linuxPlatform && !windowsPlatform) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection supports only Linux and Windows in batch 39"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlockedSummary("unsupported_platform"); + return result; + } + result.platformAccepted = true; + result.linuxPlatformAccepted = linuxPlatform; + result.windowsPlatformAccepted = windowsPlatform; + + if (!input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffAccepted || + !resultHandoff.ok || + !resultHandoff.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReady || + resultHandoff.status != LiteBridgeRuntimeStatus::Ready || resultHandoff.platform != result.platform || + !resultHandoff.publicationGuardAccepted || !resultHandoff.resultHandoffRecordAccepted || + !resultHandoff.resultHandoffPublicationGuardMatchAccepted || !resultHandoff.disabledResultHandoffAccepted || + !resultHandoff.callbackInvocationRefused || !resultHandoff.dispatchConsumptionStillGuarded || + !resultHandoff.dispatchResultExecutionBlocked || !resultHandoff.dispatchStatusPublicationBlocked || + !resultHandoff.readinessProjectionPublicationBlocked || !resultHandoff.statusHandoffPublicationBlocked || + !resultHandoff.publicationGuardPublicationBlocked || !resultHandoff.publicationGuardResultHandoffPublicationBlocked || + !resultHandoff.publicationGuardResultHandoffReadinessProjectionPublicationBlocked || + !resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked || + !resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked || + !resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationBlocked || + !resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationBlocked || + !resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked || + !resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked || + !resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationBlocked || + !resultHandoff.platformApiPreInvocationBlocked || !resultHandoff.disabledResultHandoffStateAccepted || + !resultHandoff.resultHandoffFailureMappingAccepted || !resultHandoff.unloadExecutionBlocked || + !resultHandoff.symbolResolutionBlocked || !resultHandoff.productionLoaderDisabled || + !resultHandoff.realAdapterExecutionDisabled || !resultHandoff.loadOnlyExecutionDisabled || + !resultHandoff.separateExecutionBatchRequired || !resultHandoff.noCallbackInvocationAttempted || + !resultHandoff.noCallbackResultExecutionAttempted || !resultHandoff.noDispatchHandoffExecutionAttempted || + !resultHandoff.noDispatchStatusPublicationAttempted || !resultHandoff.noDispatchConsumerConsumptionAttempted || + !resultHandoff.noDispatchResultExecutionAttempted || !resultHandoff.noResultHandoffStatusPublicationAttempted || + !resultHandoff.noReadinessProjectionStatusPublicationAttempted || !resultHandoff.noStatusHandoffPublicationAttempted || + !resultHandoff.noPublicationGuardPublicationAttempted || !resultHandoff.noPublicationGuardResultHandoffPublicationAttempted || + !resultHandoff.noPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !resultHandoff.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !resultHandoff.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted || + !resultHandoff.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted || + !resultHandoff.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !resultHandoff.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !resultHandoff.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted || + !resultHandoff.noRuntimePlatformDynamicLibraryLoaded || !resultHandoff.noRuntimePlatformDynamicLibraryUnloaded || + !resultHandoff.noRuntimePlatformSymbolResolution) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection requires matching ready disabled result-handoff evidence"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_required"); + return result; + } + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffAccepted = true; + + if (!input.readinessProjectionReviewed || !input.readinessProjectionRecorded || !input.readinessProjectionDisabled || + input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId.empty() || + input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection requires a reviewed disabled readiness-projection record"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_required"); + return result; + } + result.readinessProjectionRecordAccepted = true; + + if (!input.readinessProjectionMatchesResultHandoffEvidence || result.adapterName.empty() || + result.ownerName != resultHandoff.ownerName || result.handoffId != resultHandoff.handoffId || + result.loadCallbackBoundaryName != resultHandoff.loadCallbackBoundaryName || + result.callbackBindingId != resultHandoff.callbackBindingId || result.callbackName != resultHandoff.callbackName || + result.guardId != resultHandoff.guardId || result.refusalResultId != resultHandoff.refusalResultId || + result.propagationId != resultHandoff.propagationId || result.dispatchHandoffId != resultHandoff.dispatchHandoffId || + result.statusRecordId != resultHandoff.statusRecordId || result.consumerReadinessId != resultHandoff.consumerReadinessId || + result.consumerName != resultHandoff.consumerName || result.dispatchConsumptionGuardId != resultHandoff.dispatchConsumptionGuardId || + result.dispatchConsumerName != resultHandoff.dispatchConsumerName || result.resultHandoffId != resultHandoff.resultHandoffId || + result.resultConsumerName != resultHandoff.resultConsumerName || result.readinessProjectionId != resultHandoff.readinessProjectionId || + result.readinessConsumerName != resultHandoff.readinessConsumerName || result.statusHandoffId != resultHandoff.statusHandoffId || + result.statusConsumerName != resultHandoff.statusConsumerName || result.publicationGuardId != resultHandoff.publicationGuardId || + result.publicationConsumerName != resultHandoff.publicationConsumerName || + result.publicationGuardResultHandoffId != resultHandoff.publicationGuardResultHandoffId || + result.publicationGuardResultConsumerName != resultHandoff.publicationGuardResultConsumerName || + result.publicationGuardResultHandoffReadinessProjectionId != resultHandoff.publicationGuardResultHandoffReadinessProjectionId || + result.publicationGuardResultHandoffReadinessConsumerName != resultHandoff.publicationGuardResultHandoffReadinessConsumerName || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffId != resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffId || + result.publicationGuardResultHandoffReadinessProjectionStatusConsumerName != resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusConsumerName || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId != resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName != resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId != resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName != resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId != resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName != resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId != resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName != resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId != resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName != resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId != resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName != resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection requires readiness-projection-to-result-handoff match evidence"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_match_required"); + return result; + } + result.readinessProjectionResultHandoffMatchAccepted = true; + + if (!input.disabledReadinessProjectionRegistered || !input.readinessProjectionAcceptsResultHandoffEvidence || + !input.readinessProjectionReturnsDisabledReadiness || !input.readinessProjectionBlocksDispatchConsumption || + !input.readinessProjectionBlocksDispatchResultExecution || !input.readinessProjectionBlocksStatusPublication || + !input.readinessProjectionBlocksReadinessPublication || !input.readinessProjectionBlocksStatusHandoffPublication || + !input.readinessProjectionBlocksPublicationGuardPublication || !input.readinessProjectionBlocksPublicationGuardResultHandoffPublication || + !input.readinessProjectionBlocksPublicationGuardResultHandoffReadinessProjectionPublication || + !input.readinessProjectionBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication || + !input.readinessProjectionBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication || + !input.readinessProjectionBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication || + !input.readinessProjectionBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication || + !input.readinessProjectionBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication || + !input.readinessProjectionBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication || + !input.readinessProjectionBlocksResultHandoffPublication || !input.readinessProjectionBlocksResultHandoffReadinessProjectionPublication) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection requires disabled readiness-projection evidence"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlockedSummary( + "disabled_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_required"); + return result; + } + result.disabledReadinessProjectionAccepted = true; + + if (!input.callbackInvocationStillDisabled || !input.callbackInvocationRefused || !input.callbackInvocationRefusalReviewed || + !input.projectionStopsBeforeCallbackInvocation || !input.projectionStopsBeforeCallbackResultExecution || + !input.projectionStopsBeforeDispatchConsumption || !input.projectionStopsBeforeDispatchResultExecution || + !input.projectionStopsBeforeDispatchStatusPublication || !input.projectionStopsBeforeReadinessPublication || + !input.projectionStopsBeforeStatusHandoffPublication || !input.projectionStopsBeforePublicationGuardPublication || + !input.projectionStopsBeforePublicationGuardResultHandoffPublication || + !input.projectionStopsBeforePublicationGuardResultHandoffReadinessProjectionPublication || + !input.projectionStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication || + !input.projectionStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication || + !input.projectionStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication || + !input.projectionStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication || + !input.projectionStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication || + !input.projectionStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication || + !input.projectionStopsBeforeResultPublication || !input.projectionStopsBeforeResultHandoffReadinessProjectionPublication || + !input.projectionStopsBeforePlatformApi || !input.projectionRequiresSeparateExecutionBatch) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection must remain disabled before callback, dispatch result execution, status publication, readiness publication, result publication, and platform APIs"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_disabled_state_required"); + return result; + } + result.callbackInvocationRefused = true; + result.dispatchConsumptionStillGuarded = true; + result.dispatchResultExecutionBlocked = true; + result.dispatchStatusPublicationBlocked = true; + result.readinessProjectionPublicationBlocked = true; + result.statusHandoffPublicationBlocked = true; + result.publicationGuardPublicationBlocked = true; + result.publicationGuardResultHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationBlocked = true; + result.platformApiPreInvocationBlocked = true; + + if (!input.projectionProducesNoDynamicHandle || !input.projectionStoresNoDynamicHandle || + !input.projectionReleasesNoDynamicHandle || !input.projectionResolvesNoSymbols || + !input.projectionStoresNoSymbolTable || !input.projectionCreatesNoRuntime) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection must not create runtime loader state"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_runtime_state_required"); + return result; + } + result.disabledReadinessProjectionStateAccepted = true; + + if (!input.readinessProjectionFailureMappingReviewed) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection requires disabled readiness-projection failure mapping review"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_failure_mapping_required"); + return result; + } + result.readinessProjectionFailureMappingAccepted = true; + + if (!input.unloadExecutionStillDisabled || !input.symbolResolutionStillDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection must keep unload and symbol resolution disabled"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlockedSummary("non_load_execution_enabled"); + return result; + } + result.unloadExecutionBlocked = true; + result.symbolResolutionBlocked = true; + + if (!input.productionLoaderExecutionDisabled || !input.realAdapterExecutionDisabled || !input.loadOnlyExecutionDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection must keep real loader execution disabled"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlockedSummary("production_loader_enabled"); + return result; + } + result.productionLoaderDisabled = true; + result.realAdapterExecutionDisabled = true; + result.loadOnlyExecutionDisabled = true; + + if (!input.separateExecutionBatchRequired) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection requires a separate execution batch"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlockedSummary("separate_execution_batch_required"); + return result; + } + result.separateExecutionBatchRequired = true; + + result.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionReady = true; + result.status = LiteBridgeRuntimeStatus::Ready; + result.ok = true; + result.summary = std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection=ready; platform=") + + result.platform + "; scope=load-only-disabled-callback-refusal-propagation-consumer-readiness-dispatch-consumption-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection; execution=disabled"; + return result; +} + +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffInput& input) +{ + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffResult result; + result.status = LiteBridgeRuntimeStatus::Configured; + const auto& readinessProjection = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection; + const auto select = [](const std::string& inputValue, const std::string& upstreamValue) { + return inputValue.empty() ? upstreamValue : inputValue; + }; + + result.platform = normalizedPlatform(input.platform.empty() ? readinessProjection.platform : input.platform); + result.adapterName = select(input.adapterName, readinessProjection.adapterName); + result.ownerName = select(input.ownerName, readinessProjection.ownerName); + result.handoffId = select(input.handoffId, readinessProjection.handoffId); + result.loadCallbackBoundaryName = select(input.loadCallbackBoundaryName, readinessProjection.loadCallbackBoundaryName); + result.callbackBindingId = select(input.callbackBindingId, readinessProjection.callbackBindingId); + result.callbackName = select(input.callbackName, readinessProjection.callbackName); + result.guardId = select(input.guardId, readinessProjection.guardId); + result.refusalResultId = select(input.refusalResultId, readinessProjection.refusalResultId); + result.propagationId = select(input.propagationId, readinessProjection.propagationId); + result.dispatchHandoffId = select(input.dispatchHandoffId, readinessProjection.dispatchHandoffId); + result.statusRecordId = select(input.statusRecordId, readinessProjection.statusRecordId); + result.consumerReadinessId = select(input.consumerReadinessId, readinessProjection.consumerReadinessId); + result.consumerName = select(input.consumerName, readinessProjection.consumerName); + result.dispatchConsumptionGuardId = select(input.dispatchConsumptionGuardId, readinessProjection.dispatchConsumptionGuardId); + result.dispatchConsumerName = select(input.dispatchConsumerName, readinessProjection.dispatchConsumerName); + result.resultHandoffId = select(input.resultHandoffId, readinessProjection.resultHandoffId); + result.resultConsumerName = select(input.resultConsumerName, readinessProjection.resultConsumerName); + result.readinessProjectionId = select(input.readinessProjectionId, readinessProjection.readinessProjectionId); + result.readinessConsumerName = select(input.readinessConsumerName, readinessProjection.readinessConsumerName); + result.statusHandoffId = select(input.statusHandoffId, readinessProjection.statusHandoffId); + result.statusConsumerName = select(input.statusConsumerName, readinessProjection.statusConsumerName); + result.publicationGuardId = select(input.publicationGuardId, readinessProjection.publicationGuardId); + result.publicationConsumerName = select(input.publicationConsumerName, readinessProjection.publicationConsumerName); + result.publicationGuardResultHandoffId = select(input.publicationGuardResultHandoffId, readinessProjection.publicationGuardResultHandoffId); + result.publicationGuardResultConsumerName = select(input.publicationGuardResultConsumerName, readinessProjection.publicationGuardResultConsumerName); + result.publicationGuardResultHandoffReadinessProjectionId = select(input.publicationGuardResultHandoffReadinessProjectionId, readinessProjection.publicationGuardResultHandoffReadinessProjectionId); + result.publicationGuardResultHandoffReadinessConsumerName = select(input.publicationGuardResultHandoffReadinessConsumerName, readinessProjection.publicationGuardResultHandoffReadinessConsumerName); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffId = select(input.publicationGuardResultHandoffReadinessProjectionStatusHandoffId, readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffId); + result.publicationGuardResultHandoffReadinessProjectionStatusConsumerName = select(input.publicationGuardResultHandoffReadinessProjectionStatusConsumerName, readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusConsumerName); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId = select(input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId, readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName = select(input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName, readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId = select(input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId, readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName = select(input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName, readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId = select(input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId, readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName = select(input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName, readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId = select(input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId, readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName = select(input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName, readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId = select(input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId, readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName = select(input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName, readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId = select(input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId, readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName = select(input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName, readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId = select(input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId, readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName = select(input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName, readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName; + + result.noCallbackInvocationAttempted = !input.callbackInvocationAttempted; + result.noCallbackResultExecutionAttempted = !input.callbackResultExecutionAttempted; + result.noDispatchHandoffExecutionAttempted = !input.dispatchHandoffExecutionAttempted; + result.noDispatchStatusPublicationAttempted = !input.dispatchStatusPublicationAttempted; + result.noDispatchConsumerConsumptionAttempted = !input.dispatchConsumerConsumptionAttempted; + result.noDispatchResultExecutionAttempted = !input.dispatchResultExecutionAttempted; + result.noResultHandoffStatusPublicationAttempted = !input.resultHandoffStatusPublicationAttempted; + result.noReadinessProjectionStatusPublicationAttempted = !input.readinessProjectionStatusPublicationAttempted; + result.noStatusHandoffPublicationAttempted = !input.statusHandoffPublicationAttempted; + result.noPublicationGuardPublicationAttempted = !input.publicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noRuntimePlatformDynamicLibraryLoaded = !input.runtimePlatformLoadAttempted; + result.noRuntimePlatformDynamicLibraryUnloaded = !input.runtimePlatformUnloadAttempted; + result.noRuntimePlatformSymbolResolution = !input.runtimePlatformSymbolResolutionAttempted; + result.noSdxlCalls = !input.sdxlCallRequested; + result.noBridgeCalls = !input.bridgeCallRequested; + result.noServerConnectivityChecked = !input.serverConnectivityCheckRequested; + result.noWalletLifecycle = !input.walletLifecycleRequested; + result.noSyncStarted = !input.syncRequested; + result.noSyncStatusPolled = !input.syncStatusPollingRequested; + result.noWorkerQueueEnqueue = !input.workerQueueRequested; + result.noWalletStateMutation = !input.walletStateMutationRequested; + result.noWalletPersistence = !input.walletPersistenceRequested; + result.noSettingsPersistence = !input.settingsWriteRequested; + result.noSendImportExportExecution = !input.sendImportExportRequested; + result.noArtifactMutation = !input.artifactMutationRequested; + + if (!result.noCallbackInvocationAttempted || !result.noCallbackResultExecutionAttempted || + !result.noDispatchHandoffExecutionAttempted || !result.noDispatchStatusPublicationAttempted || + !result.noDispatchConsumerConsumptionAttempted || !result.noDispatchResultExecutionAttempted || + !result.noResultHandoffStatusPublicationAttempted || !result.noReadinessProjectionStatusPublicationAttempted || + !result.noStatusHandoffPublicationAttempted || !result.noPublicationGuardPublicationAttempted || + !result.noPublicationGuardResultHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !result.noRuntimePlatformDynamicLibraryLoaded || !result.noRuntimePlatformDynamicLibraryUnloaded || + !result.noRuntimePlatformSymbolResolution) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff must stop before callback, dispatch result execution, status publication, readiness publication, status handoff publication, and platform loader APIs"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_or_platform_api_attempted"); + return result; + } + + if (!result.noSdxlCalls || !result.noBridgeCalls || !result.noServerConnectivityChecked || + !result.noWalletLifecycle || !result.noSyncStarted || !result.noSyncStatusPolled || + !result.noWorkerQueueEnqueue || !result.noWalletStateMutation || !result.noWalletPersistence || + !result.noSettingsPersistence || !result.noSendImportExportExecution || !result.noArtifactMutation) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff must not request wallet runtime behavior"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary("runtime_action_requested"); + return result; + } + + if (result.platform.empty()) { + result.status = LiteBridgeRuntimeStatus::Unavailable; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff requires a target platform"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary("platform_missing"); + return result; + } + + if (isMacosPlatform(result.platform)) { + result.macosDeferred = true; + result.status = LiteBridgeRuntimeStatus::Unavailable; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffIssue( + result, + input.macosDeferredByOperator + ? "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff is deferred by operator request" + : "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff requires a reviewed builder before promotion"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary("macos_deferred"); + return result; + } + + const bool linuxPlatform = isLinuxPlatform(result.platform); + const bool windowsPlatform = isWindowsPlatform(result.platform); + if (!linuxPlatform && !windowsPlatform) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff supports only Linux and Windows in batch 40"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary("unsupported_platform"); + return result; + } + result.platformAccepted = true; + result.linuxPlatformAccepted = linuxPlatform; + result.windowsPlatformAccepted = windowsPlatform; + + if (!input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionAccepted || + !readinessProjection.ok || + !readinessProjection.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionReady || + readinessProjection.status != LiteBridgeRuntimeStatus::Ready || readinessProjection.platform != result.platform || + !readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffAccepted || + !readinessProjection.readinessProjectionRecordAccepted || !readinessProjection.readinessProjectionResultHandoffMatchAccepted || + !readinessProjection.disabledReadinessProjectionAccepted || !readinessProjection.callbackInvocationRefused || + !readinessProjection.dispatchConsumptionStillGuarded || !readinessProjection.dispatchResultExecutionBlocked || + !readinessProjection.dispatchStatusPublicationBlocked || !readinessProjection.readinessProjectionPublicationBlocked || + !readinessProjection.statusHandoffPublicationBlocked || !readinessProjection.publicationGuardPublicationBlocked || + !readinessProjection.publicationGuardResultHandoffPublicationBlocked || + !readinessProjection.publicationGuardResultHandoffReadinessProjectionPublicationBlocked || + !readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked || + !readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked || + !readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationBlocked || + !readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationBlocked || + !readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked || + !readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked || + !readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationBlocked || + !readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationBlocked || + !readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationBlocked || + !readinessProjection.platformApiPreInvocationBlocked || !readinessProjection.disabledReadinessProjectionStateAccepted || + !readinessProjection.readinessProjectionFailureMappingAccepted || !readinessProjection.unloadExecutionBlocked || + !readinessProjection.symbolResolutionBlocked || !readinessProjection.productionLoaderDisabled || + !readinessProjection.realAdapterExecutionDisabled || !readinessProjection.loadOnlyExecutionDisabled || + !readinessProjection.separateExecutionBatchRequired || !readinessProjection.noCallbackInvocationAttempted || + !readinessProjection.noCallbackResultExecutionAttempted || !readinessProjection.noDispatchHandoffExecutionAttempted || + !readinessProjection.noDispatchStatusPublicationAttempted || !readinessProjection.noDispatchConsumerConsumptionAttempted || + !readinessProjection.noDispatchResultExecutionAttempted || !readinessProjection.noResultHandoffStatusPublicationAttempted || + !readinessProjection.noReadinessProjectionStatusPublicationAttempted || !readinessProjection.noStatusHandoffPublicationAttempted || + !readinessProjection.noPublicationGuardPublicationAttempted || !readinessProjection.noPublicationGuardResultHandoffPublicationAttempted || + !readinessProjection.noPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !readinessProjection.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !readinessProjection.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted || + !readinessProjection.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted || + !readinessProjection.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !readinessProjection.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !readinessProjection.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted || + !readinessProjection.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted || + !readinessProjection.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !readinessProjection.noRuntimePlatformDynamicLibraryLoaded || !readinessProjection.noRuntimePlatformDynamicLibraryUnloaded || + !readinessProjection.noRuntimePlatformSymbolResolution) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff requires matching ready disabled readiness-projection evidence"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_required"); + return result; + } + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionAccepted = true; + + if (!input.statusHandoffReviewed || !input.statusHandoffRecorded || !input.statusHandoffDisabled || + input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId.empty() || + input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff requires a reviewed disabled status-handoff record"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_required"); + return result; + } + result.statusHandoffRecordAccepted = true; + + if (!input.statusHandoffMatchesReadinessProjectionEvidence || result.adapterName.empty() || + result.ownerName != readinessProjection.ownerName || result.handoffId != readinessProjection.handoffId || + result.loadCallbackBoundaryName != readinessProjection.loadCallbackBoundaryName || + result.callbackBindingId != readinessProjection.callbackBindingId || result.callbackName != readinessProjection.callbackName || + result.guardId != readinessProjection.guardId || result.refusalResultId != readinessProjection.refusalResultId || + result.propagationId != readinessProjection.propagationId || result.dispatchHandoffId != readinessProjection.dispatchHandoffId || + result.statusRecordId != readinessProjection.statusRecordId || result.consumerReadinessId != readinessProjection.consumerReadinessId || + result.consumerName != readinessProjection.consumerName || result.dispatchConsumptionGuardId != readinessProjection.dispatchConsumptionGuardId || + result.dispatchConsumerName != readinessProjection.dispatchConsumerName || result.resultHandoffId != readinessProjection.resultHandoffId || + result.resultConsumerName != readinessProjection.resultConsumerName || result.readinessProjectionId != readinessProjection.readinessProjectionId || + result.readinessConsumerName != readinessProjection.readinessConsumerName || result.statusHandoffId != readinessProjection.statusHandoffId || + result.statusConsumerName != readinessProjection.statusConsumerName || result.publicationGuardId != readinessProjection.publicationGuardId || + result.publicationConsumerName != readinessProjection.publicationConsumerName || + result.publicationGuardResultHandoffId != readinessProjection.publicationGuardResultHandoffId || + result.publicationGuardResultConsumerName != readinessProjection.publicationGuardResultConsumerName || + result.publicationGuardResultHandoffReadinessProjectionId != readinessProjection.publicationGuardResultHandoffReadinessProjectionId || + result.publicationGuardResultHandoffReadinessConsumerName != readinessProjection.publicationGuardResultHandoffReadinessConsumerName || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffId != readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffId || + result.publicationGuardResultHandoffReadinessProjectionStatusConsumerName != readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusConsumerName || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId != readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName != readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId != readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName != readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId != readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName != readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId != readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName != readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId != readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName != readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId != readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName != readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId != readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId || + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName != readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff requires status-handoff-to-readiness-projection match evidence"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_match_required"); + return result; + } + result.statusHandoffReadinessProjectionMatchAccepted = true; + + if (!input.disabledStatusHandoffRegistered || !input.statusHandoffAcceptsReadinessProjectionEvidence || + !input.statusHandoffReturnsDisabledStatus || !input.statusHandoffBlocksDispatchConsumption || + !input.statusHandoffBlocksDispatchResultExecution || !input.statusHandoffBlocksStatusPublication || + !input.statusHandoffBlocksReadinessPublication || !input.statusHandoffBlocksStatusHandoffPublication || + !input.statusHandoffBlocksPublicationGuardPublication || !input.statusHandoffBlocksPublicationGuardResultHandoffPublication || + !input.statusHandoffBlocksPublicationGuardResultHandoffReadinessProjectionPublication || + !input.statusHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication || + !input.statusHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication || + !input.statusHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication || + !input.statusHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication || + !input.statusHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication || + !input.statusHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication || + !input.statusHandoffBlocksResultHandoffPublication || !input.statusHandoffBlocksResultHandoffReadinessProjectionPublication || + !input.statusHandoffBlocksResultHandoffReadinessProjectionStatusHandoffPublication) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff requires disabled status-handoff evidence"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary( + "disabled_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_required"); + return result; + } + result.disabledStatusHandoffAccepted = true; + + if (!input.callbackInvocationStillDisabled || !input.callbackInvocationRefused || !input.callbackInvocationRefusalReviewed || + !input.statusHandoffStopsBeforeCallbackInvocation || !input.statusHandoffStopsBeforeCallbackResultExecution || + !input.statusHandoffStopsBeforeDispatchConsumption || !input.statusHandoffStopsBeforeDispatchResultExecution || + !input.statusHandoffStopsBeforeDispatchStatusPublication || !input.statusHandoffStopsBeforeReadinessPublication || + !input.statusHandoffStopsBeforeStatusHandoffPublication || !input.statusHandoffStopsBeforePublicationGuardPublication || + !input.statusHandoffStopsBeforePublicationGuardResultHandoffPublication || + !input.statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionPublication || + !input.statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication || + !input.statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication || + !input.statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication || + !input.statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication || + !input.statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication || + !input.statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication || + !input.statusHandoffStopsBeforeResultPublication || !input.statusHandoffStopsBeforeResultHandoffReadinessProjectionPublication || + !input.statusHandoffStopsBeforeResultHandoffReadinessProjectionStatusHandoffPublication || !input.statusHandoffStopsBeforePlatformApi || + !input.statusHandoffRequiresSeparateExecutionBatch) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff must remain disabled before callback, dispatch result execution, status publication, readiness publication, result publication, and platform APIs"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_disabled_state_required"); + return result; + } + result.callbackInvocationRefused = true; + result.dispatchConsumptionStillGuarded = true; + result.dispatchResultExecutionBlocked = true; + result.dispatchStatusPublicationBlocked = true; + result.readinessProjectionPublicationBlocked = true; + result.statusHandoffPublicationBlocked = true; + result.publicationGuardPublicationBlocked = true; + result.publicationGuardResultHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked = true; + result.platformApiPreInvocationBlocked = true; + + if (!input.statusHandoffProducesNoDynamicHandle || !input.statusHandoffStoresNoDynamicHandle || + !input.statusHandoffReleasesNoDynamicHandle || !input.statusHandoffResolvesNoSymbols || + !input.statusHandoffStoresNoSymbolTable || !input.statusHandoffCreatesNoRuntime) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff must not create runtime loader state"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_runtime_state_required"); + return result; + } + result.disabledStatusHandoffStateAccepted = true; + + if (!input.statusHandoffFailureMappingReviewed) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff requires disabled status-handoff failure mapping review"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_failure_mapping_required"); + return result; + } + result.statusHandoffFailureMappingAccepted = true; + + if (!input.unloadExecutionStillDisabled || !input.symbolResolutionStillDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff must keep unload and symbol resolution disabled"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary("non_load_execution_enabled"); + return result; + } + result.unloadExecutionBlocked = true; + result.symbolResolutionBlocked = true; + + if (!input.productionLoaderExecutionDisabled || !input.realAdapterExecutionDisabled || !input.loadOnlyExecutionDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff must keep real loader execution disabled"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary("production_loader_enabled"); + return result; + } + result.productionLoaderDisabled = true; + result.realAdapterExecutionDisabled = true; + result.loadOnlyExecutionDisabled = true; + + if (!input.separateExecutionBatchRequired) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff requires a separate execution batch"); + result.summary = platformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlockedSummary("separate_execution_batch_required"); + return result; + } + result.separateExecutionBatchRequired = true; + + result.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffReady = true; + result.status = LiteBridgeRuntimeStatus::Ready; + result.ok = true; + result.summary = std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff=ready; platform=") + + result.platform + "; scope=load-only-disabled-callback-refusal-propagation-consumer-readiness-dispatch-consumption-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff; execution=disabled"; + return result; +} + +using LiteBridgeRuntimeBatch40StatusHandoffResult = LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffResult; + +template +static void resetGeneratedLiteRuntimeCurrentExecutionGates(Result& result) +{ + result.unloadExecutionBlocked = false; + result.symbolResolutionBlocked = false; + result.productionLoaderDisabled = false; + result.realAdapterExecutionDisabled = false; + result.loadOnlyExecutionDisabled = false; + result.separateExecutionBatchRequired = false; +} + +using LiteBridgeRuntimeBatch41PublicationGuardInput = LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardInput; +using LiteBridgeRuntimeBatch41PublicationGuardResult = LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResult; + +static std::string batch41PublicationGuardBlockedSummary(const std::string& reason) +{ + return std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard=blocked; reason=") + reason; +} + +static void addBatch41PublicationGuardIssue(LiteBridgeRuntimeBatch41PublicationGuardResult& result, + const std::string& message) +{ + result.issues.push_back(message); + if (result.error.empty()) result.error = message; +} + +static void setBatch41PublicationGuardAttemptEvidence(const LiteBridgeRuntimeBatch41PublicationGuardInput& input, + LiteBridgeRuntimeBatch41PublicationGuardResult& result) +{ + result.noCallbackInvocationAttempted = !input.callbackInvocationAttempted; + result.noCallbackResultExecutionAttempted = !input.callbackResultExecutionAttempted; + result.noDispatchHandoffExecutionAttempted = !input.dispatchHandoffExecutionAttempted; + result.noDispatchStatusPublicationAttempted = !input.dispatchStatusPublicationAttempted; + result.noDispatchConsumerConsumptionAttempted = !input.dispatchConsumerConsumptionAttempted; + result.noDispatchResultExecutionAttempted = !input.dispatchResultExecutionAttempted; + result.noResultHandoffStatusPublicationAttempted = !input.resultHandoffStatusPublicationAttempted; + result.noReadinessProjectionStatusPublicationAttempted = !input.readinessProjectionStatusPublicationAttempted; + result.noStatusHandoffPublicationAttempted = !input.statusHandoffPublicationAttempted; + result.noPublicationGuardPublicationAttempted = !input.publicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted; + result.noRuntimePlatformDynamicLibraryLoaded = !input.runtimePlatformLoadAttempted; + result.noRuntimePlatformDynamicLibraryUnloaded = !input.runtimePlatformUnloadAttempted; + result.noRuntimePlatformSymbolResolution = !input.runtimePlatformSymbolResolutionAttempted; + result.noSdxlCalls = !input.sdxlCallRequested; + result.noBridgeCalls = !input.bridgeCallRequested; + result.noServerConnectivityChecked = !input.serverConnectivityCheckRequested; + result.noWalletLifecycle = !input.walletLifecycleRequested; + result.noSyncStarted = !input.syncRequested; + result.noSyncStatusPolled = !input.syncStatusPollingRequested; + result.noWorkerQueueEnqueue = !input.workerQueueRequested; + result.noWalletStateMutation = !input.walletStateMutationRequested; + result.noWalletPersistence = !input.walletPersistenceRequested; + result.noSettingsPersistence = !input.settingsWriteRequested; + result.noSendImportExportExecution = !input.sendImportExportRequested; + result.noArtifactMutation = !input.artifactMutationRequested; +} + +static bool batch41PublicationGuardAttempted(const LiteBridgeRuntimeBatch41PublicationGuardResult& result) +{ + return !result.noCallbackInvocationAttempted || !result.noCallbackResultExecutionAttempted || + !result.noDispatchHandoffExecutionAttempted || !result.noDispatchStatusPublicationAttempted || + !result.noDispatchConsumerConsumptionAttempted || !result.noDispatchResultExecutionAttempted || + !result.noResultHandoffStatusPublicationAttempted || !result.noReadinessProjectionStatusPublicationAttempted || + !result.noStatusHandoffPublicationAttempted || !result.noPublicationGuardPublicationAttempted || + !result.noPublicationGuardResultHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted || + !result.noRuntimePlatformDynamicLibraryLoaded || !result.noRuntimePlatformDynamicLibraryUnloaded || + !result.noRuntimePlatformSymbolResolution; +} + +static bool batch41PublicationGuardRuntimeActionRequested(const LiteBridgeRuntimeBatch41PublicationGuardResult& result) +{ + return !result.noSdxlCalls || !result.noBridgeCalls || !result.noServerConnectivityChecked || + !result.noWalletLifecycle || !result.noSyncStarted || !result.noSyncStatusPolled || + !result.noWorkerQueueEnqueue || !result.noWalletStateMutation || !result.noWalletPersistence || + !result.noSettingsPersistence || !result.noSendImportExportExecution || !result.noArtifactMutation; +} + +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardInput& input) +{ + LiteBridgeRuntimeBatch41PublicationGuardResult result; + result.status = LiteBridgeRuntimeStatus::Configured; + const auto& statusHandoff = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff; + result.platform = normalizedPlatform(input.platform.empty() ? statusHandoff.platform : input.platform); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName; + setBatch41PublicationGuardAttemptEvidence(input, result); + resetGeneratedLiteRuntimeCurrentExecutionGates(result); + + if (batch41PublicationGuardAttempted(result)) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch41PublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard must stop before callback, dispatch result execution, status publication, readiness publication, publication guard publication, and platform loader APIs"); + result.summary = batch41PublicationGuardBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_or_platform_api_attempted"); + return result; + } + + if (batch41PublicationGuardRuntimeActionRequested(result)) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch41PublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard must not request wallet runtime behavior"); + result.summary = batch41PublicationGuardBlockedSummary("runtime_action_requested"); + return result; + } + + if (result.platform.empty()) { + result.status = LiteBridgeRuntimeStatus::Unavailable; + addBatch41PublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard requires a target platform"); + result.summary = batch41PublicationGuardBlockedSummary("platform_missing"); + return result; + } + + if (isMacosPlatform(result.platform)) { + result.macosDeferred = true; + result.status = LiteBridgeRuntimeStatus::Unavailable; + addBatch41PublicationGuardIssue( + result, + input.macosDeferredByOperator + ? "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard is deferred by operator request" + : "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard requires a reviewed builder before promotion"); + result.summary = batch41PublicationGuardBlockedSummary("macos_deferred"); + return result; + } + + const bool linuxPlatform = isLinuxPlatform(result.platform); + const bool windowsPlatform = isWindowsPlatform(result.platform); + if (!linuxPlatform && !windowsPlatform) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch41PublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard supports only Linux and Windows in batch 41"); + result.summary = batch41PublicationGuardBlockedSummary("unsupported_platform"); + return result; + } + result.platformAccepted = true; + result.linuxPlatformAccepted = linuxPlatform; + result.windowsPlatformAccepted = windowsPlatform; + + if (!input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffAccepted || + !statusHandoff.ok || + !statusHandoff.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffReady || + statusHandoff.status != LiteBridgeRuntimeStatus::Ready || statusHandoff.platform != result.platform || + !statusHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionAccepted || + !statusHandoff.statusHandoffRecordAccepted || !statusHandoff.statusHandoffReadinessProjectionMatchAccepted || + !statusHandoff.disabledStatusHandoffAccepted || !statusHandoff.callbackInvocationRefused || + !statusHandoff.dispatchConsumptionStillGuarded || !statusHandoff.dispatchResultExecutionBlocked || + !statusHandoff.dispatchStatusPublicationBlocked || !statusHandoff.readinessProjectionPublicationBlocked || + !statusHandoff.statusHandoffPublicationBlocked || !statusHandoff.publicationGuardPublicationBlocked || + !statusHandoff.publicationGuardResultHandoffPublicationBlocked || + !statusHandoff.publicationGuardResultHandoffReadinessProjectionPublicationBlocked || + !statusHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked || + !statusHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked || + !statusHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationBlocked || + !statusHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationBlocked || + !statusHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked || + !statusHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked || + !statusHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationBlocked || + !statusHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationBlocked || + !statusHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked || + !statusHandoff.platformApiPreInvocationBlocked || !statusHandoff.disabledStatusHandoffStateAccepted || + !statusHandoff.statusHandoffFailureMappingAccepted || !statusHandoff.unloadExecutionBlocked || + !statusHandoff.symbolResolutionBlocked || !statusHandoff.productionLoaderDisabled || + !statusHandoff.realAdapterExecutionDisabled || !statusHandoff.loadOnlyExecutionDisabled || + !statusHandoff.separateExecutionBatchRequired || !statusHandoff.noRuntimePlatformDynamicLibraryLoaded || + !statusHandoff.noRuntimePlatformDynamicLibraryUnloaded || !statusHandoff.noRuntimePlatformSymbolResolution) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch41PublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard requires matching ready disabled status-handoff evidence"); + result.summary = batch41PublicationGuardBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_required"); + return result; + } + + static_cast(result) = statusHandoff; + result.ok = false; + result.status = LiteBridgeRuntimeStatus::Configured; + result.issues.clear(); + result.error.clear(); + result.summary.clear(); + result.platformAccepted = true; + result.linuxPlatformAccepted = linuxPlatform; + result.windowsPlatformAccepted = windowsPlatform; + result.macosDeferred = false; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffAccepted = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName; + setBatch41PublicationGuardAttemptEvidence(input, result); + resetGeneratedLiteRuntimeCurrentExecutionGates(result); + + if (!input.publicationGuardReviewed || !input.publicationGuardRecorded || !input.publicationGuardDisabled || + input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId.empty() || + input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch41PublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard requires a reviewed disabled publication-guard record"); + result.summary = batch41PublicationGuardBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_required"); + return result; + } + result.publicationGuardRecordAccepted = true; + + if (!input.publicationGuardMatchesStatusHandoffEvidence || result.adapterName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch41PublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard requires publication-guard-to-status-handoff match evidence"); + result.summary = batch41PublicationGuardBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_match_required"); + return result; + } + result.publicationGuardStatusHandoffMatchAccepted = true; + + if (!input.disabledPublicationGuardRegistered || !input.publicationGuardAcceptsStatusHandoffEvidence || + !input.publicationGuardReturnsDisabledPublication || !input.publicationGuardBlocksDispatchConsumption || + !input.publicationGuardBlocksDispatchResultExecution || !input.publicationGuardBlocksStatusPublication || + !input.publicationGuardBlocksReadinessPublication || !input.publicationGuardBlocksStatusHandoffPublication || + !input.publicationGuardBlocksPublicationGuardPublication || !input.publicationGuardBlocksPublicationGuardResultHandoffPublication || + !input.publicationGuardBlocksPublicationGuardResultHandoffReadinessProjectionPublication || + !input.publicationGuardBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication || + !input.publicationGuardBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication || + !input.publicationGuardBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication || + !input.publicationGuardBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication || + !input.publicationGuardBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication || + !input.publicationGuardBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication || + !input.publicationGuardBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication || + !input.publicationGuardBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication || + !input.publicationGuardBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication || + !input.publicationGuardBlocksResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch41PublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard requires disabled publication-guard evidence"); + result.summary = batch41PublicationGuardBlockedSummary( + "disabled_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_required"); + return result; + } + result.disabledPublicationGuardAccepted = true; + + if (!input.callbackInvocationStillDisabled || !input.callbackInvocationRefused || !input.callbackInvocationRefusalReviewed || + !input.publicationGuardStopsBeforeCallbackInvocation || !input.publicationGuardStopsBeforeCallbackResultExecution || + !input.publicationGuardStopsBeforeDispatchConsumption || !input.publicationGuardStopsBeforeDispatchResultExecution || + !input.publicationGuardStopsBeforeDispatchStatusPublication || !input.publicationGuardStopsBeforeReadinessPublication || + !input.publicationGuardStopsBeforeStatusHandoffPublication || !input.publicationGuardStopsBeforePublicationGuardPublication || + !input.publicationGuardStopsBeforePublicationGuardResultHandoffPublication || + !input.publicationGuardStopsBeforePublicationGuardResultHandoffReadinessProjectionPublication || + !input.publicationGuardStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication || + !input.publicationGuardStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication || + !input.publicationGuardStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication || + !input.publicationGuardStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication || + !input.publicationGuardStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication || + !input.publicationGuardStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication || + !input.publicationGuardStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication || + !input.publicationGuardStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication || + !input.publicationGuardStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication || + !input.publicationGuardStopsBeforeResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication || + !input.publicationGuardStopsBeforePlatformApi || !input.publicationGuardRequiresSeparateExecutionBatch) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch41PublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard must remain disabled before callback, dispatch result execution, status publication, readiness publication, publication, and platform APIs"); + result.summary = batch41PublicationGuardBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_disabled_state_required"); + return result; + } + result.callbackInvocationRefused = true; + result.dispatchConsumptionStillGuarded = true; + result.dispatchResultExecutionBlocked = true; + result.dispatchStatusPublicationBlocked = true; + result.readinessProjectionPublicationBlocked = true; + result.statusHandoffPublicationBlocked = true; + result.publicationGuardPublicationBlocked = true; + result.publicationGuardResultHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked = true; + result.platformApiPreInvocationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked = true; + + if (!input.publicationGuardProducesNoDynamicHandle || !input.publicationGuardStoresNoDynamicHandle || + !input.publicationGuardReleasesNoDynamicHandle || !input.publicationGuardResolvesNoSymbols || + !input.publicationGuardStoresNoSymbolTable || !input.publicationGuardCreatesNoRuntime) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch41PublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard must not create runtime loader state"); + result.summary = batch41PublicationGuardBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_runtime_state_required"); + return result; + } + result.disabledPublicationGuardStateAccepted = true; + + if (!input.publicationGuardFailureMappingReviewed) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch41PublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard requires disabled publication-guard failure mapping review"); + result.summary = batch41PublicationGuardBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_failure_mapping_required"); + return result; + } + result.publicationGuardFailureMappingAccepted = true; + + if (!input.unloadExecutionStillDisabled || !input.symbolResolutionStillDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch41PublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard must keep unload and symbol resolution disabled"); + result.summary = batch41PublicationGuardBlockedSummary("non_load_execution_enabled"); + return result; + } + result.unloadExecutionBlocked = true; + result.symbolResolutionBlocked = true; + + if (!input.productionLoaderExecutionDisabled || !input.realAdapterExecutionDisabled || !input.loadOnlyExecutionDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch41PublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard must keep real loader execution disabled"); + result.summary = batch41PublicationGuardBlockedSummary("production_loader_enabled"); + return result; + } + result.productionLoaderDisabled = true; + result.realAdapterExecutionDisabled = true; + result.loadOnlyExecutionDisabled = true; + + if (!input.separateExecutionBatchRequired) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch41PublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard requires a separate execution batch"); + result.summary = batch41PublicationGuardBlockedSummary("separate_execution_batch_required"); + return result; + } + result.separateExecutionBatchRequired = true; + + result.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardReady = true; + result.status = LiteBridgeRuntimeStatus::Ready; + result.ok = true; + result.summary = std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard=ready; platform=") + + result.platform + "; scope=load-only-disabled-callback-refusal-propagation-consumer-readiness-dispatch-consumption-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard; execution=disabled"; + return result; +} + +using LiteBridgeRuntimeBatch42ResultHandoffInput = LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffInput; +using LiteBridgeRuntimeBatch42ResultHandoffResult = LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffResult; + +static std::string batch42ResultHandoffBlockedSummary(const std::string& reason) +{ + return std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff=blocked; reason=") + reason; +} + +static void addBatch42ResultHandoffIssue(LiteBridgeRuntimeBatch42ResultHandoffResult& result, + const std::string& message) +{ + result.issues.push_back(message); + if (result.error.empty()) result.error = message; +} + +static void setBatch42ResultHandoffAttemptEvidence(const LiteBridgeRuntimeBatch42ResultHandoffInput& input, + LiteBridgeRuntimeBatch42ResultHandoffResult& result) +{ + result.noCallbackInvocationAttempted = !input.callbackInvocationAttempted; + result.noCallbackResultExecutionAttempted = !input.callbackResultExecutionAttempted; + result.noDispatchHandoffExecutionAttempted = !input.dispatchHandoffExecutionAttempted; + result.noDispatchStatusPublicationAttempted = !input.dispatchStatusPublicationAttempted; + result.noDispatchConsumerConsumptionAttempted = !input.dispatchConsumerConsumptionAttempted; + result.noDispatchResultExecutionAttempted = !input.dispatchResultExecutionAttempted; + result.noResultHandoffStatusPublicationAttempted = !input.resultHandoffStatusPublicationAttempted; + result.noReadinessProjectionStatusPublicationAttempted = !input.readinessProjectionStatusPublicationAttempted; + result.noStatusHandoffPublicationAttempted = !input.statusHandoffPublicationAttempted; + result.noPublicationGuardPublicationAttempted = !input.publicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted; + result.noRuntimePlatformDynamicLibraryLoaded = !input.runtimePlatformLoadAttempted; + result.noRuntimePlatformDynamicLibraryUnloaded = !input.runtimePlatformUnloadAttempted; + result.noRuntimePlatformSymbolResolution = !input.runtimePlatformSymbolResolutionAttempted; + result.noSdxlCalls = !input.sdxlCallRequested; + result.noBridgeCalls = !input.bridgeCallRequested; + result.noServerConnectivityChecked = !input.serverConnectivityCheckRequested; + result.noWalletLifecycle = !input.walletLifecycleRequested; + result.noSyncStarted = !input.syncRequested; + result.noSyncStatusPolled = !input.syncStatusPollingRequested; + result.noWorkerQueueEnqueue = !input.workerQueueRequested; + result.noWalletStateMutation = !input.walletStateMutationRequested; + result.noWalletPersistence = !input.walletPersistenceRequested; + result.noSettingsPersistence = !input.settingsWriteRequested; + result.noSendImportExportExecution = !input.sendImportExportRequested; + result.noArtifactMutation = !input.artifactMutationRequested; +} + +static bool batch42ResultHandoffAttempted(const LiteBridgeRuntimeBatch42ResultHandoffResult& result) +{ + return !result.noCallbackInvocationAttempted || !result.noCallbackResultExecutionAttempted || + !result.noDispatchHandoffExecutionAttempted || !result.noDispatchStatusPublicationAttempted || + !result.noDispatchConsumerConsumptionAttempted || !result.noDispatchResultExecutionAttempted || + !result.noResultHandoffStatusPublicationAttempted || !result.noReadinessProjectionStatusPublicationAttempted || + !result.noStatusHandoffPublicationAttempted || !result.noPublicationGuardPublicationAttempted || + !result.noPublicationGuardResultHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted || + !result.noRuntimePlatformDynamicLibraryLoaded || !result.noRuntimePlatformDynamicLibraryUnloaded || + !result.noRuntimePlatformSymbolResolution; +} + +static bool batch42ResultHandoffRuntimeActionRequested(const LiteBridgeRuntimeBatch42ResultHandoffResult& result) +{ + return !result.noSdxlCalls || !result.noBridgeCalls || !result.noServerConnectivityChecked || + !result.noWalletLifecycle || !result.noSyncStarted || !result.noSyncStatusPolled || + !result.noWorkerQueueEnqueue || !result.noWalletStateMutation || !result.noWalletPersistence || + !result.noSettingsPersistence || !result.noSendImportExportExecution || !result.noArtifactMutation; +} + +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffInput& input) +{ + LiteBridgeRuntimeBatch42ResultHandoffResult result; + result.status = LiteBridgeRuntimeStatus::Configured; + const auto& publicationGuard = input.publicationGuard; + result.platform = normalizedPlatform(input.platform.empty() ? publicationGuard.platform : input.platform); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName; + setBatch42ResultHandoffAttemptEvidence(input, result); + resetGeneratedLiteRuntimeCurrentExecutionGates(result); + + if (batch42ResultHandoffAttempted(result)) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch42ResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff must stop before callback, dispatch result execution, status publication, readiness publication, result-handoff publication, and platform loader APIs"); + result.summary = batch42ResultHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_or_platform_api_attempted"); + return result; + } + + if (batch42ResultHandoffRuntimeActionRequested(result)) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch42ResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff must not request wallet runtime behavior"); + result.summary = batch42ResultHandoffBlockedSummary("runtime_action_requested"); + return result; + } + + if (result.platform.empty()) { + result.status = LiteBridgeRuntimeStatus::Unavailable; + addBatch42ResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff requires a target platform"); + result.summary = batch42ResultHandoffBlockedSummary("platform_missing"); + return result; + } + + if (isMacosPlatform(result.platform)) { + result.macosDeferred = true; + result.status = LiteBridgeRuntimeStatus::Unavailable; + addBatch42ResultHandoffIssue( + result, + input.macosDeferredByOperator + ? "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff is deferred by operator request" + : "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff requires a reviewed builder before promotion"); + result.summary = batch42ResultHandoffBlockedSummary("macos_deferred"); + return result; + } + + const bool linuxPlatform = isLinuxPlatform(result.platform); + const bool windowsPlatform = isWindowsPlatform(result.platform); + if (!linuxPlatform && !windowsPlatform) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch42ResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff supports only Linux and Windows in batch 42"); + result.summary = batch42ResultHandoffBlockedSummary("unsupported_platform"); + return result; + } + result.platformAccepted = true; + result.linuxPlatformAccepted = linuxPlatform; + result.windowsPlatformAccepted = windowsPlatform; + + if (!input.publicationGuardAccepted || !publicationGuard.ok || + !publicationGuard.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardReady || + publicationGuard.status != LiteBridgeRuntimeStatus::Ready || publicationGuard.platform != result.platform || + !publicationGuard.publicationGuardRecordAccepted || !publicationGuard.publicationGuardStatusHandoffMatchAccepted || + !publicationGuard.disabledPublicationGuardAccepted || !publicationGuard.callbackInvocationRefused || + !publicationGuard.dispatchConsumptionStillGuarded || !publicationGuard.dispatchResultExecutionBlocked || + !publicationGuard.dispatchStatusPublicationBlocked || !publicationGuard.readinessProjectionPublicationBlocked || + !publicationGuard.statusHandoffPublicationBlocked || !publicationGuard.publicationGuardPublicationBlocked || + !publicationGuard.publicationGuardResultHandoffPublicationBlocked || + !publicationGuard.publicationGuardResultHandoffReadinessProjectionPublicationBlocked || + !publicationGuard.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked || + !publicationGuard.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked || + !publicationGuard.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationBlocked || + !publicationGuard.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationBlocked || + !publicationGuard.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked || + !publicationGuard.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked || + !publicationGuard.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationBlocked || + !publicationGuard.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationBlocked || + !publicationGuard.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked || + !publicationGuard.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked || + !publicationGuard.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked || + !publicationGuard.platformApiPreInvocationBlocked || !publicationGuard.disabledPublicationGuardStateAccepted || + !publicationGuard.publicationGuardFailureMappingAccepted || !publicationGuard.unloadExecutionBlocked || + !publicationGuard.symbolResolutionBlocked || !publicationGuard.productionLoaderDisabled || + !publicationGuard.realAdapterExecutionDisabled || !publicationGuard.loadOnlyExecutionDisabled || + !publicationGuard.separateExecutionBatchRequired || !publicationGuard.noRuntimePlatformDynamicLibraryLoaded || + !publicationGuard.noRuntimePlatformDynamicLibraryUnloaded || !publicationGuard.noRuntimePlatformSymbolResolution) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch42ResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff requires matching ready disabled publication-guard evidence"); + result.summary = batch42ResultHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_required"); + return result; + } + + static_cast(result) = publicationGuard; + result.ok = false; + result.status = LiteBridgeRuntimeStatus::Configured; + result.issues.clear(); + result.error.clear(); + result.summary.clear(); + result.platformAccepted = true; + result.linuxPlatformAccepted = linuxPlatform; + result.windowsPlatformAccepted = windowsPlatform; + result.macosDeferred = false; + result.publicationGuardAccepted = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName; + setBatch42ResultHandoffAttemptEvidence(input, result); + resetGeneratedLiteRuntimeCurrentExecutionGates(result); + + if (!input.resultHandoffReviewed || !input.resultHandoffRecorded || !input.resultHandoffDisabled || + input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId.empty() || + input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch42ResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff requires a reviewed disabled result-handoff record"); + result.summary = batch42ResultHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_required"); + return result; + } + result.resultHandoffRecordAccepted = true; + + if (!input.resultHandoffMatchesPublicationGuardEvidence || result.adapterName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch42ResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff requires result-handoff-to-publication-guard match evidence"); + result.summary = batch42ResultHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_match_required"); + return result; + } + result.resultHandoffPublicationGuardMatchAccepted = true; + + if (!input.disabledResultHandoffRegistered || !input.resultHandoffAcceptsPublicationGuardEvidence || + !input.resultHandoffReturnsDisabledResult || !input.resultHandoffBlocksDispatchConsumption || + !input.resultHandoffBlocksDispatchResultExecution || !input.resultHandoffBlocksStatusPublication || + !input.resultHandoffBlocksReadinessPublication || !input.resultHandoffBlocksStatusHandoffPublication || + !input.resultHandoffBlocksPublicationGuardPublication || !input.resultHandoffBlocksPublicationGuardResultHandoffPublication || + !input.resultHandoffBlocksPublicationGuardResultHandoffReadinessProjectionPublication || + !input.resultHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication || + !input.resultHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication || + !input.resultHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication || + !input.resultHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication || + !input.resultHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication || + !input.resultHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication || + !input.resultHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication || + !input.resultHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication || + !input.resultHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication || + !input.resultHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication || + !input.resultHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch42ResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff requires disabled result-handoff evidence"); + result.summary = batch42ResultHandoffBlockedSummary( + "disabled_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_required"); + return result; + } + result.disabledResultHandoffAccepted = true; + + if (!input.callbackInvocationStillDisabled || !input.callbackInvocationRefused || !input.callbackInvocationRefusalReviewed || + !input.resultHandoffStopsBeforeCallbackInvocation || !input.resultHandoffStopsBeforeCallbackResultExecution || + !input.resultHandoffStopsBeforeDispatchConsumption || !input.resultHandoffStopsBeforeDispatchResultExecution || + !input.resultHandoffStopsBeforeDispatchStatusPublication || !input.resultHandoffStopsBeforeReadinessPublication || + !input.resultHandoffStopsBeforeStatusHandoffPublication || !input.resultHandoffStopsBeforePublicationGuardPublication || + !input.resultHandoffStopsBeforePublicationGuardResultHandoffPublication || + !input.resultHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionPublication || + !input.resultHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication || + !input.resultHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication || + !input.resultHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication || + !input.resultHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication || + !input.resultHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication || + !input.resultHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication || + !input.resultHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication || + !input.resultHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication || + !input.resultHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication || + !input.resultHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication || + !input.resultHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication || + !input.resultHandoffStopsBeforePlatformApi || !input.resultHandoffRequiresSeparateExecutionBatch) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch42ResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff must remain disabled before callback, dispatch result execution, status publication, readiness publication, result publication, and platform APIs"); + result.summary = batch42ResultHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_disabled_state_required"); + return result; + } + result.callbackInvocationRefused = true; + result.dispatchConsumptionStillGuarded = true; + result.dispatchResultExecutionBlocked = true; + result.dispatchStatusPublicationBlocked = true; + result.readinessProjectionPublicationBlocked = true; + result.statusHandoffPublicationBlocked = true; + result.publicationGuardPublicationBlocked = true; + result.publicationGuardResultHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationBlocked = true; + result.platformApiPreInvocationBlocked = true; + + if (!input.resultHandoffProducesNoDynamicHandle || !input.resultHandoffStoresNoDynamicHandle || + !input.resultHandoffReleasesNoDynamicHandle || !input.resultHandoffResolvesNoSymbols || + !input.resultHandoffStoresNoSymbolTable || !input.resultHandoffCreatesNoRuntime) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch42ResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff must not create runtime loader state"); + result.summary = batch42ResultHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_runtime_state_required"); + return result; + } + result.disabledResultHandoffStateAccepted = true; + + if (!input.resultHandoffFailureMappingReviewed) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch42ResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff requires disabled result-handoff failure mapping review"); + result.summary = batch42ResultHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_failure_mapping_required"); + return result; + } + result.resultHandoffFailureMappingAccepted = true; + + if (!input.unloadExecutionStillDisabled || !input.symbolResolutionStillDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch42ResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff must keep unload and symbol resolution disabled"); + result.summary = batch42ResultHandoffBlockedSummary("non_load_execution_enabled"); + return result; + } + result.unloadExecutionBlocked = true; + result.symbolResolutionBlocked = true; + + if (!input.productionLoaderExecutionDisabled || !input.realAdapterExecutionDisabled || !input.loadOnlyExecutionDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch42ResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff must keep real loader execution disabled"); + result.summary = batch42ResultHandoffBlockedSummary("production_loader_enabled"); + return result; + } + result.productionLoaderDisabled = true; + result.realAdapterExecutionDisabled = true; + result.loadOnlyExecutionDisabled = true; + + if (!input.separateExecutionBatchRequired) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch42ResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff requires a separate execution batch"); + result.summary = batch42ResultHandoffBlockedSummary("separate_execution_batch_required"); + return result; + } + result.separateExecutionBatchRequired = true; + + result.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReady = true; + result.status = LiteBridgeRuntimeStatus::Ready; + result.ok = true; + result.summary = std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff=ready; platform=") + + result.platform + "; scope=load-only-disabled-callback-refusal-propagation-consumer-readiness-dispatch-consumption-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff; execution=disabled"; + return result; +} + +using LiteBridgeRuntimeBatch43ReadinessProjectionInput = LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionInput; +using LiteBridgeRuntimeBatch43ReadinessProjectionResult = LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionResult; + +static std::string batch43ReadinessProjectionBlockedSummary(const std::string& reason) +{ + return std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection=blocked; reason=") + reason; +} + +static void addBatch43ReadinessProjectionIssue(LiteBridgeRuntimeBatch43ReadinessProjectionResult& result, + const std::string& message) +{ + result.issues.push_back(message); + if (result.error.empty()) result.error = message; +} + +static void setBatch43ReadinessProjectionAttemptEvidence(const LiteBridgeRuntimeBatch43ReadinessProjectionInput& input, + LiteBridgeRuntimeBatch43ReadinessProjectionResult& result) +{ + result.noCallbackInvocationAttempted = !input.callbackInvocationAttempted; + result.noCallbackResultExecutionAttempted = !input.callbackResultExecutionAttempted; + result.noDispatchHandoffExecutionAttempted = !input.dispatchHandoffExecutionAttempted; + result.noDispatchStatusPublicationAttempted = !input.dispatchStatusPublicationAttempted; + result.noDispatchConsumerConsumptionAttempted = !input.dispatchConsumerConsumptionAttempted; + result.noDispatchResultExecutionAttempted = !input.dispatchResultExecutionAttempted; + result.noResultHandoffStatusPublicationAttempted = !input.resultHandoffStatusPublicationAttempted; + result.noReadinessProjectionStatusPublicationAttempted = !input.readinessProjectionStatusPublicationAttempted; + result.noStatusHandoffPublicationAttempted = !input.statusHandoffPublicationAttempted; + result.noPublicationGuardPublicationAttempted = !input.publicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noRuntimePlatformDynamicLibraryLoaded = !input.runtimePlatformLoadAttempted; + result.noRuntimePlatformDynamicLibraryUnloaded = !input.runtimePlatformUnloadAttempted; + result.noRuntimePlatformSymbolResolution = !input.runtimePlatformSymbolResolutionAttempted; + result.noSdxlCalls = !input.sdxlCallRequested; + result.noBridgeCalls = !input.bridgeCallRequested; + result.noServerConnectivityChecked = !input.serverConnectivityCheckRequested; + result.noWalletLifecycle = !input.walletLifecycleRequested; + result.noSyncStarted = !input.syncRequested; + result.noSyncStatusPolled = !input.syncStatusPollingRequested; + result.noWorkerQueueEnqueue = !input.workerQueueRequested; + result.noWalletStateMutation = !input.walletStateMutationRequested; + result.noWalletPersistence = !input.walletPersistenceRequested; + result.noSettingsPersistence = !input.settingsWriteRequested; + result.noSendImportExportExecution = !input.sendImportExportRequested; + result.noArtifactMutation = !input.artifactMutationRequested; +} + +static bool batch43ReadinessProjectionAttempted(const LiteBridgeRuntimeBatch43ReadinessProjectionResult& result) +{ + return !result.noCallbackInvocationAttempted || !result.noCallbackResultExecutionAttempted || + !result.noDispatchHandoffExecutionAttempted || !result.noDispatchStatusPublicationAttempted || + !result.noDispatchConsumerConsumptionAttempted || !result.noDispatchResultExecutionAttempted || + !result.noResultHandoffStatusPublicationAttempted || !result.noReadinessProjectionStatusPublicationAttempted || + !result.noStatusHandoffPublicationAttempted || !result.noPublicationGuardPublicationAttempted || + !result.noPublicationGuardResultHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !result.noRuntimePlatformDynamicLibraryLoaded || !result.noRuntimePlatformDynamicLibraryUnloaded || + !result.noRuntimePlatformSymbolResolution; +} + +static bool batch43ReadinessProjectionRuntimeActionRequested(const LiteBridgeRuntimeBatch43ReadinessProjectionResult& result) +{ + return !result.noSdxlCalls || !result.noBridgeCalls || !result.noServerConnectivityChecked || + !result.noWalletLifecycle || !result.noSyncStarted || !result.noSyncStatusPolled || + !result.noWorkerQueueEnqueue || !result.noWalletStateMutation || !result.noWalletPersistence || + !result.noSettingsPersistence || !result.noSendImportExportExecution || !result.noArtifactMutation; +} + +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionInput& input) +{ + LiteBridgeRuntimeBatch43ReadinessProjectionResult result; + result.status = LiteBridgeRuntimeStatus::Configured; + const auto& resultHandoff = input.resultHandoff; + result.platform = normalizedPlatform(input.platform.empty() ? resultHandoff.platform : input.platform); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName; + setBatch43ReadinessProjectionAttemptEvidence(input, result); + resetGeneratedLiteRuntimeCurrentExecutionGates(result); + + if (batch43ReadinessProjectionAttempted(result)) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch43ReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection must stop before callback, dispatch result execution, status publication, readiness publication, result-handoff readiness projection publication, and platform loader APIs"); + result.summary = batch43ReadinessProjectionBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_or_platform_api_attempted"); + return result; + } + + if (batch43ReadinessProjectionRuntimeActionRequested(result)) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch43ReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection must not request wallet runtime behavior"); + result.summary = batch43ReadinessProjectionBlockedSummary("runtime_action_requested"); + return result; + } + + if (result.platform.empty()) { + result.status = LiteBridgeRuntimeStatus::Unavailable; + addBatch43ReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection requires a target platform"); + result.summary = batch43ReadinessProjectionBlockedSummary("platform_missing"); + return result; + } + + if (isMacosPlatform(result.platform)) { + result.macosDeferred = true; + result.status = LiteBridgeRuntimeStatus::Unavailable; + addBatch43ReadinessProjectionIssue( + result, + input.macosDeferredByOperator + ? "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection is deferred by operator request" + : "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection requires a reviewed builder before promotion"); + result.summary = batch43ReadinessProjectionBlockedSummary("macos_deferred"); + return result; + } + + const bool linuxPlatform = isLinuxPlatform(result.platform); + const bool windowsPlatform = isWindowsPlatform(result.platform); + if (!linuxPlatform && !windowsPlatform) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch43ReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection supports only Linux and Windows in batch 43"); + result.summary = batch43ReadinessProjectionBlockedSummary("unsupported_platform"); + return result; + } + result.platformAccepted = true; + result.linuxPlatformAccepted = linuxPlatform; + result.windowsPlatformAccepted = windowsPlatform; + + if (!input.resultHandoffAccepted || !resultHandoff.ok || + !resultHandoff.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReady || + resultHandoff.status != LiteBridgeRuntimeStatus::Ready || resultHandoff.platform != result.platform || + !resultHandoff.publicationGuardAccepted || !resultHandoff.resultHandoffRecordAccepted || + !resultHandoff.resultHandoffPublicationGuardMatchAccepted || !resultHandoff.disabledResultHandoffAccepted || + !resultHandoff.callbackInvocationRefused || !resultHandoff.dispatchConsumptionStillGuarded || + !resultHandoff.dispatchResultExecutionBlocked || !resultHandoff.dispatchStatusPublicationBlocked || + !resultHandoff.readinessProjectionPublicationBlocked || !resultHandoff.statusHandoffPublicationBlocked || + !resultHandoff.publicationGuardPublicationBlocked || !resultHandoff.publicationGuardResultHandoffPublicationBlocked || + !resultHandoff.publicationGuardResultHandoffReadinessProjectionPublicationBlocked || + !resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked || + !resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked || + !resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationBlocked || + !resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationBlocked || + !resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked || + !resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked || + !resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationBlocked || + !resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationBlocked || + !resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked || + !resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked || + !resultHandoff.platformApiPreInvocationBlocked || !resultHandoff.disabledResultHandoffStateAccepted || + !resultHandoff.resultHandoffFailureMappingAccepted || !resultHandoff.unloadExecutionBlocked || + !resultHandoff.symbolResolutionBlocked || !resultHandoff.productionLoaderDisabled || + !resultHandoff.realAdapterExecutionDisabled || !resultHandoff.loadOnlyExecutionDisabled || + !resultHandoff.separateExecutionBatchRequired || !resultHandoff.noRuntimePlatformDynamicLibraryLoaded || + !resultHandoff.noRuntimePlatformDynamicLibraryUnloaded || !resultHandoff.noRuntimePlatformSymbolResolution || + !resultHandoff.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch43ReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection requires matching ready disabled result-handoff evidence"); + result.summary = batch43ReadinessProjectionBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_required"); + return result; + } + + static_cast(result) = resultHandoff; + result.ok = false; + result.status = LiteBridgeRuntimeStatus::Configured; + result.issues.clear(); + result.error.clear(); + result.summary.clear(); + result.platformAccepted = true; + result.linuxPlatformAccepted = linuxPlatform; + result.windowsPlatformAccepted = windowsPlatform; + result.macosDeferred = false; + result.resultHandoffAccepted = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName; + setBatch43ReadinessProjectionAttemptEvidence(input, result); + resetGeneratedLiteRuntimeCurrentExecutionGates(result); + + if (!input.readinessProjectionReviewed || !input.readinessProjectionRecorded || !input.readinessProjectionDisabled || + input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId.empty() || + input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch43ReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection requires a reviewed disabled readiness-projection record"); + result.summary = batch43ReadinessProjectionBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_required"); + return result; + } + result.readinessProjectionRecordAccepted = true; + + if (!input.readinessProjectionMatchesResultHandoffEvidence || result.adapterName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch43ReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection requires readiness-projection-to-result-handoff match evidence"); + result.summary = batch43ReadinessProjectionBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_match_required"); + return result; + } + result.readinessProjectionResultHandoffMatchAccepted = true; + + if (!input.disabledReadinessProjectionRegistered || !input.readinessProjectionAcceptsResultHandoffEvidence || + !input.readinessProjectionReturnsDisabledReadiness || !input.readinessProjectionBlocksDispatchConsumption || + !input.readinessProjectionBlocksDispatchResultExecution || !input.readinessProjectionBlocksStatusPublication || + !input.readinessProjectionBlocksReadinessPublication || !input.readinessProjectionBlocksStatusHandoffPublication || + !input.readinessProjectionBlocksPublicationGuardPublication || !input.readinessProjectionBlocksPublicationGuardResultHandoffPublication || + !input.readinessProjectionBlocksPublicationGuardResultHandoffReadinessProjectionPublication || + !input.readinessProjectionBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication || + !input.readinessProjectionBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication || + !input.readinessProjectionBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication || + !input.readinessProjectionBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication || + !input.readinessProjectionBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication || + !input.readinessProjectionBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication || + !input.readinessProjectionBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication || + !input.readinessProjectionBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication || + !input.readinessProjectionBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication || + !input.readinessProjectionBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication || + !input.readinessProjectionBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication || + !input.readinessProjectionBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch43ReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection requires disabled readiness-projection evidence"); + result.summary = batch43ReadinessProjectionBlockedSummary( + "disabled_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_required"); + return result; + } + result.disabledReadinessProjectionAccepted = true; + + if (!input.callbackInvocationStillDisabled || !input.callbackInvocationRefused || !input.callbackInvocationRefusalReviewed || + !input.readinessProjectionStopsBeforeCallbackInvocation || !input.readinessProjectionStopsBeforeCallbackResultExecution || + !input.readinessProjectionStopsBeforeDispatchConsumption || !input.readinessProjectionStopsBeforeDispatchResultExecution || + !input.readinessProjectionStopsBeforeDispatchStatusPublication || !input.readinessProjectionStopsBeforeReadinessPublication || + !input.readinessProjectionStopsBeforeStatusHandoffPublication || !input.readinessProjectionStopsBeforePublicationGuardPublication || + !input.readinessProjectionStopsBeforePublicationGuardResultHandoffPublication || + !input.readinessProjectionStopsBeforePublicationGuardResultHandoffReadinessProjectionPublication || + !input.readinessProjectionStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication || + !input.readinessProjectionStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication || + !input.readinessProjectionStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication || + !input.readinessProjectionStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication || + !input.readinessProjectionStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication || + !input.readinessProjectionStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication || + !input.readinessProjectionStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication || + !input.readinessProjectionStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication || + !input.readinessProjectionStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication || + !input.readinessProjectionStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication || + !input.readinessProjectionStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication || + !input.readinessProjectionStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication || + !input.readinessProjectionStopsBeforePlatformApi || !input.readinessProjectionRequiresSeparateExecutionBatch) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch43ReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection must remain disabled before callback, dispatch result execution, status publication, readiness publication, result publication, and platform APIs"); + result.summary = batch43ReadinessProjectionBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_disabled_state_required"); + return result; + } + result.callbackInvocationRefused = true; + result.dispatchConsumptionStillGuarded = true; + result.dispatchResultExecutionBlocked = true; + result.dispatchStatusPublicationBlocked = true; + result.readinessProjectionPublicationBlocked = true; + result.statusHandoffPublicationBlocked = true; + result.publicationGuardPublicationBlocked = true; + result.publicationGuardResultHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationBlocked = true; + result.platformApiPreInvocationBlocked = true; + + if (!input.readinessProjectionProducesNoDynamicHandle || !input.readinessProjectionStoresNoDynamicHandle || + !input.readinessProjectionReleasesNoDynamicHandle || !input.readinessProjectionResolvesNoSymbols || + !input.readinessProjectionStoresNoSymbolTable || !input.readinessProjectionCreatesNoRuntime) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch43ReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection must not create runtime loader state"); + result.summary = batch43ReadinessProjectionBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_runtime_state_required"); + return result; + } + result.disabledReadinessProjectionStateAccepted = true; + + if (!input.readinessProjectionFailureMappingReviewed) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch43ReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection requires disabled readiness-projection failure mapping review"); + result.summary = batch43ReadinessProjectionBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_failure_mapping_required"); + return result; + } + result.readinessProjectionFailureMappingAccepted = true; + + if (!input.unloadExecutionStillDisabled || !input.symbolResolutionStillDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch43ReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection must keep unload and symbol resolution disabled"); + result.summary = batch43ReadinessProjectionBlockedSummary("non_load_execution_enabled"); + return result; + } + result.unloadExecutionBlocked = true; + result.symbolResolutionBlocked = true; + + if (!input.productionLoaderExecutionDisabled || !input.realAdapterExecutionDisabled || !input.loadOnlyExecutionDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch43ReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection must keep real loader execution disabled"); + result.summary = batch43ReadinessProjectionBlockedSummary("production_loader_enabled"); + return result; + } + result.productionLoaderDisabled = true; + result.realAdapterExecutionDisabled = true; + result.loadOnlyExecutionDisabled = true; + + if (!input.separateExecutionBatchRequired) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch43ReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection requires a separate execution batch"); + result.summary = batch43ReadinessProjectionBlockedSummary("separate_execution_batch_required"); + return result; + } + result.separateExecutionBatchRequired = true; + + result.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionReady = true; + result.status = LiteBridgeRuntimeStatus::Ready; + result.ok = true; + result.summary = std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection=ready; platform=") + + result.platform + "; scope=load-only-disabled-callback-refusal-propagation-consumer-readiness-dispatch-consumption-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection; execution=disabled"; + return result; +} + +using LiteBridgeRuntimeBatch44StatusHandoffInput = LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffInput; +using LiteBridgeRuntimeBatch44StatusHandoffResult = LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffResult; + +static std::string batch44StatusHandoffBlockedSummary(const std::string& reason) +{ + return std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff=blocked; reason=") + reason; +} + +static void addBatch44StatusHandoffIssue(LiteBridgeRuntimeBatch44StatusHandoffResult& result, + const std::string& message) +{ + result.issues.push_back(message); + if (result.error.empty()) result.error = message; +} + +static void setBatch44StatusHandoffAttemptEvidence(const LiteBridgeRuntimeBatch44StatusHandoffInput& input, + LiteBridgeRuntimeBatch44StatusHandoffResult& result) +{ + result.noCallbackInvocationAttempted = !input.callbackInvocationAttempted; + result.noCallbackResultExecutionAttempted = !input.callbackResultExecutionAttempted; + result.noDispatchHandoffExecutionAttempted = !input.dispatchHandoffExecutionAttempted; + result.noDispatchStatusPublicationAttempted = !input.dispatchStatusPublicationAttempted; + result.noDispatchConsumerConsumptionAttempted = !input.dispatchConsumerConsumptionAttempted; + result.noDispatchResultExecutionAttempted = !input.dispatchResultExecutionAttempted; + result.noResultHandoffStatusPublicationAttempted = !input.resultHandoffStatusPublicationAttempted; + result.noReadinessProjectionStatusPublicationAttempted = !input.readinessProjectionStatusPublicationAttempted; + result.noStatusHandoffPublicationAttempted = !input.statusHandoffPublicationAttempted; + result.noPublicationGuardPublicationAttempted = !input.publicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noRuntimePlatformDynamicLibraryLoaded = !input.runtimePlatformLoadAttempted; + result.noRuntimePlatformDynamicLibraryUnloaded = !input.runtimePlatformUnloadAttempted; + result.noRuntimePlatformSymbolResolution = !input.runtimePlatformSymbolResolutionAttempted; + result.noSdxlCalls = !input.sdxlCallRequested; + result.noBridgeCalls = !input.bridgeCallRequested; + result.noServerConnectivityChecked = !input.serverConnectivityCheckRequested; + result.noWalletLifecycle = !input.walletLifecycleRequested; + result.noSyncStarted = !input.syncRequested; + result.noSyncStatusPolled = !input.syncStatusPollingRequested; + result.noWorkerQueueEnqueue = !input.workerQueueRequested; + result.noWalletStateMutation = !input.walletStateMutationRequested; + result.noWalletPersistence = !input.walletPersistenceRequested; + result.noSettingsPersistence = !input.settingsWriteRequested; + result.noSendImportExportExecution = !input.sendImportExportRequested; + result.noArtifactMutation = !input.artifactMutationRequested; +} + +static bool batch44StatusHandoffAttempted(const LiteBridgeRuntimeBatch44StatusHandoffResult& result) +{ + return !result.noCallbackInvocationAttempted || !result.noCallbackResultExecutionAttempted || + !result.noDispatchHandoffExecutionAttempted || !result.noDispatchStatusPublicationAttempted || + !result.noDispatchConsumerConsumptionAttempted || !result.noDispatchResultExecutionAttempted || + !result.noResultHandoffStatusPublicationAttempted || !result.noReadinessProjectionStatusPublicationAttempted || + !result.noStatusHandoffPublicationAttempted || !result.noPublicationGuardPublicationAttempted || + !result.noPublicationGuardResultHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !result.noRuntimePlatformDynamicLibraryLoaded || !result.noRuntimePlatformDynamicLibraryUnloaded || + !result.noRuntimePlatformSymbolResolution; +} + +static bool batch44StatusHandoffRuntimeActionRequested(const LiteBridgeRuntimeBatch44StatusHandoffResult& result) +{ + return !result.noSdxlCalls || !result.noBridgeCalls || !result.noServerConnectivityChecked || + !result.noWalletLifecycle || !result.noSyncStarted || !result.noSyncStatusPolled || + !result.noWorkerQueueEnqueue || !result.noWalletStateMutation || !result.noWalletPersistence || + !result.noSettingsPersistence || !result.noSendImportExportExecution || !result.noArtifactMutation; +} + +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffInput& input) +{ + LiteBridgeRuntimeBatch44StatusHandoffResult result; + result.status = LiteBridgeRuntimeStatus::Configured; + const auto& readinessProjection = input.readinessProjection; + result.platform = normalizedPlatform(input.platform.empty() ? readinessProjection.platform : input.platform); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName; + setBatch44StatusHandoffAttemptEvidence(input, result); + resetGeneratedLiteRuntimeCurrentExecutionGates(result); + + if (batch44StatusHandoffAttempted(result)) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch44StatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff must stop before callback, dispatch result execution, status publication, readiness publication, status-handoff publication, and platform loader APIs"); + result.summary = batch44StatusHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_or_platform_api_attempted"); + return result; + } + + if (batch44StatusHandoffRuntimeActionRequested(result)) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch44StatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff must not request wallet runtime behavior"); + result.summary = batch44StatusHandoffBlockedSummary("runtime_action_requested"); + return result; + } + + if (result.platform.empty()) { + result.status = LiteBridgeRuntimeStatus::Unavailable; + addBatch44StatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff requires a target platform"); + result.summary = batch44StatusHandoffBlockedSummary("platform_missing"); + return result; + } + + if (isMacosPlatform(result.platform)) { + result.macosDeferred = true; + result.status = LiteBridgeRuntimeStatus::Unavailable; + addBatch44StatusHandoffIssue( + result, + input.macosDeferredByOperator + ? "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff is deferred by operator request" + : "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff requires a reviewed builder before promotion"); + result.summary = batch44StatusHandoffBlockedSummary("macos_deferred"); + return result; + } + + const bool linuxPlatform = isLinuxPlatform(result.platform); + const bool windowsPlatform = isWindowsPlatform(result.platform); + if (!linuxPlatform && !windowsPlatform) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch44StatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff supports only Linux and Windows in batch 44"); + result.summary = batch44StatusHandoffBlockedSummary("unsupported_platform"); + return result; + } + result.platformAccepted = true; + result.linuxPlatformAccepted = linuxPlatform; + result.windowsPlatformAccepted = windowsPlatform; + + if (!input.readinessProjectionAccepted || !readinessProjection.ok || + !readinessProjection.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionReady || + readinessProjection.status != LiteBridgeRuntimeStatus::Ready || readinessProjection.platform != result.platform || + !readinessProjection.resultHandoffAccepted || !readinessProjection.readinessProjectionRecordAccepted || + !readinessProjection.readinessProjectionResultHandoffMatchAccepted || !readinessProjection.disabledReadinessProjectionAccepted || + !readinessProjection.callbackInvocationRefused || !readinessProjection.dispatchConsumptionStillGuarded || + !readinessProjection.dispatchResultExecutionBlocked || !readinessProjection.dispatchStatusPublicationBlocked || + !readinessProjection.readinessProjectionPublicationBlocked || !readinessProjection.statusHandoffPublicationBlocked || + !readinessProjection.publicationGuardPublicationBlocked || !readinessProjection.publicationGuardResultHandoffPublicationBlocked || + !readinessProjection.publicationGuardResultHandoffReadinessProjectionPublicationBlocked || + !readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked || + !readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked || + !readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationBlocked || + !readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationBlocked || + !readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked || + !readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked || + !readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked || + !readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked || + !readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationBlocked || + !readinessProjection.platformApiPreInvocationBlocked || !readinessProjection.disabledReadinessProjectionStateAccepted || + !readinessProjection.readinessProjectionFailureMappingAccepted || !readinessProjection.unloadExecutionBlocked || + !readinessProjection.symbolResolutionBlocked || !readinessProjection.productionLoaderDisabled || + !readinessProjection.realAdapterExecutionDisabled || !readinessProjection.loadOnlyExecutionDisabled || + !readinessProjection.separateExecutionBatchRequired || !readinessProjection.noRuntimePlatformDynamicLibraryLoaded || + !readinessProjection.noRuntimePlatformDynamicLibraryUnloaded || !readinessProjection.noRuntimePlatformSymbolResolution || + !readinessProjection.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch44StatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff requires matching ready disabled readiness-projection evidence"); + result.summary = batch44StatusHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_required"); + return result; + } + + static_cast(result) = readinessProjection; + result.ok = false; + result.status = LiteBridgeRuntimeStatus::Configured; + result.issues.clear(); + result.error.clear(); + result.summary.clear(); + result.platformAccepted = true; + result.linuxPlatformAccepted = linuxPlatform; + result.windowsPlatformAccepted = windowsPlatform; + result.macosDeferred = false; + result.readinessProjectionAccepted = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName; + setBatch44StatusHandoffAttemptEvidence(input, result); + resetGeneratedLiteRuntimeCurrentExecutionGates(result); + + if (!input.statusHandoffReviewed || !input.statusHandoffRecorded || !input.statusHandoffDisabled || + input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId.empty() || + input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch44StatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff requires a reviewed disabled status-handoff record"); + result.summary = batch44StatusHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_required"); + return result; + } + result.statusHandoffRecordAccepted = true; + + if (!input.statusHandoffMatchesReadinessProjectionEvidence || result.adapterName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch44StatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff requires status-handoff-to-readiness-projection match evidence"); + result.summary = batch44StatusHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_match_required"); + return result; + } + result.statusHandoffReadinessProjectionMatchAccepted = true; + + if (!input.disabledStatusHandoffRegistered || !input.statusHandoffAcceptsReadinessProjectionEvidence || + !input.statusHandoffReturnsDisabledStatus || !input.statusHandoffBlocksDispatchConsumption || + !input.statusHandoffBlocksDispatchResultExecution || !input.statusHandoffBlocksStatusPublication || + !input.statusHandoffBlocksReadinessPublication || !input.statusHandoffBlocksStatusHandoffPublication || + !input.statusHandoffBlocksPublicationGuardPublication || !input.statusHandoffBlocksPublicationGuardResultHandoffPublication || + !input.statusHandoffBlocksPublicationGuardResultHandoffReadinessProjectionPublication || + !input.statusHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication || + !input.statusHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication || + !input.statusHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication || + !input.statusHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication || + !input.statusHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication || + !input.statusHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication || + !input.statusHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication || + !input.statusHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication || + !input.statusHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication || + !input.statusHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication || + !input.statusHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication || + !input.statusHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication || + !input.statusHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch44StatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff requires disabled status-handoff evidence"); + result.summary = batch44StatusHandoffBlockedSummary( + "disabled_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_required"); + return result; + } + result.disabledStatusHandoffAccepted = true; + + if (!input.callbackInvocationStillDisabled || !input.callbackInvocationRefused || !input.callbackInvocationRefusalReviewed || + !input.statusHandoffStopsBeforeCallbackInvocation || !input.statusHandoffStopsBeforeCallbackResultExecution || + !input.statusHandoffStopsBeforeDispatchConsumption || !input.statusHandoffStopsBeforeDispatchResultExecution || + !input.statusHandoffStopsBeforeDispatchStatusPublication || !input.statusHandoffStopsBeforeReadinessPublication || + !input.statusHandoffStopsBeforeStatusHandoffPublication || !input.statusHandoffStopsBeforePublicationGuardPublication || + !input.statusHandoffStopsBeforePublicationGuardResultHandoffPublication || + !input.statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionPublication || + !input.statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication || + !input.statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication || + !input.statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication || + !input.statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication || + !input.statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication || + !input.statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication || + !input.statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication || + !input.statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication || + !input.statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication || + !input.statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication || + !input.statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication || + !input.statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication || + !input.statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication || + !input.statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication || + !input.statusHandoffStopsBeforePlatformApi || !input.statusHandoffRequiresSeparateExecutionBatch) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch44StatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff must remain disabled before callback, dispatch result execution, status publication, readiness publication, status handoff, and platform APIs"); + result.summary = batch44StatusHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_disabled_state_required"); + return result; + } + result.callbackInvocationRefused = true; + result.dispatchConsumptionStillGuarded = true; + result.dispatchResultExecutionBlocked = true; + result.dispatchStatusPublicationBlocked = true; + result.readinessProjectionPublicationBlocked = true; + result.statusHandoffPublicationBlocked = true; + result.publicationGuardPublicationBlocked = true; + result.publicationGuardResultHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked = true; + result.platformApiPreInvocationBlocked = true; + + if (!input.statusHandoffProducesNoDynamicHandle || !input.statusHandoffStoresNoDynamicHandle || + !input.statusHandoffReleasesNoDynamicHandle || !input.statusHandoffResolvesNoSymbols || + !input.statusHandoffStoresNoSymbolTable || !input.statusHandoffCreatesNoRuntime) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch44StatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff must not create runtime loader state"); + result.summary = batch44StatusHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_runtime_state_required"); + return result; + } + result.disabledStatusHandoffStateAccepted = true; + + if (!input.statusHandoffFailureMappingReviewed) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch44StatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff requires disabled status-handoff failure mapping review"); + result.summary = batch44StatusHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_failure_mapping_required"); + return result; + } + result.statusHandoffFailureMappingAccepted = true; + + if (!input.unloadExecutionStillDisabled || !input.symbolResolutionStillDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch44StatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff must keep unload and symbol resolution disabled"); + result.summary = batch44StatusHandoffBlockedSummary("non_load_execution_enabled"); + return result; + } + result.unloadExecutionBlocked = true; + result.symbolResolutionBlocked = true; + + if (!input.productionLoaderExecutionDisabled || !input.realAdapterExecutionDisabled || !input.loadOnlyExecutionDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch44StatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff must keep real loader execution disabled"); + result.summary = batch44StatusHandoffBlockedSummary("production_loader_enabled"); + return result; + } + result.productionLoaderDisabled = true; + result.realAdapterExecutionDisabled = true; + result.loadOnlyExecutionDisabled = true; + + if (!input.separateExecutionBatchRequired) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch44StatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff requires a separate execution batch"); + result.summary = batch44StatusHandoffBlockedSummary("separate_execution_batch_required"); + return result; + } + result.separateExecutionBatchRequired = true; + + result.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffReady = true; + result.status = LiteBridgeRuntimeStatus::Ready; + result.ok = true; + result.summary = std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff=ready; platform=") + + result.platform + "; scope=load-only-disabled-callback-refusal-propagation-consumer-readiness-dispatch-consumption-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff; execution=disabled"; + return result; +} + +using LiteBridgeRuntimeBatch45PublicationGuardInput = LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardInput; +using LiteBridgeRuntimeBatch45PublicationGuardResult = LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResult; + +static std::string batch45PublicationGuardBlockedSummary(const std::string& reason) +{ + return std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard=blocked; reason=") + reason; +} + +static void addBatch45PublicationGuardIssue(LiteBridgeRuntimeBatch45PublicationGuardResult& result, + const std::string& message) +{ + result.issues.push_back(message); + if (result.error.empty()) result.error = message; +} + +static void setBatch45PublicationGuardAttemptEvidence(const LiteBridgeRuntimeBatch45PublicationGuardInput& input, + LiteBridgeRuntimeBatch45PublicationGuardResult& result) +{ + result.noCallbackInvocationAttempted = !input.callbackInvocationAttempted; + result.noCallbackResultExecutionAttempted = !input.callbackResultExecutionAttempted; + result.noDispatchHandoffExecutionAttempted = !input.dispatchHandoffExecutionAttempted; + result.noDispatchStatusPublicationAttempted = !input.dispatchStatusPublicationAttempted; + result.noDispatchConsumerConsumptionAttempted = !input.dispatchConsumerConsumptionAttempted; + result.noDispatchResultExecutionAttempted = !input.dispatchResultExecutionAttempted; + result.noResultHandoffStatusPublicationAttempted = !input.resultHandoffStatusPublicationAttempted; + result.noReadinessProjectionStatusPublicationAttempted = !input.readinessProjectionStatusPublicationAttempted; + result.noStatusHandoffPublicationAttempted = !input.statusHandoffPublicationAttempted; + result.noPublicationGuardPublicationAttempted = !input.publicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted; + result.noRuntimePlatformDynamicLibraryLoaded = !input.runtimePlatformLoadAttempted; + result.noRuntimePlatformDynamicLibraryUnloaded = !input.runtimePlatformUnloadAttempted; + result.noRuntimePlatformSymbolResolution = !input.runtimePlatformSymbolResolutionAttempted; + result.noSdxlCalls = !input.sdxlCallRequested; + result.noBridgeCalls = !input.bridgeCallRequested; + result.noServerConnectivityChecked = !input.serverConnectivityCheckRequested; + result.noWalletLifecycle = !input.walletLifecycleRequested; + result.noSyncStarted = !input.syncRequested; + result.noSyncStatusPolled = !input.syncStatusPollingRequested; + result.noWorkerQueueEnqueue = !input.workerQueueRequested; + result.noWalletStateMutation = !input.walletStateMutationRequested; + result.noWalletPersistence = !input.walletPersistenceRequested; + result.noSettingsPersistence = !input.settingsWriteRequested; + result.noSendImportExportExecution = !input.sendImportExportRequested; + result.noArtifactMutation = !input.artifactMutationRequested; +} + +static bool batch45PublicationGuardAttempted(const LiteBridgeRuntimeBatch45PublicationGuardResult& result) +{ + return !result.noCallbackInvocationAttempted || !result.noCallbackResultExecutionAttempted || + !result.noDispatchHandoffExecutionAttempted || !result.noDispatchStatusPublicationAttempted || + !result.noDispatchConsumerConsumptionAttempted || !result.noDispatchResultExecutionAttempted || + !result.noResultHandoffStatusPublicationAttempted || !result.noReadinessProjectionStatusPublicationAttempted || + !result.noStatusHandoffPublicationAttempted || !result.noPublicationGuardPublicationAttempted || + !result.noPublicationGuardResultHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted || + !result.noRuntimePlatformDynamicLibraryLoaded || !result.noRuntimePlatformDynamicLibraryUnloaded || + !result.noRuntimePlatformSymbolResolution; +} + +static bool batch45PublicationGuardRuntimeActionRequested(const LiteBridgeRuntimeBatch45PublicationGuardResult& result) +{ + return !result.noSdxlCalls || !result.noBridgeCalls || !result.noServerConnectivityChecked || + !result.noWalletLifecycle || !result.noSyncStarted || !result.noSyncStatusPolled || + !result.noWorkerQueueEnqueue || !result.noWalletStateMutation || !result.noWalletPersistence || + !result.noSettingsPersistence || !result.noSendImportExportExecution || !result.noArtifactMutation; +} + +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardInput& input) +{ + LiteBridgeRuntimeBatch45PublicationGuardResult result; + result.status = LiteBridgeRuntimeStatus::Configured; + const auto& statusHandoff = input.statusHandoff; + result.platform = normalizedPlatform(input.platform.empty() ? statusHandoff.platform : input.platform); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName; + setBatch45PublicationGuardAttemptEvidence(input, result); + resetGeneratedLiteRuntimeCurrentExecutionGates(result); + + if (batch45PublicationGuardAttempted(result)) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch45PublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard must stop before callback, dispatch result execution, status publication, readiness publication, publication guard publication, and platform loader APIs"); + result.summary = batch45PublicationGuardBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_or_platform_api_attempted"); + return result; + } + + if (batch45PublicationGuardRuntimeActionRequested(result)) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch45PublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard must not request wallet runtime behavior"); + result.summary = batch45PublicationGuardBlockedSummary("runtime_action_requested"); + return result; + } + + if (result.platform.empty()) { + result.status = LiteBridgeRuntimeStatus::Unavailable; + addBatch45PublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard requires a target platform"); + result.summary = batch45PublicationGuardBlockedSummary("platform_missing"); + return result; + } + + if (isMacosPlatform(result.platform)) { + result.macosDeferred = true; + result.status = LiteBridgeRuntimeStatus::Unavailable; + addBatch45PublicationGuardIssue( + result, + input.macosDeferredByOperator + ? "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard is deferred by operator request" + : "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard requires a reviewed builder before promotion"); + result.summary = batch45PublicationGuardBlockedSummary("macos_deferred"); + return result; + } + + const bool linuxPlatform = isLinuxPlatform(result.platform); + const bool windowsPlatform = isWindowsPlatform(result.platform); + if (!linuxPlatform && !windowsPlatform) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch45PublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard supports only Linux and Windows in batch 45"); + result.summary = batch45PublicationGuardBlockedSummary("unsupported_platform"); + return result; + } + result.platformAccepted = true; + result.linuxPlatformAccepted = linuxPlatform; + result.windowsPlatformAccepted = windowsPlatform; + + if (!input.statusHandoffAccepted || !statusHandoff.ok || + !statusHandoff.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffReady || + statusHandoff.status != LiteBridgeRuntimeStatus::Ready || statusHandoff.platform != result.platform || + !statusHandoff.readinessProjectionAccepted || !statusHandoff.statusHandoffRecordAccepted || + !statusHandoff.statusHandoffReadinessProjectionMatchAccepted || !statusHandoff.disabledStatusHandoffAccepted || + !statusHandoff.callbackInvocationRefused || !statusHandoff.dispatchConsumptionStillGuarded || + !statusHandoff.dispatchResultExecutionBlocked || !statusHandoff.dispatchStatusPublicationBlocked || + !statusHandoff.readinessProjectionPublicationBlocked || !statusHandoff.statusHandoffPublicationBlocked || + !statusHandoff.publicationGuardPublicationBlocked || + !statusHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked || + !statusHandoff.platformApiPreInvocationBlocked || !statusHandoff.disabledStatusHandoffStateAccepted || + !statusHandoff.statusHandoffFailureMappingAccepted || !statusHandoff.unloadExecutionBlocked || + !statusHandoff.symbolResolutionBlocked || !statusHandoff.productionLoaderDisabled || + !statusHandoff.realAdapterExecutionDisabled || !statusHandoff.loadOnlyExecutionDisabled || + !statusHandoff.separateExecutionBatchRequired || !statusHandoff.noRuntimePlatformDynamicLibraryLoaded || + !statusHandoff.noRuntimePlatformDynamicLibraryUnloaded || !statusHandoff.noRuntimePlatformSymbolResolution || + !statusHandoff.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch45PublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard requires matching ready disabled status-handoff evidence"); + result.summary = batch45PublicationGuardBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_required"); + return result; + } + + static_cast(result) = statusHandoff; + result.ok = false; + result.status = LiteBridgeRuntimeStatus::Configured; + result.issues.clear(); + result.error.clear(); + result.summary.clear(); + result.platformAccepted = true; + result.linuxPlatformAccepted = linuxPlatform; + result.windowsPlatformAccepted = windowsPlatform; + result.macosDeferred = false; + result.statusHandoffAccepted = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName; + setBatch45PublicationGuardAttemptEvidence(input, result); + resetGeneratedLiteRuntimeCurrentExecutionGates(result); + + if (!input.publicationGuardReviewed || !input.publicationGuardRecorded || !input.publicationGuardDisabled || + input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId.empty() || + input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch45PublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard requires a reviewed disabled publication-guard record"); + result.summary = batch45PublicationGuardBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_required"); + return result; + } + result.publicationGuardRecordAccepted = true; + + if (!input.publicationGuardMatchesStatusHandoffEvidence || result.adapterName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch45PublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard requires publication-guard-to-status-handoff match evidence"); + result.summary = batch45PublicationGuardBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_match_required"); + return result; + } + result.publicationGuardStatusHandoffMatchAccepted = true; + + if (!input.disabledPublicationGuardRegistered || !input.publicationGuardAcceptsStatusHandoffEvidence || + !input.publicationGuardReturnsDisabledPublication || !input.publicationGuardBlocksDispatchConsumption || + !input.publicationGuardBlocksDispatchResultExecution || !input.publicationGuardBlocksStatusPublication || + !input.publicationGuardBlocksReadinessPublication || !input.publicationGuardBlocksStatusHandoffPublication || + !input.publicationGuardBlocksPublicationGuardPublication || + !input.publicationGuardBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch45PublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard requires disabled publication-guard evidence"); + result.summary = batch45PublicationGuardBlockedSummary( + "disabled_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_required"); + return result; + } + result.disabledPublicationGuardAccepted = true; + + if (!input.callbackInvocationStillDisabled || !input.callbackInvocationRefused || !input.callbackInvocationRefusalReviewed || + !input.publicationGuardStopsBeforeCallbackInvocation || !input.publicationGuardStopsBeforeCallbackResultExecution || + !input.publicationGuardStopsBeforeDispatchConsumption || !input.publicationGuardStopsBeforeDispatchResultExecution || + !input.publicationGuardStopsBeforeDispatchStatusPublication || !input.publicationGuardStopsBeforeReadinessPublication || + !input.publicationGuardStopsBeforeStatusHandoffPublication || !input.publicationGuardStopsBeforePublicationGuardPublication || + !input.publicationGuardStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication || + !input.publicationGuardStopsBeforePlatformApi || !input.publicationGuardRequiresSeparateExecutionBatch) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch45PublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard must remain disabled before callback, dispatch result execution, status publication, readiness publication, publication, and platform APIs"); + result.summary = batch45PublicationGuardBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_disabled_state_required"); + return result; + } + result.callbackInvocationRefused = true; + result.dispatchConsumptionStillGuarded = true; + result.dispatchResultExecutionBlocked = true; + result.dispatchStatusPublicationBlocked = true; + result.readinessProjectionPublicationBlocked = true; + result.statusHandoffPublicationBlocked = true; + result.publicationGuardPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked = true; + result.platformApiPreInvocationBlocked = true; + + if (!input.publicationGuardProducesNoDynamicHandle || !input.publicationGuardStoresNoDynamicHandle || + !input.publicationGuardReleasesNoDynamicHandle || !input.publicationGuardResolvesNoSymbols || + !input.publicationGuardStoresNoSymbolTable || !input.publicationGuardCreatesNoRuntime) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch45PublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard must not create runtime loader state"); + result.summary = batch45PublicationGuardBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_runtime_state_required"); + return result; + } + result.disabledPublicationGuardStateAccepted = true; + + if (!input.publicationGuardFailureMappingReviewed) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch45PublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard requires disabled publication-guard failure mapping review"); + result.summary = batch45PublicationGuardBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_failure_mapping_required"); + return result; + } + result.publicationGuardFailureMappingAccepted = true; + + if (!input.unloadExecutionStillDisabled || !input.symbolResolutionStillDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch45PublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard must keep unload and symbol resolution disabled"); + result.summary = batch45PublicationGuardBlockedSummary("non_load_execution_enabled"); + return result; + } + result.unloadExecutionBlocked = true; + result.symbolResolutionBlocked = true; + + if (!input.productionLoaderExecutionDisabled || !input.realAdapterExecutionDisabled || !input.loadOnlyExecutionDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch45PublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard must keep real loader execution disabled"); + result.summary = batch45PublicationGuardBlockedSummary("production_loader_enabled"); + return result; + } + result.productionLoaderDisabled = true; + result.realAdapterExecutionDisabled = true; + result.loadOnlyExecutionDisabled = true; + + if (!input.separateExecutionBatchRequired) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch45PublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard requires a separate execution batch"); + result.summary = batch45PublicationGuardBlockedSummary("separate_execution_batch_required"); + return result; + } + result.separateExecutionBatchRequired = true; + + result.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardReady = true; + result.status = LiteBridgeRuntimeStatus::Ready; + result.ok = true; + result.summary = std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard=ready; platform=") + + result.platform + "; scope=load-only-disabled-callback-refusal-propagation-consumer-readiness-dispatch-consumption-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard; execution=disabled"; + return result; +} + +using LiteBridgeRuntimeBatch46ResultHandoffInput = LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffInput; +using LiteBridgeRuntimeBatch46ResultHandoffResult = LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffResult; + +static std::string batch46ResultHandoffBlockedSummary(const std::string& reason) +{ + return std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff=blocked; reason=") + reason; +} + +static void addBatch46ResultHandoffIssue(LiteBridgeRuntimeBatch46ResultHandoffResult& result, + const std::string& message) +{ + result.issues.push_back(message); + if (result.error.empty()) result.error = message; +} + +static void setBatch46ResultHandoffAttemptEvidence(const LiteBridgeRuntimeBatch46ResultHandoffInput& input, + LiteBridgeRuntimeBatch46ResultHandoffResult& result) +{ + result.noCallbackInvocationAttempted = !input.callbackInvocationAttempted; + result.noCallbackResultExecutionAttempted = !input.callbackResultExecutionAttempted; + result.noDispatchHandoffExecutionAttempted = !input.dispatchHandoffExecutionAttempted; + result.noDispatchStatusPublicationAttempted = !input.dispatchStatusPublicationAttempted; + result.noDispatchConsumerConsumptionAttempted = !input.dispatchConsumerConsumptionAttempted; + result.noDispatchResultExecutionAttempted = !input.dispatchResultExecutionAttempted; + result.noResultHandoffStatusPublicationAttempted = !input.resultHandoffStatusPublicationAttempted; + result.noReadinessProjectionStatusPublicationAttempted = !input.readinessProjectionStatusPublicationAttempted; + result.noStatusHandoffPublicationAttempted = !input.statusHandoffPublicationAttempted; + result.noPublicationGuardPublicationAttempted = !input.publicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted; + result.noRuntimePlatformDynamicLibraryLoaded = !input.runtimePlatformLoadAttempted; + result.noRuntimePlatformDynamicLibraryUnloaded = !input.runtimePlatformUnloadAttempted; + result.noRuntimePlatformSymbolResolution = !input.runtimePlatformSymbolResolutionAttempted; + result.noSdxlCalls = !input.sdxlCallRequested; + result.noBridgeCalls = !input.bridgeCallRequested; + result.noServerConnectivityChecked = !input.serverConnectivityCheckRequested; + result.noWalletLifecycle = !input.walletLifecycleRequested; + result.noSyncStarted = !input.syncRequested; + result.noSyncStatusPolled = !input.syncStatusPollingRequested; + result.noWorkerQueueEnqueue = !input.workerQueueRequested; + result.noWalletStateMutation = !input.walletStateMutationRequested; + result.noWalletPersistence = !input.walletPersistenceRequested; + result.noSettingsPersistence = !input.settingsWriteRequested; + result.noSendImportExportExecution = !input.sendImportExportRequested; + result.noArtifactMutation = !input.artifactMutationRequested; +} + +static bool batch46ResultHandoffAttempted(const LiteBridgeRuntimeBatch46ResultHandoffResult& result) +{ + return !result.noCallbackInvocationAttempted || !result.noCallbackResultExecutionAttempted || + !result.noDispatchHandoffExecutionAttempted || !result.noDispatchStatusPublicationAttempted || + !result.noDispatchConsumerConsumptionAttempted || !result.noDispatchResultExecutionAttempted || + !result.noResultHandoffStatusPublicationAttempted || !result.noReadinessProjectionStatusPublicationAttempted || + !result.noStatusHandoffPublicationAttempted || !result.noPublicationGuardPublicationAttempted || + !result.noPublicationGuardResultHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted || + !result.noRuntimePlatformDynamicLibraryLoaded || !result.noRuntimePlatformDynamicLibraryUnloaded || + !result.noRuntimePlatformSymbolResolution; +} + +static bool batch46ResultHandoffRuntimeActionRequested(const LiteBridgeRuntimeBatch46ResultHandoffResult& result) +{ + return !result.noSdxlCalls || !result.noBridgeCalls || !result.noServerConnectivityChecked || + !result.noWalletLifecycle || !result.noSyncStarted || !result.noSyncStatusPolled || + !result.noWorkerQueueEnqueue || !result.noWalletStateMutation || !result.noWalletPersistence || + !result.noSettingsPersistence || !result.noSendImportExportExecution || !result.noArtifactMutation; +} + +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffInput& input) +{ + LiteBridgeRuntimeBatch46ResultHandoffResult result; + result.status = LiteBridgeRuntimeStatus::Configured; + const auto& publicationGuard = input.publicationGuard; + result.platform = normalizedPlatform(input.platform.empty() ? publicationGuard.platform : input.platform); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName; + setBatch46ResultHandoffAttemptEvidence(input, result); + resetGeneratedLiteRuntimeCurrentExecutionGates(result); + + if (batch46ResultHandoffAttempted(result)) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch46ResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff must stop before callback, dispatch result execution, status publication, readiness publication, result-handoff publication, and platform loader APIs"); + result.summary = batch46ResultHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_or_platform_api_attempted"); + return result; + } + + if (batch46ResultHandoffRuntimeActionRequested(result)) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch46ResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff must not request wallet runtime behavior"); + result.summary = batch46ResultHandoffBlockedSummary("runtime_action_requested"); + return result; + } + + if (result.platform.empty()) { + result.status = LiteBridgeRuntimeStatus::Unavailable; + addBatch46ResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff requires a target platform"); + result.summary = batch46ResultHandoffBlockedSummary("platform_missing"); + return result; + } + + if (isMacosPlatform(result.platform)) { + result.macosDeferred = true; + result.status = LiteBridgeRuntimeStatus::Unavailable; + addBatch46ResultHandoffIssue( + result, + input.macosDeferredByOperator + ? "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff is deferred by operator request" + : "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff requires a reviewed builder before promotion"); + result.summary = batch46ResultHandoffBlockedSummary("macos_deferred"); + return result; + } + + const bool linuxPlatform = isLinuxPlatform(result.platform); + const bool windowsPlatform = isWindowsPlatform(result.platform); + if (!linuxPlatform && !windowsPlatform) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch46ResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff supports only Linux and Windows in batch 46"); + result.summary = batch46ResultHandoffBlockedSummary("unsupported_platform"); + return result; + } + result.platformAccepted = true; + result.linuxPlatformAccepted = linuxPlatform; + result.windowsPlatformAccepted = windowsPlatform; + + if (!input.publicationGuardAccepted || !publicationGuard.ok || + !publicationGuard.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardReady || + publicationGuard.status != LiteBridgeRuntimeStatus::Ready || publicationGuard.platform != result.platform || + !publicationGuard.statusHandoffAccepted || !publicationGuard.publicationGuardRecordAccepted || + !publicationGuard.publicationGuardStatusHandoffMatchAccepted || !publicationGuard.disabledPublicationGuardAccepted || + !publicationGuard.callbackInvocationRefused || !publicationGuard.dispatchConsumptionStillGuarded || + !publicationGuard.dispatchResultExecutionBlocked || !publicationGuard.dispatchStatusPublicationBlocked || + !publicationGuard.readinessProjectionPublicationBlocked || !publicationGuard.statusHandoffPublicationBlocked || + !publicationGuard.publicationGuardPublicationBlocked || + !publicationGuard.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked || + !publicationGuard.platformApiPreInvocationBlocked || !publicationGuard.disabledPublicationGuardStateAccepted || + !publicationGuard.publicationGuardFailureMappingAccepted || !publicationGuard.unloadExecutionBlocked || + !publicationGuard.symbolResolutionBlocked || !publicationGuard.productionLoaderDisabled || + !publicationGuard.realAdapterExecutionDisabled || !publicationGuard.loadOnlyExecutionDisabled || + !publicationGuard.separateExecutionBatchRequired || !publicationGuard.noRuntimePlatformDynamicLibraryLoaded || + !publicationGuard.noRuntimePlatformDynamicLibraryUnloaded || !publicationGuard.noRuntimePlatformSymbolResolution || + !publicationGuard.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch46ResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff requires matching ready disabled publication-guard evidence"); + result.summary = batch46ResultHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_required"); + return result; + } + + static_cast(result) = publicationGuard; + result.ok = false; + result.status = LiteBridgeRuntimeStatus::Configured; + result.issues.clear(); + result.error.clear(); + result.summary.clear(); + result.platformAccepted = true; + result.linuxPlatformAccepted = linuxPlatform; + result.windowsPlatformAccepted = windowsPlatform; + result.macosDeferred = false; + result.publicationGuardAccepted = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName; + setBatch46ResultHandoffAttemptEvidence(input, result); + resetGeneratedLiteRuntimeCurrentExecutionGates(result); + + if (!input.resultHandoffReviewed || !input.resultHandoffRecorded || !input.resultHandoffDisabled || + input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId.empty() || + input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch46ResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff requires a reviewed disabled result-handoff record"); + result.summary = batch46ResultHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_required"); + return result; + } + result.resultHandoffRecordAccepted = true; + + if (!input.resultHandoffMatchesPublicationGuardEvidence || result.adapterName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch46ResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff requires result-handoff-to-publication-guard match evidence"); + result.summary = batch46ResultHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_match_required"); + return result; + } + result.resultHandoffPublicationGuardMatchAccepted = true; + + if (!input.disabledResultHandoffRegistered || !input.resultHandoffAcceptsPublicationGuardEvidence || + !input.resultHandoffReturnsDisabledResult || !input.resultHandoffBlocksDispatchConsumption || + !input.resultHandoffBlocksDispatchResultExecution || !input.resultHandoffBlocksStatusPublication || + !input.resultHandoffBlocksReadinessPublication || !input.resultHandoffBlocksStatusHandoffPublication || + !input.resultHandoffBlocksPublicationGuardPublication || !input.resultHandoffBlocksPublicationGuardResultHandoffPublication || + !input.resultHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch46ResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff requires disabled result-handoff evidence"); + result.summary = batch46ResultHandoffBlockedSummary( + "disabled_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_required"); + return result; + } + result.disabledResultHandoffAccepted = true; + + if (!input.callbackInvocationStillDisabled || !input.callbackInvocationRefused || !input.callbackInvocationRefusalReviewed || + !input.resultHandoffStopsBeforeCallbackInvocation || !input.resultHandoffStopsBeforeCallbackResultExecution || + !input.resultHandoffStopsBeforeDispatchConsumption || !input.resultHandoffStopsBeforeDispatchResultExecution || + !input.resultHandoffStopsBeforeDispatchStatusPublication || !input.resultHandoffStopsBeforeReadinessPublication || + !input.resultHandoffStopsBeforeStatusHandoffPublication || !input.resultHandoffStopsBeforePublicationGuardPublication || + !input.resultHandoffStopsBeforePublicationGuardResultHandoffPublication || + !input.resultHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication || + !input.resultHandoffStopsBeforePlatformApi || !input.resultHandoffRequiresSeparateExecutionBatch) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch46ResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff must remain disabled before callback, dispatch result execution, status publication, readiness publication, result handoff, and platform APIs"); + result.summary = batch46ResultHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_disabled_state_required"); + return result; + } + result.callbackInvocationRefused = true; + result.dispatchConsumptionStillGuarded = true; + result.dispatchResultExecutionBlocked = true; + result.dispatchStatusPublicationBlocked = true; + result.readinessProjectionPublicationBlocked = true; + result.statusHandoffPublicationBlocked = true; + result.publicationGuardPublicationBlocked = true; + result.publicationGuardResultHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationBlocked = true; + result.platformApiPreInvocationBlocked = true; + + if (!input.resultHandoffProducesNoDynamicHandle || !input.resultHandoffStoresNoDynamicHandle || + !input.resultHandoffReleasesNoDynamicHandle || !input.resultHandoffResolvesNoSymbols || + !input.resultHandoffStoresNoSymbolTable || !input.resultHandoffCreatesNoRuntime) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch46ResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff must not create runtime loader state"); + result.summary = batch46ResultHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_runtime_state_required"); + return result; + } + result.disabledResultHandoffStateAccepted = true; + + if (!input.resultHandoffFailureMappingReviewed) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch46ResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff requires disabled result-handoff failure mapping review"); + result.summary = batch46ResultHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_failure_mapping_required"); + return result; + } + result.resultHandoffFailureMappingAccepted = true; + + if (!input.unloadExecutionStillDisabled || !input.symbolResolutionStillDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch46ResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff must keep unload and symbol resolution disabled"); + result.summary = batch46ResultHandoffBlockedSummary("non_load_execution_enabled"); + return result; + } + result.unloadExecutionBlocked = true; + result.symbolResolutionBlocked = true; + + if (!input.productionLoaderExecutionDisabled || !input.realAdapterExecutionDisabled || !input.loadOnlyExecutionDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch46ResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff must keep real loader execution disabled"); + result.summary = batch46ResultHandoffBlockedSummary("production_loader_enabled"); + return result; + } + result.productionLoaderDisabled = true; + result.realAdapterExecutionDisabled = true; + result.loadOnlyExecutionDisabled = true; + + if (!input.separateExecutionBatchRequired) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch46ResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff requires a separate execution batch"); + result.summary = batch46ResultHandoffBlockedSummary("separate_execution_batch_required"); + return result; + } + result.separateExecutionBatchRequired = true; + + result.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReady = true; + result.status = LiteBridgeRuntimeStatus::Ready; + result.ok = true; + result.summary = std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff=ready; platform=") + + result.platform + "; scope=load-only-disabled-callback-refusal-propagation-consumer-readiness-dispatch-consumption-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff; execution=disabled"; + return result; +} + +using LiteBridgeRuntimeBatch47ReadinessProjectionInput = LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionInput; +using LiteBridgeRuntimeBatch47ReadinessProjectionResult = LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionResult; + +static std::string batch47ReadinessProjectionBlockedSummary(const std::string& reason) +{ + return std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection=blocked; reason=") + reason; +} + +static void addBatch47ReadinessProjectionIssue(LiteBridgeRuntimeBatch47ReadinessProjectionResult& result, + const std::string& message) +{ + result.issues.push_back(message); + if (result.error.empty()) result.error = message; +} + +static void setBatch47ReadinessProjectionAttemptEvidence(const LiteBridgeRuntimeBatch47ReadinessProjectionInput& input, + LiteBridgeRuntimeBatch47ReadinessProjectionResult& result) +{ + result.noCallbackInvocationAttempted = !input.callbackInvocationAttempted; + result.noCallbackResultExecutionAttempted = !input.callbackResultExecutionAttempted; + result.noDispatchHandoffExecutionAttempted = !input.dispatchHandoffExecutionAttempted; + result.noDispatchStatusPublicationAttempted = !input.dispatchStatusPublicationAttempted; + result.noDispatchConsumerConsumptionAttempted = !input.dispatchConsumerConsumptionAttempted; + result.noDispatchResultExecutionAttempted = !input.dispatchResultExecutionAttempted; + result.noResultHandoffStatusPublicationAttempted = !input.resultHandoffStatusPublicationAttempted; + result.noReadinessProjectionStatusPublicationAttempted = !input.readinessProjectionStatusPublicationAttempted; + result.noStatusHandoffPublicationAttempted = !input.statusHandoffPublicationAttempted; + result.noPublicationGuardPublicationAttempted = !input.publicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noRuntimePlatformDynamicLibraryLoaded = !input.runtimePlatformLoadAttempted; + result.noRuntimePlatformDynamicLibraryUnloaded = !input.runtimePlatformUnloadAttempted; + result.noRuntimePlatformSymbolResolution = !input.runtimePlatformSymbolResolutionAttempted; + result.noSdxlCalls = !input.sdxlCallRequested; + result.noBridgeCalls = !input.bridgeCallRequested; + result.noServerConnectivityChecked = !input.serverConnectivityCheckRequested; + result.noWalletLifecycle = !input.walletLifecycleRequested; + result.noSyncStarted = !input.syncRequested; + result.noSyncStatusPolled = !input.syncStatusPollingRequested; + result.noWorkerQueueEnqueue = !input.workerQueueRequested; + result.noWalletStateMutation = !input.walletStateMutationRequested; + result.noWalletPersistence = !input.walletPersistenceRequested; + result.noSettingsPersistence = !input.settingsWriteRequested; + result.noSendImportExportExecution = !input.sendImportExportRequested; + result.noArtifactMutation = !input.artifactMutationRequested; +} + +static bool batch47ReadinessProjectionAttempted(const LiteBridgeRuntimeBatch47ReadinessProjectionResult& result) +{ + return !result.noCallbackInvocationAttempted || !result.noCallbackResultExecutionAttempted || + !result.noDispatchHandoffExecutionAttempted || !result.noDispatchStatusPublicationAttempted || + !result.noDispatchConsumerConsumptionAttempted || !result.noDispatchResultExecutionAttempted || + !result.noResultHandoffStatusPublicationAttempted || !result.noReadinessProjectionStatusPublicationAttempted || + !result.noStatusHandoffPublicationAttempted || !result.noPublicationGuardPublicationAttempted || + !result.noPublicationGuardResultHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !result.noRuntimePlatformDynamicLibraryLoaded || !result.noRuntimePlatformDynamicLibraryUnloaded || + !result.noRuntimePlatformSymbolResolution; +} + +static bool batch47ReadinessProjectionRuntimeActionRequested(const LiteBridgeRuntimeBatch47ReadinessProjectionResult& result) +{ + return !result.noSdxlCalls || !result.noBridgeCalls || !result.noServerConnectivityChecked || + !result.noWalletLifecycle || !result.noSyncStarted || !result.noSyncStatusPolled || + !result.noWorkerQueueEnqueue || !result.noWalletStateMutation || !result.noWalletPersistence || + !result.noSettingsPersistence || !result.noSendImportExportExecution || !result.noArtifactMutation; +} + +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionInput& input) +{ + LiteBridgeRuntimeBatch47ReadinessProjectionResult result; + result.status = LiteBridgeRuntimeStatus::Configured; + const auto& resultHandoff = input.resultHandoff; + result.platform = normalizedPlatform(input.platform.empty() ? resultHandoff.platform : input.platform); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName; + setBatch47ReadinessProjectionAttemptEvidence(input, result); + resetGeneratedLiteRuntimeCurrentExecutionGates(result); + + if (batch47ReadinessProjectionAttempted(result)) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch47ReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection must stop before callback, dispatch result execution, status publication, readiness publication, result-handoff readiness projection publication, and platform loader APIs"); + result.summary = batch47ReadinessProjectionBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_or_platform_api_attempted"); + return result; + } + + if (batch47ReadinessProjectionRuntimeActionRequested(result)) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch47ReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection must not request wallet runtime behavior"); + result.summary = batch47ReadinessProjectionBlockedSummary("runtime_action_requested"); + return result; + } + + if (result.platform.empty()) { + result.status = LiteBridgeRuntimeStatus::Unavailable; + addBatch47ReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection requires a target platform"); + result.summary = batch47ReadinessProjectionBlockedSummary("platform_missing"); + return result; + } + + if (isMacosPlatform(result.platform)) { + result.macosDeferred = true; + result.status = LiteBridgeRuntimeStatus::Unavailable; + addBatch47ReadinessProjectionIssue( + result, + input.macosDeferredByOperator + ? "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection is deferred by operator request" + : "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection requires a reviewed builder before promotion"); + result.summary = batch47ReadinessProjectionBlockedSummary("macos_deferred"); + return result; + } + + const bool linuxPlatform = isLinuxPlatform(result.platform); + const bool windowsPlatform = isWindowsPlatform(result.platform); + if (!linuxPlatform && !windowsPlatform) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch47ReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection supports only Linux and Windows in batch 47"); + result.summary = batch47ReadinessProjectionBlockedSummary("unsupported_platform"); + return result; + } + result.platformAccepted = true; + result.linuxPlatformAccepted = linuxPlatform; + result.windowsPlatformAccepted = windowsPlatform; + + if (!input.resultHandoffAccepted || !resultHandoff.ok || + !resultHandoff.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReady || + resultHandoff.status != LiteBridgeRuntimeStatus::Ready || resultHandoff.platform != result.platform || + !resultHandoff.publicationGuardAccepted || !resultHandoff.resultHandoffRecordAccepted || + !resultHandoff.resultHandoffPublicationGuardMatchAccepted || !resultHandoff.disabledResultHandoffAccepted || + !resultHandoff.callbackInvocationRefused || !resultHandoff.dispatchConsumptionStillGuarded || + !resultHandoff.dispatchResultExecutionBlocked || !resultHandoff.dispatchStatusPublicationBlocked || + !resultHandoff.readinessProjectionPublicationBlocked || !resultHandoff.statusHandoffPublicationBlocked || + !resultHandoff.publicationGuardPublicationBlocked || !resultHandoff.publicationGuardResultHandoffPublicationBlocked || + !resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationBlocked || + !resultHandoff.platformApiPreInvocationBlocked || !resultHandoff.disabledResultHandoffStateAccepted || + !resultHandoff.resultHandoffFailureMappingAccepted || !resultHandoff.unloadExecutionBlocked || + !resultHandoff.symbolResolutionBlocked || !resultHandoff.productionLoaderDisabled || + !resultHandoff.realAdapterExecutionDisabled || !resultHandoff.loadOnlyExecutionDisabled || + !resultHandoff.separateExecutionBatchRequired || !resultHandoff.noRuntimePlatformDynamicLibraryLoaded || + !resultHandoff.noRuntimePlatformDynamicLibraryUnloaded || !resultHandoff.noRuntimePlatformSymbolResolution || + !resultHandoff.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch47ReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection requires matching ready disabled result-handoff evidence"); + result.summary = batch47ReadinessProjectionBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_required"); + return result; + } + + static_cast(result) = resultHandoff; + result.ok = false; + result.status = LiteBridgeRuntimeStatus::Configured; + result.issues.clear(); + result.error.clear(); + result.summary.clear(); + result.platformAccepted = true; + result.linuxPlatformAccepted = linuxPlatform; + result.windowsPlatformAccepted = windowsPlatform; + result.macosDeferred = false; + result.resultHandoffAccepted = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName; + setBatch47ReadinessProjectionAttemptEvidence(input, result); + resetGeneratedLiteRuntimeCurrentExecutionGates(result); + + if (!input.readinessProjectionReviewed || !input.readinessProjectionRecorded || !input.readinessProjectionDisabled || + input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId.empty() || + input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch47ReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection requires a reviewed disabled readiness-projection record"); + result.summary = batch47ReadinessProjectionBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_required"); + return result; + } + result.readinessProjectionRecordAccepted = true; + + if (!input.readinessProjectionMatchesResultHandoffEvidence || result.adapterName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch47ReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection requires readiness-projection-to-result-handoff match evidence"); + result.summary = batch47ReadinessProjectionBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_match_required"); + return result; + } + result.readinessProjectionResultHandoffMatchAccepted = true; + + if (!input.disabledReadinessProjectionRegistered || !input.readinessProjectionAcceptsResultHandoffEvidence || + !input.readinessProjectionReturnsDisabledReadiness || !input.readinessProjectionBlocksDispatchConsumption || + !input.readinessProjectionBlocksDispatchResultExecution || !input.readinessProjectionBlocksStatusPublication || + !input.readinessProjectionBlocksReadinessPublication || !input.readinessProjectionBlocksStatusHandoffPublication || + !input.readinessProjectionBlocksPublicationGuardPublication || !input.readinessProjectionBlocksPublicationGuardResultHandoffPublication || + !input.readinessProjectionBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication || + !input.readinessProjectionBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch47ReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection requires disabled readiness-projection evidence"); + result.summary = batch47ReadinessProjectionBlockedSummary( + "disabled_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_required"); + return result; + } + result.disabledReadinessProjectionAccepted = true; + + if (!input.callbackInvocationStillDisabled || !input.callbackInvocationRefused || !input.callbackInvocationRefusalReviewed || + !input.readinessProjectionStopsBeforeCallbackInvocation || !input.readinessProjectionStopsBeforeCallbackResultExecution || + !input.readinessProjectionStopsBeforeDispatchConsumption || !input.readinessProjectionStopsBeforeDispatchResultExecution || + !input.readinessProjectionStopsBeforeDispatchStatusPublication || !input.readinessProjectionStopsBeforeReadinessPublication || + !input.readinessProjectionStopsBeforeStatusHandoffPublication || !input.readinessProjectionStopsBeforePublicationGuardPublication || + !input.readinessProjectionStopsBeforePublicationGuardResultHandoffPublication || + !input.readinessProjectionStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication || + !input.readinessProjectionStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication || + !input.readinessProjectionStopsBeforePlatformApi || !input.readinessProjectionRequiresSeparateExecutionBatch) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch47ReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection must remain disabled before callback, dispatch result execution, status publication, readiness publication, result projection, and platform APIs"); + result.summary = batch47ReadinessProjectionBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_disabled_state_required"); + return result; + } + result.callbackInvocationRefused = true; + result.dispatchConsumptionStillGuarded = true; + result.dispatchResultExecutionBlocked = true; + result.dispatchStatusPublicationBlocked = true; + result.readinessProjectionPublicationBlocked = true; + result.statusHandoffPublicationBlocked = true; + result.publicationGuardPublicationBlocked = true; + result.publicationGuardResultHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationBlocked = true; + result.platformApiPreInvocationBlocked = true; + + if (!input.readinessProjectionProducesNoDynamicHandle || !input.readinessProjectionStoresNoDynamicHandle || + !input.readinessProjectionReleasesNoDynamicHandle || !input.readinessProjectionResolvesNoSymbols || + !input.readinessProjectionStoresNoSymbolTable || !input.readinessProjectionCreatesNoRuntime) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch47ReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection must not create runtime loader state"); + result.summary = batch47ReadinessProjectionBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_runtime_state_required"); + return result; + } + result.disabledReadinessProjectionStateAccepted = true; + + if (!input.readinessProjectionFailureMappingReviewed) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch47ReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection requires disabled readiness-projection failure mapping review"); + result.summary = batch47ReadinessProjectionBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_failure_mapping_required"); + return result; + } + result.readinessProjectionFailureMappingAccepted = true; + + if (!input.unloadExecutionStillDisabled || !input.symbolResolutionStillDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch47ReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection must keep unload and symbol resolution disabled"); + result.summary = batch47ReadinessProjectionBlockedSummary("non_load_execution_enabled"); + return result; + } + result.unloadExecutionBlocked = true; + result.symbolResolutionBlocked = true; + + if (!input.productionLoaderExecutionDisabled || !input.realAdapterExecutionDisabled || !input.loadOnlyExecutionDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch47ReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection must keep real loader execution disabled"); + result.summary = batch47ReadinessProjectionBlockedSummary("production_loader_enabled"); + return result; + } + result.productionLoaderDisabled = true; + result.realAdapterExecutionDisabled = true; + result.loadOnlyExecutionDisabled = true; + + if (!input.separateExecutionBatchRequired) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch47ReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection requires a separate execution batch"); + result.summary = batch47ReadinessProjectionBlockedSummary("separate_execution_batch_required"); + return result; + } + result.separateExecutionBatchRequired = true; + + result.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionReady = true; + result.status = LiteBridgeRuntimeStatus::Ready; + result.ok = true; + result.summary = std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection=ready; platform=") + + result.platform + "; scope=load-only-disabled-callback-refusal-propagation-consumer-readiness-dispatch-consumption-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection; execution=disabled"; + return result; +} + +using LiteBridgeRuntimeBatch48StatusHandoffInput = LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffInput; +using LiteBridgeRuntimeBatch48StatusHandoffResult = LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffResult; + +static std::string batch48StatusHandoffBlockedSummary(const std::string& reason) +{ + return std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff=blocked; reason=") + reason; +} + +static void addBatch48StatusHandoffIssue(LiteBridgeRuntimeBatch48StatusHandoffResult& result, + const std::string& message) +{ + result.issues.push_back(message); + if (result.error.empty()) result.error = message; +} + +static void setBatch48StatusHandoffAttemptEvidence(const LiteBridgeRuntimeBatch48StatusHandoffInput& input, + LiteBridgeRuntimeBatch48StatusHandoffResult& result) +{ + result.noCallbackInvocationAttempted = !input.callbackInvocationAttempted; + result.noCallbackResultExecutionAttempted = !input.callbackResultExecutionAttempted; + result.noDispatchHandoffExecutionAttempted = !input.dispatchHandoffExecutionAttempted; + result.noDispatchStatusPublicationAttempted = !input.dispatchStatusPublicationAttempted; + result.noDispatchConsumerConsumptionAttempted = !input.dispatchConsumerConsumptionAttempted; + result.noDispatchResultExecutionAttempted = !input.dispatchResultExecutionAttempted; + result.noResultHandoffStatusPublicationAttempted = !input.resultHandoffStatusPublicationAttempted; + result.noReadinessProjectionStatusPublicationAttempted = !input.readinessProjectionStatusPublicationAttempted; + result.noStatusHandoffPublicationAttempted = !input.statusHandoffPublicationAttempted; + result.noPublicationGuardPublicationAttempted = !input.publicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noRuntimePlatformDynamicLibraryLoaded = !input.runtimePlatformLoadAttempted; + result.noRuntimePlatformDynamicLibraryUnloaded = !input.runtimePlatformUnloadAttempted; + result.noRuntimePlatformSymbolResolution = !input.runtimePlatformSymbolResolutionAttempted; + result.noSdxlCalls = !input.sdxlCallRequested; + result.noBridgeCalls = !input.bridgeCallRequested; + result.noServerConnectivityChecked = !input.serverConnectivityCheckRequested; + result.noWalletLifecycle = !input.walletLifecycleRequested; + result.noSyncStarted = !input.syncRequested; + result.noSyncStatusPolled = !input.syncStatusPollingRequested; + result.noWorkerQueueEnqueue = !input.workerQueueRequested; + result.noWalletStateMutation = !input.walletStateMutationRequested; + result.noWalletPersistence = !input.walletPersistenceRequested; + result.noSettingsPersistence = !input.settingsWriteRequested; + result.noSendImportExportExecution = !input.sendImportExportRequested; + result.noArtifactMutation = !input.artifactMutationRequested; +} + +static bool batch48StatusHandoffAttempted(const LiteBridgeRuntimeBatch48StatusHandoffResult& result) +{ + return !result.noCallbackInvocationAttempted || !result.noCallbackResultExecutionAttempted || + !result.noDispatchHandoffExecutionAttempted || !result.noDispatchStatusPublicationAttempted || + !result.noDispatchConsumerConsumptionAttempted || !result.noDispatchResultExecutionAttempted || + !result.noResultHandoffStatusPublicationAttempted || !result.noReadinessProjectionStatusPublicationAttempted || + !result.noStatusHandoffPublicationAttempted || !result.noPublicationGuardPublicationAttempted || + !result.noPublicationGuardResultHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !result.noRuntimePlatformDynamicLibraryLoaded || !result.noRuntimePlatformDynamicLibraryUnloaded || + !result.noRuntimePlatformSymbolResolution; +} + +static bool batch48StatusHandoffRuntimeActionRequested(const LiteBridgeRuntimeBatch48StatusHandoffResult& result) +{ + return !result.noSdxlCalls || !result.noBridgeCalls || !result.noServerConnectivityChecked || + !result.noWalletLifecycle || !result.noSyncStarted || !result.noSyncStatusPolled || + !result.noWorkerQueueEnqueue || !result.noWalletStateMutation || !result.noWalletPersistence || + !result.noSettingsPersistence || !result.noSendImportExportExecution || !result.noArtifactMutation; +} + +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffInput& input) +{ + LiteBridgeRuntimeBatch48StatusHandoffResult result; + result.status = LiteBridgeRuntimeStatus::Configured; + const auto& readinessProjection = input.readinessProjection; + result.platform = normalizedPlatform(input.platform.empty() ? readinessProjection.platform : input.platform); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName; + setBatch48StatusHandoffAttemptEvidence(input, result); + resetGeneratedLiteRuntimeCurrentExecutionGates(result); + + if (batch48StatusHandoffAttempted(result)) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch48StatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff must stop before callback, dispatch result execution, status publication, readiness publication, status-handoff publication, and platform loader APIs"); + result.summary = batch48StatusHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_or_platform_api_attempted"); + return result; + } + + if (batch48StatusHandoffRuntimeActionRequested(result)) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch48StatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff must not request wallet runtime behavior"); + result.summary = batch48StatusHandoffBlockedSummary("runtime_action_requested"); + return result; + } + + if (result.platform.empty()) { + result.status = LiteBridgeRuntimeStatus::Unavailable; + addBatch48StatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff requires a target platform"); + result.summary = batch48StatusHandoffBlockedSummary("platform_missing"); + return result; + } + + if (isMacosPlatform(result.platform)) { + result.macosDeferred = true; + result.status = LiteBridgeRuntimeStatus::Unavailable; + addBatch48StatusHandoffIssue( + result, + input.macosDeferredByOperator + ? "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff is deferred by operator request" + : "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff requires a reviewed builder before promotion"); + result.summary = batch48StatusHandoffBlockedSummary("macos_deferred"); + return result; + } + + const bool linuxPlatform = isLinuxPlatform(result.platform); + const bool windowsPlatform = isWindowsPlatform(result.platform); + if (!linuxPlatform && !windowsPlatform) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch48StatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff supports only Linux and Windows in batch 48"); + result.summary = batch48StatusHandoffBlockedSummary("unsupported_platform"); + return result; + } + result.platformAccepted = true; + result.linuxPlatformAccepted = linuxPlatform; + result.windowsPlatformAccepted = windowsPlatform; + + if (!input.readinessProjectionAccepted || !readinessProjection.ok || + !readinessProjection.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionReady || + readinessProjection.status != LiteBridgeRuntimeStatus::Ready || readinessProjection.platform != result.platform || + !readinessProjection.resultHandoffAccepted || !readinessProjection.readinessProjectionRecordAccepted || + !readinessProjection.readinessProjectionResultHandoffMatchAccepted || !readinessProjection.disabledReadinessProjectionAccepted || + !readinessProjection.callbackInvocationRefused || !readinessProjection.dispatchConsumptionStillGuarded || + !readinessProjection.dispatchResultExecutionBlocked || !readinessProjection.dispatchStatusPublicationBlocked || + !readinessProjection.readinessProjectionPublicationBlocked || !readinessProjection.statusHandoffPublicationBlocked || + !readinessProjection.publicationGuardPublicationBlocked || !readinessProjection.publicationGuardResultHandoffPublicationBlocked || + !readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationBlocked || + !readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationBlocked || + !readinessProjection.platformApiPreInvocationBlocked || !readinessProjection.disabledReadinessProjectionStateAccepted || + !readinessProjection.readinessProjectionFailureMappingAccepted || !readinessProjection.unloadExecutionBlocked || + !readinessProjection.symbolResolutionBlocked || !readinessProjection.productionLoaderDisabled || + !readinessProjection.realAdapterExecutionDisabled || !readinessProjection.loadOnlyExecutionDisabled || + !readinessProjection.separateExecutionBatchRequired || !readinessProjection.noRuntimePlatformDynamicLibraryLoaded || + !readinessProjection.noRuntimePlatformDynamicLibraryUnloaded || !readinessProjection.noRuntimePlatformSymbolResolution || + !readinessProjection.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch48StatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff requires matching ready disabled readiness-projection evidence"); + result.summary = batch48StatusHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_required"); + return result; + } + + static_cast(result) = readinessProjection; + result.ok = false; + result.status = LiteBridgeRuntimeStatus::Configured; + result.issues.clear(); + result.error.clear(); + result.summary.clear(); + result.platformAccepted = true; + result.linuxPlatformAccepted = linuxPlatform; + result.windowsPlatformAccepted = windowsPlatform; + result.macosDeferred = false; + result.readinessProjectionAccepted = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName; + setBatch48StatusHandoffAttemptEvidence(input, result); + resetGeneratedLiteRuntimeCurrentExecutionGates(result); + + if (!input.statusHandoffReviewed || !input.statusHandoffRecorded || !input.statusHandoffDisabled || + input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId.empty() || + input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch48StatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff requires a reviewed disabled status-handoff record"); + result.summary = batch48StatusHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_required"); + return result; + } + result.statusHandoffRecordAccepted = true; + + if (!input.statusHandoffMatchesReadinessProjectionEvidence || result.adapterName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch48StatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff requires status-handoff-to-readiness-projection match evidence"); + result.summary = batch48StatusHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_match_required"); + return result; + } + result.statusHandoffReadinessProjectionMatchAccepted = true; + + if (!input.disabledStatusHandoffRegistered || !input.statusHandoffAcceptsReadinessProjectionEvidence || + !input.statusHandoffReturnsDisabledStatus || !input.statusHandoffBlocksDispatchConsumption || + !input.statusHandoffBlocksDispatchResultExecution || !input.statusHandoffBlocksStatusPublication || + !input.statusHandoffBlocksReadinessPublication || !input.statusHandoffBlocksStatusHandoffPublication || + !input.statusHandoffBlocksPublicationGuardPublication || !input.statusHandoffBlocksPublicationGuardResultHandoffPublication || + !input.statusHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication || + !input.statusHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication || + !input.statusHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch48StatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff requires disabled status-handoff evidence"); + result.summary = batch48StatusHandoffBlockedSummary( + "disabled_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_required"); + return result; + } + result.disabledStatusHandoffAccepted = true; + + if (!input.callbackInvocationStillDisabled || !input.callbackInvocationRefused || !input.callbackInvocationRefusalReviewed || + !input.statusHandoffStopsBeforeCallbackInvocation || !input.statusHandoffStopsBeforeCallbackResultExecution || + !input.statusHandoffStopsBeforeDispatchConsumption || !input.statusHandoffStopsBeforeDispatchResultExecution || + !input.statusHandoffStopsBeforeDispatchStatusPublication || !input.statusHandoffStopsBeforeReadinessPublication || + !input.statusHandoffStopsBeforeStatusHandoffPublication || !input.statusHandoffStopsBeforePublicationGuardPublication || + !input.statusHandoffStopsBeforePublicationGuardResultHandoffPublication || + !input.statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication || + !input.statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication || + !input.statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication || + !input.statusHandoffStopsBeforePlatformApi || !input.statusHandoffRequiresSeparateExecutionBatch) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch48StatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff must remain disabled before callback, dispatch result execution, status publication, readiness publication, status handoff, and platform APIs"); + result.summary = batch48StatusHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_disabled_state_required"); + return result; + } + result.callbackInvocationRefused = true; + result.dispatchConsumptionStillGuarded = true; + result.dispatchResultExecutionBlocked = true; + result.dispatchStatusPublicationBlocked = true; + result.readinessProjectionPublicationBlocked = true; + result.statusHandoffPublicationBlocked = true; + result.publicationGuardPublicationBlocked = true; + result.publicationGuardResultHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked = true; + result.platformApiPreInvocationBlocked = true; + + if (!input.statusHandoffProducesNoDynamicHandle || !input.statusHandoffStoresNoDynamicHandle || + !input.statusHandoffReleasesNoDynamicHandle || !input.statusHandoffResolvesNoSymbols || + !input.statusHandoffStoresNoSymbolTable || !input.statusHandoffCreatesNoRuntime) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch48StatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff must not create runtime loader state"); + result.summary = batch48StatusHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_runtime_state_required"); + return result; + } + result.disabledStatusHandoffStateAccepted = true; + + if (!input.statusHandoffFailureMappingReviewed) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch48StatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff requires disabled status-handoff failure mapping review"); + result.summary = batch48StatusHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_failure_mapping_required"); + return result; + } + result.statusHandoffFailureMappingAccepted = true; + + if (!input.unloadExecutionStillDisabled || !input.symbolResolutionStillDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch48StatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff must keep unload and symbol resolution disabled"); + result.summary = batch48StatusHandoffBlockedSummary("non_load_execution_enabled"); + return result; + } + result.unloadExecutionBlocked = true; + result.symbolResolutionBlocked = true; + + if (!input.productionLoaderExecutionDisabled || !input.realAdapterExecutionDisabled || !input.loadOnlyExecutionDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch48StatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff must keep real loader execution disabled"); + result.summary = batch48StatusHandoffBlockedSummary("production_loader_enabled"); + return result; + } + result.productionLoaderDisabled = true; + result.realAdapterExecutionDisabled = true; + result.loadOnlyExecutionDisabled = true; + + if (!input.separateExecutionBatchRequired) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch48StatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff requires a separate execution batch"); + result.summary = batch48StatusHandoffBlockedSummary("separate_execution_batch_required"); + return result; + } + result.separateExecutionBatchRequired = true; + + result.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffReady = true; + result.status = LiteBridgeRuntimeStatus::Ready; + result.ok = true; + result.summary = std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff=ready; platform=") + + result.platform + "; scope=load-only-disabled-callback-refusal-propagation-consumer-readiness-dispatch-consumption-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff; execution=disabled"; + return result; +} + +using LiteBridgeRuntimeBatch49PublicationGuardInput = LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardInput; +using LiteBridgeRuntimeBatch49PublicationGuardResult = LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResult; + +static std::string batch49PublicationGuardBlockedSummary(const std::string& reason) +{ + return std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard=blocked; reason=") + reason; +} + +static void addBatch49PublicationGuardIssue(LiteBridgeRuntimeBatch49PublicationGuardResult& result, + const std::string& message) +{ + result.issues.push_back(message); + if (result.error.empty()) result.error = message; +} + +static void setBatch49PublicationGuardAttemptEvidence(const LiteBridgeRuntimeBatch49PublicationGuardInput& input, + LiteBridgeRuntimeBatch49PublicationGuardResult& result) +{ + result.noCallbackInvocationAttempted = !input.callbackInvocationAttempted; + result.noCallbackResultExecutionAttempted = !input.callbackResultExecutionAttempted; + result.noDispatchHandoffExecutionAttempted = !input.dispatchHandoffExecutionAttempted; + result.noDispatchStatusPublicationAttempted = !input.dispatchStatusPublicationAttempted; + result.noDispatchConsumerConsumptionAttempted = !input.dispatchConsumerConsumptionAttempted; + result.noDispatchResultExecutionAttempted = !input.dispatchResultExecutionAttempted; + result.noResultHandoffStatusPublicationAttempted = !input.resultHandoffStatusPublicationAttempted; + result.noReadinessProjectionStatusPublicationAttempted = !input.readinessProjectionStatusPublicationAttempted; + result.noStatusHandoffPublicationAttempted = !input.statusHandoffPublicationAttempted; + result.noPublicationGuardPublicationAttempted = !input.publicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted; + result.noRuntimePlatformDynamicLibraryLoaded = !input.runtimePlatformLoadAttempted; + result.noRuntimePlatformDynamicLibraryUnloaded = !input.runtimePlatformUnloadAttempted; + result.noRuntimePlatformSymbolResolution = !input.runtimePlatformSymbolResolutionAttempted; + result.noSdxlCalls = !input.sdxlCallRequested; + result.noBridgeCalls = !input.bridgeCallRequested; + result.noServerConnectivityChecked = !input.serverConnectivityCheckRequested; + result.noWalletLifecycle = !input.walletLifecycleRequested; + result.noSyncStarted = !input.syncRequested; + result.noSyncStatusPolled = !input.syncStatusPollingRequested; + result.noWorkerQueueEnqueue = !input.workerQueueRequested; + result.noWalletStateMutation = !input.walletStateMutationRequested; + result.noWalletPersistence = !input.walletPersistenceRequested; + result.noSettingsPersistence = !input.settingsWriteRequested; + result.noSendImportExportExecution = !input.sendImportExportRequested; + result.noArtifactMutation = !input.artifactMutationRequested; +} + +static bool batch49PublicationGuardAttempted(const LiteBridgeRuntimeBatch49PublicationGuardResult& result) +{ + return !result.noCallbackInvocationAttempted || !result.noCallbackResultExecutionAttempted || + !result.noDispatchHandoffExecutionAttempted || !result.noDispatchStatusPublicationAttempted || + !result.noDispatchConsumerConsumptionAttempted || !result.noDispatchResultExecutionAttempted || + !result.noResultHandoffStatusPublicationAttempted || !result.noReadinessProjectionStatusPublicationAttempted || + !result.noStatusHandoffPublicationAttempted || !result.noPublicationGuardPublicationAttempted || + !result.noPublicationGuardResultHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted || + !result.noRuntimePlatformDynamicLibraryLoaded || !result.noRuntimePlatformDynamicLibraryUnloaded || + !result.noRuntimePlatformSymbolResolution; +} + +static bool batch49PublicationGuardRuntimeActionRequested(const LiteBridgeRuntimeBatch49PublicationGuardResult& result) +{ + return !result.noSdxlCalls || !result.noBridgeCalls || !result.noServerConnectivityChecked || + !result.noWalletLifecycle || !result.noSyncStarted || !result.noSyncStatusPolled || + !result.noWorkerQueueEnqueue || !result.noWalletStateMutation || !result.noWalletPersistence || + !result.noSettingsPersistence || !result.noSendImportExportExecution || !result.noArtifactMutation; +} + +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardInput& input) +{ + LiteBridgeRuntimeBatch49PublicationGuardResult result; + result.status = LiteBridgeRuntimeStatus::Configured; + const auto& statusHandoff = input.statusHandoff; + result.platform = normalizedPlatform(input.platform.empty() ? statusHandoff.platform : input.platform); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName; + setBatch49PublicationGuardAttemptEvidence(input, result); + resetGeneratedLiteRuntimeCurrentExecutionGates(result); + + if (batch49PublicationGuardAttempted(result)) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch49PublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard must stop before callback, dispatch result execution, status publication, readiness publication, publication guard publication, and platform loader APIs"); + result.summary = batch49PublicationGuardBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_or_platform_api_attempted"); + return result; + } + + if (batch49PublicationGuardRuntimeActionRequested(result)) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch49PublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard must not request wallet runtime behavior"); + result.summary = batch49PublicationGuardBlockedSummary("runtime_action_requested"); + return result; + } + + if (result.platform.empty()) { + result.status = LiteBridgeRuntimeStatus::Unavailable; + addBatch49PublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard requires a target platform"); + result.summary = batch49PublicationGuardBlockedSummary("platform_missing"); + return result; + } + + if (isMacosPlatform(result.platform)) { + result.macosDeferred = true; + result.status = LiteBridgeRuntimeStatus::Unavailable; + addBatch49PublicationGuardIssue( + result, + input.macosDeferredByOperator + ? "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard is deferred by operator request" + : "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard requires a reviewed builder before promotion"); + result.summary = batch49PublicationGuardBlockedSummary("macos_deferred"); + return result; + } + + const bool linuxPlatform = isLinuxPlatform(result.platform); + const bool windowsPlatform = isWindowsPlatform(result.platform); + if (!linuxPlatform && !windowsPlatform) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch49PublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard supports only Linux and Windows in batch 49"); + result.summary = batch49PublicationGuardBlockedSummary("unsupported_platform"); + return result; + } + result.platformAccepted = true; + result.linuxPlatformAccepted = linuxPlatform; + result.windowsPlatformAccepted = windowsPlatform; + + if (!input.statusHandoffAccepted || !statusHandoff.ok || + !statusHandoff.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffReady || + statusHandoff.status != LiteBridgeRuntimeStatus::Ready || statusHandoff.platform != result.platform || + !statusHandoff.readinessProjectionAccepted || !statusHandoff.statusHandoffRecordAccepted || + !statusHandoff.statusHandoffReadinessProjectionMatchAccepted || !statusHandoff.disabledStatusHandoffAccepted || + !statusHandoff.callbackInvocationRefused || !statusHandoff.dispatchConsumptionStillGuarded || + !statusHandoff.dispatchResultExecutionBlocked || !statusHandoff.dispatchStatusPublicationBlocked || + !statusHandoff.readinessProjectionPublicationBlocked || !statusHandoff.statusHandoffPublicationBlocked || + !statusHandoff.publicationGuardPublicationBlocked || !statusHandoff.publicationGuardResultHandoffPublicationBlocked || + !statusHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationBlocked || + !statusHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked || + !statusHandoff.platformApiPreInvocationBlocked || !statusHandoff.disabledStatusHandoffStateAccepted || + !statusHandoff.statusHandoffFailureMappingAccepted || !statusHandoff.unloadExecutionBlocked || + !statusHandoff.symbolResolutionBlocked || !statusHandoff.productionLoaderDisabled || + !statusHandoff.realAdapterExecutionDisabled || !statusHandoff.loadOnlyExecutionDisabled || + !statusHandoff.separateExecutionBatchRequired || !statusHandoff.noRuntimePlatformDynamicLibraryLoaded || + !statusHandoff.noRuntimePlatformDynamicLibraryUnloaded || !statusHandoff.noRuntimePlatformSymbolResolution || + !statusHandoff.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch49PublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard requires matching ready disabled status-handoff evidence"); + result.summary = batch49PublicationGuardBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_required"); + return result; + } + + static_cast(result) = statusHandoff; + result.ok = false; + result.status = LiteBridgeRuntimeStatus::Configured; + result.issues.clear(); + result.error.clear(); + result.summary.clear(); + result.platformAccepted = true; + result.linuxPlatformAccepted = linuxPlatform; + result.windowsPlatformAccepted = windowsPlatform; + result.macosDeferred = false; + result.statusHandoffAccepted = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName; + setBatch49PublicationGuardAttemptEvidence(input, result); + resetGeneratedLiteRuntimeCurrentExecutionGates(result); + + if (!input.publicationGuardReviewed || !input.publicationGuardRecorded || !input.publicationGuardDisabled || + input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId.empty() || + input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch49PublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard requires a reviewed disabled publication-guard record"); + result.summary = batch49PublicationGuardBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_required"); + return result; + } + result.publicationGuardRecordAccepted = true; + + if (!input.publicationGuardMatchesStatusHandoffEvidence || result.adapterName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch49PublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard requires publication-guard-to-status-handoff match evidence"); + result.summary = batch49PublicationGuardBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_match_required"); + return result; + } + result.publicationGuardStatusHandoffMatchAccepted = true; + + if (!input.disabledPublicationGuardRegistered || !input.publicationGuardAcceptsStatusHandoffEvidence || + !input.publicationGuardReturnsDisabledPublication || !input.publicationGuardBlocksDispatchConsumption || + !input.publicationGuardBlocksDispatchResultExecution || !input.publicationGuardBlocksStatusPublication || + !input.publicationGuardBlocksReadinessPublication || !input.publicationGuardBlocksStatusHandoffPublication || + !input.publicationGuardBlocksPublicationGuardPublication || !input.publicationGuardBlocksPublicationGuardResultHandoffPublication || + !input.publicationGuardBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication || + !input.publicationGuardBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication || + !input.publicationGuardBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication || + !input.publicationGuardBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch49PublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard requires disabled publication-guard evidence"); + result.summary = batch49PublicationGuardBlockedSummary( + "disabled_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_required"); + return result; + } + result.disabledPublicationGuardAccepted = true; + + if (!input.callbackInvocationStillDisabled || !input.callbackInvocationRefused || !input.callbackInvocationRefusalReviewed || + !input.publicationGuardStopsBeforeCallbackInvocation || !input.publicationGuardStopsBeforeCallbackResultExecution || + !input.publicationGuardStopsBeforeDispatchConsumption || !input.publicationGuardStopsBeforeDispatchResultExecution || + !input.publicationGuardStopsBeforeDispatchStatusPublication || !input.publicationGuardStopsBeforeReadinessPublication || + !input.publicationGuardStopsBeforeStatusHandoffPublication || !input.publicationGuardStopsBeforePublicationGuardPublication || + !input.publicationGuardStopsBeforePublicationGuardResultHandoffPublication || + !input.publicationGuardStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication || + !input.publicationGuardStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication || + !input.publicationGuardStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication || + !input.publicationGuardStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication || + !input.publicationGuardStopsBeforePlatformApi || !input.publicationGuardRequiresSeparateExecutionBatch) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch49PublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard must remain disabled before callback, dispatch result execution, status publication, readiness publication, publication, and platform APIs"); + result.summary = batch49PublicationGuardBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_disabled_state_required"); + return result; + } + result.callbackInvocationRefused = true; + result.dispatchConsumptionStillGuarded = true; + result.dispatchResultExecutionBlocked = true; + result.dispatchStatusPublicationBlocked = true; + result.readinessProjectionPublicationBlocked = true; + result.statusHandoffPublicationBlocked = true; + result.publicationGuardPublicationBlocked = true; + result.publicationGuardResultHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked = true; + result.platformApiPreInvocationBlocked = true; + + if (!input.publicationGuardProducesNoDynamicHandle || !input.publicationGuardStoresNoDynamicHandle || + !input.publicationGuardReleasesNoDynamicHandle || !input.publicationGuardResolvesNoSymbols || + !input.publicationGuardStoresNoSymbolTable || !input.publicationGuardCreatesNoRuntime) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch49PublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard must not create runtime loader state"); + result.summary = batch49PublicationGuardBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_runtime_state_required"); + return result; + } + result.disabledPublicationGuardStateAccepted = true; + + if (!input.publicationGuardFailureMappingReviewed) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch49PublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard requires disabled publication-guard failure mapping review"); + result.summary = batch49PublicationGuardBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_failure_mapping_required"); + return result; + } + result.publicationGuardFailureMappingAccepted = true; + + if (!input.unloadExecutionStillDisabled || !input.symbolResolutionStillDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch49PublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard must keep unload and symbol resolution disabled"); + result.summary = batch49PublicationGuardBlockedSummary("non_load_execution_enabled"); + return result; + } + result.unloadExecutionBlocked = true; + result.symbolResolutionBlocked = true; + + if (!input.productionLoaderExecutionDisabled || !input.realAdapterExecutionDisabled || !input.loadOnlyExecutionDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch49PublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard must keep real loader execution disabled"); + result.summary = batch49PublicationGuardBlockedSummary("production_loader_enabled"); + return result; + } + result.productionLoaderDisabled = true; + result.realAdapterExecutionDisabled = true; + result.loadOnlyExecutionDisabled = true; + + if (!input.separateExecutionBatchRequired) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch49PublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard requires a separate execution batch"); + result.summary = batch49PublicationGuardBlockedSummary("separate_execution_batch_required"); + return result; + } + result.separateExecutionBatchRequired = true; + + result.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardReady = true; + result.status = LiteBridgeRuntimeStatus::Ready; + result.ok = true; + result.summary = std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard=ready; platform=") + + result.platform + "; scope=load-only-disabled-callback-refusal-propagation-consumer-readiness-dispatch-consumption-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard; execution=disabled"; + return result; +} + +using LiteBridgeRuntimeBatch50ResultHandoffInput = LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffInput; +using LiteBridgeRuntimeBatch50ResultHandoffResult = LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffResult; + +static std::string batch50ResultHandoffBlockedSummary(const std::string& reason) +{ + return std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff=blocked; reason=") + reason; +} + +static void addBatch50ResultHandoffIssue(LiteBridgeRuntimeBatch50ResultHandoffResult& result, + const std::string& message) +{ + result.issues.push_back(message); + if (result.error.empty()) result.error = message; +} + +static void setBatch50ResultHandoffAttemptEvidence(const LiteBridgeRuntimeBatch50ResultHandoffInput& input, + LiteBridgeRuntimeBatch50ResultHandoffResult& result) +{ + result.noCallbackInvocationAttempted = !input.callbackInvocationAttempted; + result.noCallbackResultExecutionAttempted = !input.callbackResultExecutionAttempted; + result.noDispatchHandoffExecutionAttempted = !input.dispatchHandoffExecutionAttempted; + result.noDispatchStatusPublicationAttempted = !input.dispatchStatusPublicationAttempted; + result.noDispatchConsumerConsumptionAttempted = !input.dispatchConsumerConsumptionAttempted; + result.noDispatchResultExecutionAttempted = !input.dispatchResultExecutionAttempted; + result.noResultHandoffStatusPublicationAttempted = !input.resultHandoffStatusPublicationAttempted; + result.noReadinessProjectionStatusPublicationAttempted = !input.readinessProjectionStatusPublicationAttempted; + result.noStatusHandoffPublicationAttempted = !input.statusHandoffPublicationAttempted; + result.noPublicationGuardPublicationAttempted = !input.publicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted; + if (input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted) { + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = false; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = false; + } + result.noRuntimePlatformDynamicLibraryLoaded = !input.runtimePlatformLoadAttempted; + result.noRuntimePlatformDynamicLibraryUnloaded = !input.runtimePlatformUnloadAttempted; + result.noRuntimePlatformSymbolResolution = !input.runtimePlatformSymbolResolutionAttempted; + result.noSdxlCalls = !input.sdxlCallRequested; + result.noBridgeCalls = !input.bridgeCallRequested; + result.noServerConnectivityChecked = !input.serverConnectivityCheckRequested; + result.noWalletLifecycle = !input.walletLifecycleRequested; + result.noSyncStarted = !input.syncRequested; + result.noSyncStatusPolled = !input.syncStatusPollingRequested; + result.noWorkerQueueEnqueue = !input.workerQueueRequested; + result.noWalletStateMutation = !input.walletStateMutationRequested; + result.noWalletPersistence = !input.walletPersistenceRequested; + result.noSettingsPersistence = !input.settingsWriteRequested; + result.noSendImportExportExecution = !input.sendImportExportRequested; + result.noArtifactMutation = !input.artifactMutationRequested; +} + +static bool batch50ResultHandoffAttempted(const LiteBridgeRuntimeBatch50ResultHandoffResult& result) +{ + return batch49PublicationGuardAttempted(result) || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted; +} + +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffInput& input) +{ + LiteBridgeRuntimeBatch50ResultHandoffResult result; + result.status = LiteBridgeRuntimeStatus::Configured; + const auto& publicationGuard = input.publicationGuard; + result.platform = normalizedPlatform(input.platform.empty() ? publicationGuard.platform : input.platform); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName; + setBatch50ResultHandoffAttemptEvidence(input, result); + resetGeneratedLiteRuntimeCurrentExecutionGates(result); + + if (batch50ResultHandoffAttempted(result)) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch50ResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff must stop before callback, dispatch result execution, status publication, readiness publication, result-handoff publication, and platform loader APIs"); + result.summary = batch50ResultHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_or_platform_api_attempted"); + return result; + } + + if (batch49PublicationGuardRuntimeActionRequested(result)) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch50ResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff must not request wallet runtime behavior"); + result.summary = batch50ResultHandoffBlockedSummary("runtime_action_requested"); + return result; + } + + if (result.platform.empty()) { + result.status = LiteBridgeRuntimeStatus::Unavailable; + addBatch50ResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff requires a target platform"); + result.summary = batch50ResultHandoffBlockedSummary("platform_missing"); + return result; + } + + if (isMacosPlatform(result.platform)) { + result.macosDeferred = true; + result.status = LiteBridgeRuntimeStatus::Unavailable; + addBatch50ResultHandoffIssue( + result, + input.macosDeferredByOperator + ? "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff is deferred by operator request" + : "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff requires a reviewed builder before promotion"); + result.summary = batch50ResultHandoffBlockedSummary("macos_deferred"); + return result; + } + + const bool linuxPlatform = isLinuxPlatform(result.platform); + const bool windowsPlatform = isWindowsPlatform(result.platform); + if (!linuxPlatform && !windowsPlatform) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch50ResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff supports only Linux and Windows in batch 50"); + result.summary = batch50ResultHandoffBlockedSummary("unsupported_platform"); + return result; + } + result.platformAccepted = true; + result.linuxPlatformAccepted = linuxPlatform; + result.windowsPlatformAccepted = windowsPlatform; + + if (!input.publicationGuardAccepted || !publicationGuard.ok || + !publicationGuard.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardReady || + publicationGuard.status != LiteBridgeRuntimeStatus::Ready || publicationGuard.platform != result.platform || + !publicationGuard.statusHandoffAccepted || !publicationGuard.publicationGuardRecordAccepted || + !publicationGuard.publicationGuardStatusHandoffMatchAccepted || !publicationGuard.disabledPublicationGuardAccepted || + !publicationGuard.callbackInvocationRefused || !publicationGuard.dispatchConsumptionStillGuarded || + !publicationGuard.dispatchResultExecutionBlocked || !publicationGuard.dispatchStatusPublicationBlocked || + !publicationGuard.readinessProjectionPublicationBlocked || !publicationGuard.statusHandoffPublicationBlocked || + !publicationGuard.publicationGuardPublicationBlocked || !publicationGuard.publicationGuardResultHandoffPublicationBlocked || + !publicationGuard.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked || + !publicationGuard.platformApiPreInvocationBlocked || !publicationGuard.disabledPublicationGuardStateAccepted || + !publicationGuard.publicationGuardFailureMappingAccepted || !publicationGuard.unloadExecutionBlocked || + !publicationGuard.symbolResolutionBlocked || !publicationGuard.productionLoaderDisabled || + !publicationGuard.realAdapterExecutionDisabled || !publicationGuard.loadOnlyExecutionDisabled || + !publicationGuard.separateExecutionBatchRequired || !publicationGuard.noRuntimePlatformDynamicLibraryLoaded || + !publicationGuard.noRuntimePlatformDynamicLibraryUnloaded || !publicationGuard.noRuntimePlatformSymbolResolution || + !publicationGuard.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch50ResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff requires matching ready disabled publication-guard evidence"); + result.summary = batch50ResultHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_required"); + return result; + } + + static_cast(result) = publicationGuard; + result.ok = false; + result.status = LiteBridgeRuntimeStatus::Configured; + result.issues.clear(); + result.error.clear(); + result.summary.clear(); + result.platformAccepted = true; + result.linuxPlatformAccepted = linuxPlatform; + result.windowsPlatformAccepted = windowsPlatform; + result.macosDeferred = false; + result.publicationGuardAccepted = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName; + setBatch50ResultHandoffAttemptEvidence(input, result); + resetGeneratedLiteRuntimeCurrentExecutionGates(result); + + if (!input.resultHandoffReviewed || !input.resultHandoffRecorded || !input.resultHandoffDisabled || + input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId.empty() || + input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch50ResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff requires a reviewed disabled result-handoff record"); + result.summary = batch50ResultHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_required"); + return result; + } + result.resultHandoffRecordAccepted = true; + + if (!input.resultHandoffMatchesPublicationGuardEvidence || result.adapterName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch50ResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff requires result-handoff-to-publication-guard match evidence"); + result.summary = batch50ResultHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_match_required"); + return result; + } + result.resultHandoffPublicationGuardMatchAccepted = true; + + if (!input.disabledResultHandoffRegistered || !input.resultHandoffAcceptsPublicationGuardEvidence || + !input.resultHandoffReturnsDisabledResult || + !input.resultHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch50ResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff requires disabled result-handoff evidence"); + result.summary = batch50ResultHandoffBlockedSummary( + "disabled_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_required"); + return result; + } + result.disabledResultHandoffAccepted = true; + + if (!input.callbackInvocationStillDisabled || !input.callbackInvocationRefused || !input.callbackInvocationRefusalReviewed || + !input.resultHandoffStopsBeforeCallbackInvocation || !input.resultHandoffStopsBeforeCallbackResultExecution || + !input.resultHandoffStopsBeforeDispatchConsumption || !input.resultHandoffStopsBeforeDispatchResultExecution || + !input.resultHandoffStopsBeforeDispatchStatusPublication || !input.resultHandoffStopsBeforeReadinessPublication || + !input.resultHandoffStopsBeforeStatusHandoffPublication || !input.resultHandoffStopsBeforePublicationGuardPublication || + !input.resultHandoffStopsBeforePublicationGuardResultHandoffPublication || + !input.resultHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication || + !input.resultHandoffStopsBeforePlatformApi || !input.resultHandoffRequiresSeparateExecutionBatch) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch50ResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff must remain disabled before callback, dispatch result execution, status publication, readiness publication, result publication, and platform APIs"); + result.summary = batch50ResultHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_disabled_state_required"); + return result; + } + result.callbackInvocationRefused = true; + result.dispatchConsumptionStillGuarded = true; + result.dispatchResultExecutionBlocked = true; + result.dispatchStatusPublicationBlocked = true; + result.readinessProjectionPublicationBlocked = true; + result.statusHandoffPublicationBlocked = true; + result.publicationGuardPublicationBlocked = true; + result.publicationGuardResultHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationBlocked = true; + result.platformApiPreInvocationBlocked = true; + + if (!input.resultHandoffProducesNoDynamicHandle || !input.resultHandoffStoresNoDynamicHandle || + !input.resultHandoffReleasesNoDynamicHandle || !input.resultHandoffResolvesNoSymbols || + !input.resultHandoffStoresNoSymbolTable || !input.resultHandoffCreatesNoRuntime) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch50ResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff must not create runtime loader state"); + result.summary = batch50ResultHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_runtime_state_required"); + return result; + } + result.disabledResultHandoffStateAccepted = true; + + if (!input.resultHandoffFailureMappingReviewed) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch50ResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff requires disabled result-handoff failure mapping review"); + result.summary = batch50ResultHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_failure_mapping_required"); + return result; + } + result.resultHandoffFailureMappingAccepted = true; + + if (!input.unloadExecutionStillDisabled || !input.symbolResolutionStillDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch50ResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff must keep unload and symbol resolution disabled"); + result.summary = batch50ResultHandoffBlockedSummary("non_load_execution_enabled"); + return result; + } + result.unloadExecutionBlocked = true; + result.symbolResolutionBlocked = true; + + if (!input.productionLoaderExecutionDisabled || !input.realAdapterExecutionDisabled || !input.loadOnlyExecutionDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch50ResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff must keep real loader execution disabled"); + result.summary = batch50ResultHandoffBlockedSummary("production_loader_enabled"); + return result; + } + result.productionLoaderDisabled = true; + result.realAdapterExecutionDisabled = true; + result.loadOnlyExecutionDisabled = true; + + if (!input.separateExecutionBatchRequired) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch50ResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff requires a separate execution batch"); + result.summary = batch50ResultHandoffBlockedSummary("separate_execution_batch_required"); + return result; + } + result.separateExecutionBatchRequired = true; + + result.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReady = true; + result.status = LiteBridgeRuntimeStatus::Ready; + result.ok = true; + result.summary = std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff=ready; platform=") + + result.platform + "; scope=load-only-disabled-callback-refusal-propagation-consumer-readiness-dispatch-consumption-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff; execution=disabled"; + return result; +} + +using LiteBridgeRuntimeBatch51ReadinessProjectionInput = LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionInput; +using LiteBridgeRuntimeBatch51ReadinessProjectionResult = LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionResult; + +static std::string batch51ReadinessProjectionBlockedSummary(const std::string& reason) +{ + return std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection=blocked; reason=") + reason; +} + +static void addBatch51ReadinessProjectionIssue(LiteBridgeRuntimeBatch51ReadinessProjectionResult& result, + const std::string& message) +{ + result.issues.push_back(message); + if (result.error.empty()) result.error = message; +} + +static void setBatch51ReadinessProjectionAttemptEvidence(const LiteBridgeRuntimeBatch51ReadinessProjectionInput& input, + LiteBridgeRuntimeBatch51ReadinessProjectionResult& result) +{ + result.noCallbackInvocationAttempted = !input.callbackInvocationAttempted; + result.noCallbackResultExecutionAttempted = !input.callbackResultExecutionAttempted; + result.noDispatchHandoffExecutionAttempted = !input.dispatchHandoffExecutionAttempted; + result.noDispatchStatusPublicationAttempted = !input.dispatchStatusPublicationAttempted; + result.noDispatchConsumerConsumptionAttempted = !input.dispatchConsumerConsumptionAttempted; + result.noDispatchResultExecutionAttempted = !input.dispatchResultExecutionAttempted; + result.noResultHandoffStatusPublicationAttempted = !input.resultHandoffStatusPublicationAttempted; + result.noReadinessProjectionStatusPublicationAttempted = !input.readinessProjectionStatusPublicationAttempted; + result.noStatusHandoffPublicationAttempted = !input.statusHandoffPublicationAttempted; + result.noPublicationGuardPublicationAttempted = !input.publicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted; + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted; + result.noRuntimePlatformDynamicLibraryLoaded = !input.runtimePlatformLoadAttempted; + result.noRuntimePlatformDynamicLibraryUnloaded = !input.runtimePlatformUnloadAttempted; + result.noRuntimePlatformSymbolResolution = !input.runtimePlatformSymbolResolutionAttempted; + result.noSdxlCalls = !input.sdxlCallRequested; + result.noBridgeCalls = !input.bridgeCallRequested; + result.noServerConnectivityChecked = !input.serverConnectivityCheckRequested; + result.noWalletLifecycle = !input.walletLifecycleRequested; + result.noSyncStarted = !input.syncRequested; + result.noSyncStatusPolled = !input.syncStatusPollingRequested; + result.noWorkerQueueEnqueue = !input.workerQueueRequested; + result.noWalletStateMutation = !input.walletStateMutationRequested; + result.noWalletPersistence = !input.walletPersistenceRequested; + result.noSettingsPersistence = !input.settingsWriteRequested; + result.noSendImportExportExecution = !input.sendImportExportRequested; + result.noArtifactMutation = !input.artifactMutationRequested; +} + +static bool batch51ReadinessProjectionAttempted(const LiteBridgeRuntimeBatch51ReadinessProjectionResult& result) +{ + return batch50ResultHandoffAttempted(result) || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted; +} + +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionInput& input) +{ + LiteBridgeRuntimeBatch51ReadinessProjectionResult result; + result.status = LiteBridgeRuntimeStatus::Configured; + const auto& resultHandoff = input.resultHandoff; + result.platform = normalizedPlatform(input.platform.empty() ? resultHandoff.platform : input.platform); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName; + setBatch51ReadinessProjectionAttemptEvidence(input, result); + resetGeneratedLiteRuntimeCurrentExecutionGates(result); + + if (batch51ReadinessProjectionAttempted(result)) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch51ReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection must stop before callback, dispatch result execution, status publication, readiness publication, result-handoff readiness projection publication, and platform loader APIs"); + result.summary = batch51ReadinessProjectionBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_or_platform_api_attempted"); + return result; + } + + if (batch49PublicationGuardRuntimeActionRequested(result)) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch51ReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection must not request wallet runtime behavior"); + result.summary = batch51ReadinessProjectionBlockedSummary("runtime_action_requested"); + return result; + } + + if (result.platform.empty()) { + result.status = LiteBridgeRuntimeStatus::Unavailable; + addBatch51ReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection requires a target platform"); + result.summary = batch51ReadinessProjectionBlockedSummary("platform_missing"); + return result; + } + + if (isMacosPlatform(result.platform)) { + result.macosDeferred = true; + result.status = LiteBridgeRuntimeStatus::Unavailable; + addBatch51ReadinessProjectionIssue( + result, + input.macosDeferredByOperator + ? "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection is deferred by operator request" + : "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection requires a reviewed builder before promotion"); + result.summary = batch51ReadinessProjectionBlockedSummary("macos_deferred"); + return result; + } + + const bool linuxPlatform = isLinuxPlatform(result.platform); + const bool windowsPlatform = isWindowsPlatform(result.platform); + if (!linuxPlatform && !windowsPlatform) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch51ReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection supports only Linux and Windows in batch 51"); + result.summary = batch51ReadinessProjectionBlockedSummary("unsupported_platform"); + return result; + } + result.platformAccepted = true; + result.linuxPlatformAccepted = linuxPlatform; + result.windowsPlatformAccepted = windowsPlatform; + + if (!input.resultHandoffAccepted || !resultHandoff.ok || + !resultHandoff.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReady || + resultHandoff.status != LiteBridgeRuntimeStatus::Ready || resultHandoff.platform != result.platform || + !resultHandoff.publicationGuardAccepted || !resultHandoff.resultHandoffRecordAccepted || + !resultHandoff.resultHandoffPublicationGuardMatchAccepted || !resultHandoff.disabledResultHandoffAccepted || + !resultHandoff.callbackInvocationRefused || !resultHandoff.dispatchConsumptionStillGuarded || + !resultHandoff.dispatchResultExecutionBlocked || !resultHandoff.dispatchStatusPublicationBlocked || + !resultHandoff.readinessProjectionPublicationBlocked || !resultHandoff.statusHandoffPublicationBlocked || + !resultHandoff.publicationGuardPublicationBlocked || !resultHandoff.publicationGuardResultHandoffPublicationBlocked || + !resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked || + !resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationBlocked || + !resultHandoff.platformApiPreInvocationBlocked || !resultHandoff.disabledResultHandoffStateAccepted || + !resultHandoff.resultHandoffFailureMappingAccepted || !resultHandoff.unloadExecutionBlocked || + !resultHandoff.symbolResolutionBlocked || !resultHandoff.productionLoaderDisabled || + !resultHandoff.realAdapterExecutionDisabled || !resultHandoff.loadOnlyExecutionDisabled || + !resultHandoff.separateExecutionBatchRequired || !resultHandoff.noRuntimePlatformDynamicLibraryLoaded || + !resultHandoff.noRuntimePlatformDynamicLibraryUnloaded || !resultHandoff.noRuntimePlatformSymbolResolution || + !resultHandoff.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch51ReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection requires matching ready disabled result-handoff evidence"); + result.summary = batch51ReadinessProjectionBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_required"); + return result; + } + + static_cast(result) = resultHandoff; + result.ok = false; + result.status = LiteBridgeRuntimeStatus::Configured; + result.issues.clear(); + result.error.clear(); + result.summary.clear(); + result.platformAccepted = true; + result.linuxPlatformAccepted = linuxPlatform; + result.windowsPlatformAccepted = windowsPlatform; + result.macosDeferred = false; + result.resultHandoffAccepted = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName; + setBatch51ReadinessProjectionAttemptEvidence(input, result); + resetGeneratedLiteRuntimeCurrentExecutionGates(result); + + if (!input.readinessProjectionReviewed || !input.readinessProjectionRecorded || !input.readinessProjectionDisabled || + input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId.empty() || + input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch51ReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection requires a reviewed disabled readiness-projection record"); + result.summary = batch51ReadinessProjectionBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_required"); + return result; + } + result.readinessProjectionRecordAccepted = true; + + if (!input.readinessProjectionMatchesResultHandoffEvidence || result.adapterName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch51ReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection requires readiness-projection-to-result-handoff match evidence"); + result.summary = batch51ReadinessProjectionBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_match_required"); + return result; + } + result.readinessProjectionResultHandoffMatchAccepted = true; + + if (!input.disabledReadinessProjectionRegistered || !input.readinessProjectionAcceptsResultHandoffEvidence || + !input.readinessProjectionReturnsDisabledReadiness || + !input.readinessProjectionBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication || + !input.readinessProjectionBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch51ReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection requires disabled readiness-projection evidence"); + result.summary = batch51ReadinessProjectionBlockedSummary( + "disabled_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_required"); + return result; + } + result.disabledReadinessProjectionAccepted = true; + + if (!input.callbackInvocationStillDisabled || !input.callbackInvocationRefused || !input.callbackInvocationRefusalReviewed || + !input.readinessProjectionStopsBeforeCallbackInvocation || !input.readinessProjectionStopsBeforeCallbackResultExecution || + !input.readinessProjectionStopsBeforeDispatchConsumption || !input.readinessProjectionStopsBeforeDispatchResultExecution || + !input.readinessProjectionStopsBeforeDispatchStatusPublication || !input.readinessProjectionStopsBeforeReadinessPublication || + !input.readinessProjectionStopsBeforeStatusHandoffPublication || !input.readinessProjectionStopsBeforePublicationGuardPublication || + !input.readinessProjectionStopsBeforePublicationGuardResultHandoffPublication || + !input.readinessProjectionStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication || + !input.readinessProjectionStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication || + !input.readinessProjectionStopsBeforePlatformApi || !input.readinessProjectionRequiresSeparateExecutionBatch) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch51ReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection must remain disabled before callback, dispatch result execution, status publication, readiness publication, result projection, and platform APIs"); + result.summary = batch51ReadinessProjectionBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_disabled_state_required"); + return result; + } + result.callbackInvocationRefused = true; + result.dispatchConsumptionStillGuarded = true; + result.dispatchResultExecutionBlocked = true; + result.dispatchStatusPublicationBlocked = true; + result.readinessProjectionPublicationBlocked = true; + result.statusHandoffPublicationBlocked = true; + result.publicationGuardPublicationBlocked = true; + result.publicationGuardResultHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationBlocked = true; + result.platformApiPreInvocationBlocked = true; + + if (!input.readinessProjectionProducesNoDynamicHandle || !input.readinessProjectionStoresNoDynamicHandle || + !input.readinessProjectionReleasesNoDynamicHandle || !input.readinessProjectionResolvesNoSymbols || + !input.readinessProjectionStoresNoSymbolTable || !input.readinessProjectionCreatesNoRuntime) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch51ReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection must not create runtime loader state"); + result.summary = batch51ReadinessProjectionBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_runtime_state_required"); + return result; + } + result.disabledReadinessProjectionStateAccepted = true; + + if (!input.readinessProjectionFailureMappingReviewed) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch51ReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection requires disabled readiness-projection failure mapping review"); + result.summary = batch51ReadinessProjectionBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_failure_mapping_required"); + return result; + } + result.readinessProjectionFailureMappingAccepted = true; + + if (!input.unloadExecutionStillDisabled || !input.symbolResolutionStillDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch51ReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection must keep unload and symbol resolution disabled"); + result.summary = batch51ReadinessProjectionBlockedSummary("non_load_execution_enabled"); + return result; + } + result.unloadExecutionBlocked = true; + result.symbolResolutionBlocked = true; + + if (!input.productionLoaderExecutionDisabled || !input.realAdapterExecutionDisabled || !input.loadOnlyExecutionDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch51ReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection must keep real loader execution disabled"); + result.summary = batch51ReadinessProjectionBlockedSummary("production_loader_enabled"); + return result; + } + result.productionLoaderDisabled = true; + result.realAdapterExecutionDisabled = true; + result.loadOnlyExecutionDisabled = true; + + if (!input.separateExecutionBatchRequired) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch51ReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection requires a separate execution batch"); + result.summary = batch51ReadinessProjectionBlockedSummary("separate_execution_batch_required"); + return result; + } + result.separateExecutionBatchRequired = true; + + result.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionReady = true; + result.status = LiteBridgeRuntimeStatus::Ready; + result.ok = true; + result.summary = std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection=ready; platform=") + + result.platform + "; scope=load-only-disabled-callback-refusal-propagation-consumer-readiness-dispatch-consumption-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection; execution=disabled"; + return result; +} + +using LiteBridgeRuntimeBatch52StatusHandoffInput = LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffInput; +using LiteBridgeRuntimeBatch52StatusHandoffResult = LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffResult; + +static std::string batch52StatusHandoffBlockedSummary(const std::string& reason) +{ + return std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff=blocked; reason=") + reason; +} + +static void addBatch52StatusHandoffIssue(LiteBridgeRuntimeBatch52StatusHandoffResult& result, + const std::string& message) +{ + result.issues.push_back(message); + if (result.error.empty()) result.error = message; +} + +static void setBatch52StatusHandoffAttemptEvidence(const LiteBridgeRuntimeBatch52StatusHandoffInput& input, + LiteBridgeRuntimeBatch52StatusHandoffResult& result) +{ + setBatch51ReadinessProjectionAttemptEvidence(input, result); + resetGeneratedLiteRuntimeCurrentExecutionGates(result); + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; +} + +static bool batch52StatusHandoffAttempted(const LiteBridgeRuntimeBatch52StatusHandoffResult& result) +{ + return batch51ReadinessProjectionAttempted(result) || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; +} + +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffInput& input) +{ + LiteBridgeRuntimeBatch52StatusHandoffResult result; + result.status = LiteBridgeRuntimeStatus::Configured; + const auto& readinessProjection = input.readinessProjection; + result.platform = normalizedPlatform(input.platform.empty() ? readinessProjection.platform : input.platform); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName; + setBatch52StatusHandoffAttemptEvidence(input, result); + resetGeneratedLiteRuntimeCurrentExecutionGates(result); + + if (batch52StatusHandoffAttempted(result)) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch52StatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff must stop before callback, dispatch result execution, status publication, readiness publication, status-handoff publication, and platform loader APIs"); + result.summary = batch52StatusHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_or_platform_api_attempted"); + return result; + } + + if (batch49PublicationGuardRuntimeActionRequested(result)) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch52StatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff publication guard result handoff readiness projection status handoff must not request wallet runtime behavior"); + result.summary = batch52StatusHandoffBlockedSummary("runtime_action_requested"); + return result; + } + + if (result.platform.empty()) { + result.status = LiteBridgeRuntimeStatus::Unavailable; + addBatch52StatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff requires a target platform"); + result.summary = batch52StatusHandoffBlockedSummary("platform_missing"); + return result; + } + + if (isMacosPlatform(result.platform)) { + result.macosDeferred = true; + result.status = LiteBridgeRuntimeStatus::Unavailable; + addBatch52StatusHandoffIssue( + result, + input.macosDeferredByOperator + ? "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff is deferred by operator request" + : "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff requires a reviewed builder before promotion"); + result.summary = batch52StatusHandoffBlockedSummary("macos_deferred"); + return result; + } + + const bool linuxPlatform = isLinuxPlatform(result.platform); + const bool windowsPlatform = isWindowsPlatform(result.platform); + if (!linuxPlatform && !windowsPlatform) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch52StatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff supports only Linux and Windows in batch 52"); + result.summary = batch52StatusHandoffBlockedSummary("unsupported_platform"); + return result; + } + result.platformAccepted = true; + result.linuxPlatformAccepted = linuxPlatform; + result.windowsPlatformAccepted = windowsPlatform; + + if (!input.readinessProjectionAccepted || !readinessProjection.ok || + !readinessProjection.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionReady || + readinessProjection.status != LiteBridgeRuntimeStatus::Ready || readinessProjection.platform != result.platform || + !readinessProjection.resultHandoffAccepted || !readinessProjection.readinessProjectionRecordAccepted || + !readinessProjection.readinessProjectionResultHandoffMatchAccepted || !readinessProjection.disabledReadinessProjectionAccepted || + !readinessProjection.callbackInvocationRefused || !readinessProjection.dispatchConsumptionStillGuarded || + !readinessProjection.dispatchResultExecutionBlocked || !readinessProjection.dispatchStatusPublicationBlocked || + !readinessProjection.readinessProjectionPublicationBlocked || !readinessProjection.statusHandoffPublicationBlocked || + !readinessProjection.publicationGuardPublicationBlocked || !readinessProjection.publicationGuardResultHandoffPublicationBlocked || + !readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationBlocked || + !readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationBlocked || + !readinessProjection.platformApiPreInvocationBlocked || !readinessProjection.disabledReadinessProjectionStateAccepted || + !readinessProjection.readinessProjectionFailureMappingAccepted || !readinessProjection.unloadExecutionBlocked || + !readinessProjection.symbolResolutionBlocked || !readinessProjection.productionLoaderDisabled || + !readinessProjection.realAdapterExecutionDisabled || !readinessProjection.loadOnlyExecutionDisabled || + !readinessProjection.separateExecutionBatchRequired || !readinessProjection.noRuntimePlatformDynamicLibraryLoaded || + !readinessProjection.noRuntimePlatformDynamicLibraryUnloaded || !readinessProjection.noRuntimePlatformSymbolResolution || + !readinessProjection.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch52StatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff requires matching ready disabled readiness-projection evidence"); + result.summary = batch52StatusHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_required"); + return result; + } + + static_cast(result) = readinessProjection; + result.ok = false; + result.status = LiteBridgeRuntimeStatus::Configured; + result.issues.clear(); + result.error.clear(); + result.summary.clear(); + result.platformAccepted = true; + result.linuxPlatformAccepted = linuxPlatform; + result.windowsPlatformAccepted = windowsPlatform; + result.macosDeferred = false; + result.readinessProjectionAccepted = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName; + setBatch52StatusHandoffAttemptEvidence(input, result); + resetGeneratedLiteRuntimeCurrentExecutionGates(result); + + if (!input.statusHandoffReviewed || !input.statusHandoffRecorded || !input.statusHandoffDisabled || + input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId.empty() || + input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch52StatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff requires a reviewed disabled status-handoff record"); + result.summary = batch52StatusHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_required"); + return result; + } + result.statusHandoffRecordAccepted = true; + + if (!input.statusHandoffMatchesReadinessProjectionEvidence || result.adapterName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch52StatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff requires status-handoff-to-readiness-projection match evidence"); + result.summary = batch52StatusHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_match_required"); + return result; + } + result.statusHandoffReadinessProjectionMatchAccepted = true; + + if (!input.disabledStatusHandoffRegistered || !input.statusHandoffAcceptsReadinessProjectionEvidence || + !input.statusHandoffReturnsDisabledStatus || !input.statusHandoffBlocksDispatchConsumption || + !input.statusHandoffBlocksDispatchResultExecution || !input.statusHandoffBlocksStatusPublication || + !input.statusHandoffBlocksReadinessPublication || !input.statusHandoffBlocksStatusHandoffPublication || + !input.statusHandoffBlocksPublicationGuardPublication || !input.statusHandoffBlocksPublicationGuardResultHandoffPublication || + !input.statusHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch52StatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff requires disabled status-handoff evidence"); + result.summary = batch52StatusHandoffBlockedSummary( + "disabled_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_required"); + return result; + } + result.disabledStatusHandoffAccepted = true; + + if (!input.callbackInvocationStillDisabled || !input.callbackInvocationRefused || !input.callbackInvocationRefusalReviewed || + !input.statusHandoffStopsBeforeCallbackInvocation || !input.statusHandoffStopsBeforeCallbackResultExecution || + !input.statusHandoffStopsBeforeDispatchConsumption || !input.statusHandoffStopsBeforeDispatchResultExecution || + !input.statusHandoffStopsBeforeDispatchStatusPublication || !input.statusHandoffStopsBeforeReadinessPublication || + !input.statusHandoffStopsBeforeStatusHandoffPublication || !input.statusHandoffStopsBeforePublicationGuardPublication || + !input.statusHandoffStopsBeforePublicationGuardResultHandoffPublication || + !input.statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication || + !input.statusHandoffStopsBeforePlatformApi || !input.statusHandoffRequiresSeparateExecutionBatch) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch52StatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff must remain disabled before callback, dispatch result execution, status publication, readiness publication, status handoff, and platform APIs"); + result.summary = batch52StatusHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_disabled_state_required"); + return result; + } + result.callbackInvocationRefused = true; + result.dispatchConsumptionStillGuarded = true; + result.dispatchResultExecutionBlocked = true; + result.dispatchStatusPublicationBlocked = true; + result.readinessProjectionPublicationBlocked = true; + result.statusHandoffPublicationBlocked = true; + result.publicationGuardPublicationBlocked = true; + result.publicationGuardResultHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked = true; + result.platformApiPreInvocationBlocked = true; + + if (!input.statusHandoffProducesNoDynamicHandle || !input.statusHandoffStoresNoDynamicHandle || + !input.statusHandoffReleasesNoDynamicHandle || !input.statusHandoffResolvesNoSymbols || + !input.statusHandoffStoresNoSymbolTable || !input.statusHandoffCreatesNoRuntime) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch52StatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff must not create runtime loader state"); + result.summary = batch52StatusHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_runtime_state_required"); + return result; + } + result.disabledStatusHandoffStateAccepted = true; + + if (!input.statusHandoffFailureMappingReviewed) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch52StatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff requires disabled status-handoff failure mapping review"); + result.summary = batch52StatusHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_failure_mapping_required"); + return result; + } + result.statusHandoffFailureMappingAccepted = true; + + if (!input.unloadExecutionStillDisabled || !input.symbolResolutionStillDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch52StatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff must keep unload and symbol resolution disabled"); + result.summary = batch52StatusHandoffBlockedSummary("non_load_execution_enabled"); + return result; + } + result.unloadExecutionBlocked = true; + result.symbolResolutionBlocked = true; + + if (!input.productionLoaderExecutionDisabled || !input.realAdapterExecutionDisabled || !input.loadOnlyExecutionDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch52StatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff must keep real loader execution disabled"); + result.summary = batch52StatusHandoffBlockedSummary("production_loader_enabled"); + return result; + } + result.productionLoaderDisabled = true; + result.realAdapterExecutionDisabled = true; + result.loadOnlyExecutionDisabled = true; + + if (!input.separateExecutionBatchRequired) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch52StatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff requires a separate execution batch"); + result.summary = batch52StatusHandoffBlockedSummary("separate_execution_batch_required"); + return result; + } + result.separateExecutionBatchRequired = true; + + result.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffReady = true; + result.status = LiteBridgeRuntimeStatus::Ready; + result.ok = true; + result.summary = std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff=ready; platform=") + + result.platform + "; scope=load-only-disabled-callback-refusal-propagation-consumer-readiness-dispatch-consumption-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff; execution=disabled"; + return result; +} + +using LiteBridgeRuntimeBatch53PublicationGuardInput = LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardInput; +using LiteBridgeRuntimeBatch53PublicationGuardResult = LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResult; + +static std::string batch53PublicationGuardBlockedSummary(const std::string& reason) +{ + return std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard=blocked; reason=") + reason; +} + +static void addBatch53PublicationGuardIssue(LiteBridgeRuntimeBatch53PublicationGuardResult& result, + const std::string& message) +{ + result.issues.push_back(message); + if (result.error.empty()) result.error = message; +} + +static void setBatch53PublicationGuardAttemptEvidence(const LiteBridgeRuntimeBatch53PublicationGuardInput& input, + LiteBridgeRuntimeBatch53PublicationGuardResult& result) +{ + setBatch52StatusHandoffAttemptEvidence(input, result); + resetGeneratedLiteRuntimeCurrentExecutionGates(result); + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted; +} + +static bool batch53PublicationGuardAttempted(const LiteBridgeRuntimeBatch53PublicationGuardResult& result) +{ + return batch52StatusHandoffAttempted(result) || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted; +} + +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardInput& input) +{ + LiteBridgeRuntimeBatch53PublicationGuardResult result; + result.status = LiteBridgeRuntimeStatus::Configured; + const auto& statusHandoff = input.statusHandoff; + result.platform = normalizedPlatform(input.platform.empty() ? statusHandoff.platform : input.platform); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName; + setBatch53PublicationGuardAttemptEvidence(input, result); + resetGeneratedLiteRuntimeCurrentExecutionGates(result); + + if (batch53PublicationGuardAttempted(result)) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch53PublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard must stop before callback, dispatch result execution, status publication, readiness publication, publication-guard publication, and platform loader APIs"); + result.summary = batch53PublicationGuardBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_or_platform_api_attempted"); + return result; + } + + if (batch49PublicationGuardRuntimeActionRequested(result)) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch53PublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard must not request wallet runtime behavior"); + result.summary = batch53PublicationGuardBlockedSummary("runtime_action_requested"); + return result; + } + + if (result.platform.empty()) { + result.status = LiteBridgeRuntimeStatus::Unavailable; + addBatch53PublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard requires a target platform"); + result.summary = batch53PublicationGuardBlockedSummary("platform_missing"); + return result; + } + + if (isMacosPlatform(result.platform)) { + result.macosDeferred = true; + result.status = LiteBridgeRuntimeStatus::Unavailable; + addBatch53PublicationGuardIssue( + result, + input.macosDeferredByOperator + ? "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard is deferred by operator request" + : "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard requires a reviewed builder before promotion"); + result.summary = batch53PublicationGuardBlockedSummary("macos_deferred"); + return result; + } + + const bool linuxPlatform = isLinuxPlatform(result.platform); + const bool windowsPlatform = isWindowsPlatform(result.platform); + if (!linuxPlatform && !windowsPlatform) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch53PublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard supports only Linux and Windows in batch 53"); + result.summary = batch53PublicationGuardBlockedSummary("unsupported_platform"); + return result; + } + result.platformAccepted = true; + result.linuxPlatformAccepted = linuxPlatform; + result.windowsPlatformAccepted = windowsPlatform; + + if (!input.statusHandoffAccepted || !statusHandoff.ok || + !statusHandoff.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffReady || + statusHandoff.status != LiteBridgeRuntimeStatus::Ready || statusHandoff.platform != result.platform || + !statusHandoff.readinessProjectionAccepted || !statusHandoff.statusHandoffRecordAccepted || + !statusHandoff.statusHandoffReadinessProjectionMatchAccepted || !statusHandoff.disabledStatusHandoffAccepted || + !statusHandoff.callbackInvocationRefused || !statusHandoff.dispatchConsumptionStillGuarded || + !statusHandoff.dispatchResultExecutionBlocked || !statusHandoff.dispatchStatusPublicationBlocked || + !statusHandoff.readinessProjectionPublicationBlocked || !statusHandoff.statusHandoffPublicationBlocked || + !statusHandoff.publicationGuardPublicationBlocked || !statusHandoff.publicationGuardResultHandoffPublicationBlocked || + !statusHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked || + !statusHandoff.platformApiPreInvocationBlocked || !statusHandoff.disabledStatusHandoffStateAccepted || + !statusHandoff.statusHandoffFailureMappingAccepted || !statusHandoff.unloadExecutionBlocked || + !statusHandoff.symbolResolutionBlocked || !statusHandoff.productionLoaderDisabled || + !statusHandoff.realAdapterExecutionDisabled || !statusHandoff.loadOnlyExecutionDisabled || + !statusHandoff.separateExecutionBatchRequired || !statusHandoff.noRuntimePlatformDynamicLibraryLoaded || + !statusHandoff.noRuntimePlatformDynamicLibraryUnloaded || !statusHandoff.noRuntimePlatformSymbolResolution || + !statusHandoff.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch53PublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard requires matching ready disabled status-handoff evidence"); + result.summary = batch53PublicationGuardBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_required"); + return result; + } + + static_cast(result) = statusHandoff; + result.ok = false; + result.status = LiteBridgeRuntimeStatus::Configured; + result.issues.clear(); + result.error.clear(); + result.summary.clear(); + result.platformAccepted = true; + result.linuxPlatformAccepted = linuxPlatform; + result.windowsPlatformAccepted = windowsPlatform; + result.macosDeferred = false; + result.statusHandoffAccepted = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName; + setBatch53PublicationGuardAttemptEvidence(input, result); + resetGeneratedLiteRuntimeCurrentExecutionGates(result); + + if (!input.publicationGuardReviewed || !input.publicationGuardRecorded || !input.publicationGuardDisabled || + input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId.empty() || + input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch53PublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard requires a reviewed disabled publication-guard record"); + result.summary = batch53PublicationGuardBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_required"); + return result; + } + result.publicationGuardRecordAccepted = true; + + if (!input.publicationGuardMatchesStatusHandoffEvidence || result.adapterName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch53PublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard requires publication-guard-to-status-handoff match evidence"); + result.summary = batch53PublicationGuardBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_match_required"); + return result; + } + result.publicationGuardStatusHandoffMatchAccepted = true; + + if (!input.disabledPublicationGuardRegistered || !input.publicationGuardAcceptsStatusHandoffEvidence || + !input.publicationGuardReturnsDisabledPublication || !input.publicationGuardBlocksDispatchConsumption || + !input.publicationGuardBlocksDispatchResultExecution || !input.publicationGuardBlocksStatusPublication || + !input.publicationGuardBlocksReadinessPublication || !input.publicationGuardBlocksStatusHandoffPublication || + !input.publicationGuardBlocksPublicationGuardPublication || !input.publicationGuardBlocksPublicationGuardResultHandoffPublication || + !input.publicationGuardBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication || + !input.publicationGuardBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch53PublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard requires disabled publication-guard evidence"); + result.summary = batch53PublicationGuardBlockedSummary( + "disabled_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_required"); + return result; + } + result.disabledPublicationGuardAccepted = true; + + if (!input.callbackInvocationStillDisabled || !input.callbackInvocationRefused || !input.callbackInvocationRefusalReviewed || + !input.publicationGuardStopsBeforeCallbackInvocation || !input.publicationGuardStopsBeforeCallbackResultExecution || + !input.publicationGuardStopsBeforeDispatchConsumption || !input.publicationGuardStopsBeforeDispatchResultExecution || + !input.publicationGuardStopsBeforeDispatchStatusPublication || !input.publicationGuardStopsBeforeReadinessPublication || + !input.publicationGuardStopsBeforeStatusHandoffPublication || !input.publicationGuardStopsBeforePublicationGuardPublication || + !input.publicationGuardStopsBeforePublicationGuardResultHandoffPublication || + !input.publicationGuardStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication || + !input.publicationGuardStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication || + !input.publicationGuardStopsBeforePlatformApi || !input.publicationGuardRequiresSeparateExecutionBatch) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch53PublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard must remain disabled before callback, dispatch result execution, status publication, readiness publication, publication guard, and platform APIs"); + result.summary = batch53PublicationGuardBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_disabled_state_required"); + return result; + } + result.callbackInvocationRefused = true; + result.dispatchConsumptionStillGuarded = true; + result.dispatchResultExecutionBlocked = true; + result.dispatchStatusPublicationBlocked = true; + result.readinessProjectionPublicationBlocked = true; + result.statusHandoffPublicationBlocked = true; + result.publicationGuardPublicationBlocked = true; + result.publicationGuardResultHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked = true; + result.platformApiPreInvocationBlocked = true; + + if (!input.publicationGuardProducesNoDynamicHandle || !input.publicationGuardStoresNoDynamicHandle || + !input.publicationGuardReleasesNoDynamicHandle || !input.publicationGuardResolvesNoSymbols || + !input.publicationGuardStoresNoSymbolTable || !input.publicationGuardCreatesNoRuntime) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch53PublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard must not create runtime loader state"); + result.summary = batch53PublicationGuardBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_runtime_state_required"); + return result; + } + result.disabledPublicationGuardStateAccepted = true; + + if (!input.publicationGuardFailureMappingReviewed) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch53PublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard requires disabled publication-guard failure mapping review"); + result.summary = batch53PublicationGuardBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_failure_mapping_required"); + return result; + } + result.publicationGuardFailureMappingAccepted = true; + + if (!input.unloadExecutionStillDisabled || !input.symbolResolutionStillDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch53PublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard must keep unload and symbol resolution disabled"); + result.summary = batch53PublicationGuardBlockedSummary("non_load_execution_enabled"); + return result; + } + result.unloadExecutionBlocked = true; + result.symbolResolutionBlocked = true; + + if (!input.productionLoaderExecutionDisabled || !input.realAdapterExecutionDisabled || !input.loadOnlyExecutionDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch53PublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard must keep real loader execution disabled"); + result.summary = batch53PublicationGuardBlockedSummary("production_loader_enabled"); + return result; + } + result.productionLoaderDisabled = true; + result.realAdapterExecutionDisabled = true; + result.loadOnlyExecutionDisabled = true; + + if (!input.separateExecutionBatchRequired) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch53PublicationGuardIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard requires a separate execution batch"); + result.summary = batch53PublicationGuardBlockedSummary("separate_execution_batch_required"); + return result; + } + result.separateExecutionBatchRequired = true; + + result.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardReady = true; + result.status = LiteBridgeRuntimeStatus::Ready; + result.ok = true; + result.summary = std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard=ready; platform=") + + result.platform + "; scope=load-only-disabled-callback-refusal-propagation-consumer-readiness-dispatch-consumption-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard; execution=disabled"; + return result; +} + +// Unique Batch54-60 generated surfaces reuse the reviewed disabled gate templates +// while carrying the promoted evidence type chain forward. + +using LiteBridgeRuntimeBatch54ResultHandoffInput = LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffInput; +using LiteBridgeRuntimeBatch54ResultHandoffResult = LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffResult; + +static std::string batch54ResultHandoffBlockedSummary(const std::string& reason) +{ + return std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff=blocked; reason=") + reason; +} + +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffInput& input) +{ + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffResult result; + static_cast(result) = input.publicationGuard; + + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffInput legacyInput = static_cast(input); + legacyInput.publicationGuard = input.publicationGuard; + auto legacyResult = evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff(legacyInput); + static_cast(result) = input.publicationGuard; + static_cast(result) = legacyResult; + result.batch54ResultHandoffSurfaceReady = legacyResult.ok && legacyResult.status == LiteBridgeRuntimeStatus::Ready; + return result; +} + + +using LiteBridgeRuntimeBatch55ReadinessProjectionInput = LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionInput; +using LiteBridgeRuntimeBatch55ReadinessProjectionResult = LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionResult; + +static std::string batch55ReadinessProjectionBlockedSummary(const std::string& reason) +{ + return std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection=blocked; reason=") + reason; +} + +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionInput& input) +{ + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionResult result; + static_cast(result) = input.resultHandoff; + + if (result.status == LiteBridgeRuntimeStatus::Unavailable) { + return result; + } + + if (!input.resultHandoff.batch54ResultHandoffSurfaceReady) { + result.ok = false; + result.status = LiteBridgeRuntimeStatus::Failed; + result.issues.clear(); + result.error = "batch 55 requires ready batch 54 evidence before the promoted disabled readiness-projection surface"; + result.issues.push_back(result.error); + result.summary = batch55ReadinessProjectionBlockedSummary("batch_54_evidence_required"); + return result; + } + + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionInput legacyInput = static_cast(input); + legacyInput.resultHandoff = input.resultHandoff; + auto legacyResult = evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection(legacyInput); + static_cast(result) = input.resultHandoff; + static_cast(result) = legacyResult; + result.batch55ReadinessProjectionSurfaceReady = legacyResult.ok && legacyResult.status == LiteBridgeRuntimeStatus::Ready; + return result; +} + + +using LiteBridgeRuntimeBatch56StatusHandoffInput = LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffInput; +using LiteBridgeRuntimeBatch56StatusHandoffResult = LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffResult; + +static std::string batch56StatusHandoffBlockedSummary(const std::string& reason) +{ + return std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff=blocked; reason=") + reason; +} + +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffInput& input) +{ + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffResult result; + static_cast(result) = input.readinessProjection; + + if (result.status == LiteBridgeRuntimeStatus::Unavailable) { + return result; + } + + if (!input.readinessProjection.batch55ReadinessProjectionSurfaceReady) { + result.ok = false; + result.status = LiteBridgeRuntimeStatus::Failed; + result.issues.clear(); + result.error = "batch 56 requires ready batch 55 evidence before the promoted disabled status-handoff surface"; + result.issues.push_back(result.error); + result.summary = batch56StatusHandoffBlockedSummary("batch_55_evidence_required"); + return result; + } + + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffInput legacyInput = static_cast(input); + legacyInput.readinessProjection = input.readinessProjection; + auto legacyResult = evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff(legacyInput); + static_cast(result) = input.readinessProjection; + static_cast(result) = legacyResult; + result.batch56StatusHandoffSurfaceReady = legacyResult.ok && legacyResult.status == LiteBridgeRuntimeStatus::Ready; + return result; +} + + +using LiteBridgeRuntimeBatch57PublicationGuardInput = LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardInput; +using LiteBridgeRuntimeBatch57PublicationGuardResult = LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResult; + +static std::string batch57PublicationGuardBlockedSummary(const std::string& reason) +{ + return std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard=blocked; reason=") + reason; +} + +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardInput& input) +{ + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResult result; + static_cast(result) = input.statusHandoff; + + if (result.status == LiteBridgeRuntimeStatus::Unavailable) { + return result; + } + + if (!input.statusHandoff.batch56StatusHandoffSurfaceReady) { + result.ok = false; + result.status = LiteBridgeRuntimeStatus::Failed; + result.issues.clear(); + result.error = "batch 57 requires ready batch 56 evidence before the promoted disabled publication-guard surface"; + result.issues.push_back(result.error); + result.summary = batch57PublicationGuardBlockedSummary("batch_56_evidence_required"); + return result; + } + + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardInput legacyInput = static_cast(input); + legacyInput.statusHandoff = input.statusHandoff; + auto legacyResult = evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard(legacyInput); + static_cast(result) = input.statusHandoff; + static_cast(result) = legacyResult; + result.batch57PublicationGuardSurfaceReady = legacyResult.ok && legacyResult.status == LiteBridgeRuntimeStatus::Ready; + return result; +} + + +using LiteBridgeRuntimeBatch58ResultHandoffInput = LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffInput; +using LiteBridgeRuntimeBatch58ResultHandoffResult = LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffResult; + +static std::string batch58ResultHandoffBlockedSummary(const std::string& reason) +{ + return std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff=blocked; reason=") + reason; +} + +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffInput& input) +{ + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffResult result; + static_cast(result) = input.publicationGuard; + + if (result.status == LiteBridgeRuntimeStatus::Unavailable) { + return result; + } + + if (!input.publicationGuard.batch57PublicationGuardSurfaceReady) { + result.ok = false; + result.status = LiteBridgeRuntimeStatus::Failed; + result.issues.clear(); + result.error = "batch 58 requires ready batch 57 evidence before the promoted disabled result-handoff surface"; + result.issues.push_back(result.error); + result.summary = batch58ResultHandoffBlockedSummary("batch_57_evidence_required"); + return result; + } + + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffInput legacyInput = static_cast(input); + legacyInput.publicationGuard = input.publicationGuard; + auto legacyResult = evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff(legacyInput); + static_cast(result) = input.publicationGuard; + static_cast(result) = legacyResult; + result.batch58ResultHandoffSurfaceReady = legacyResult.ok && legacyResult.status == LiteBridgeRuntimeStatus::Ready; + return result; +} + + +using LiteBridgeRuntimeBatch59ReadinessProjectionInput = LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionInput; +using LiteBridgeRuntimeBatch59ReadinessProjectionResult = LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionResult; + +static std::string batch59ReadinessProjectionBlockedSummary(const std::string& reason) +{ + return std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection=blocked; reason=") + reason; +} + +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionInput& input) +{ + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionResult result; + static_cast(result) = input.resultHandoff; + + if (result.status == LiteBridgeRuntimeStatus::Unavailable) { + return result; + } + + if (!input.resultHandoff.batch58ResultHandoffSurfaceReady) { + result.ok = false; + result.status = LiteBridgeRuntimeStatus::Failed; + result.issues.clear(); + result.error = "batch 59 requires ready batch 58 evidence before the promoted disabled readiness-projection surface"; + result.issues.push_back(result.error); + result.summary = batch59ReadinessProjectionBlockedSummary("batch_58_evidence_required"); + return result; + } + + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionInput legacyInput = static_cast(input); + legacyInput.resultHandoff = input.resultHandoff; + auto legacyResult = evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection(legacyInput); + static_cast(result) = input.resultHandoff; + static_cast(result) = legacyResult; + result.batch59ReadinessProjectionSurfaceReady = legacyResult.ok && legacyResult.status == LiteBridgeRuntimeStatus::Ready; + return result; +} + + +using LiteBridgeRuntimeBatch60StatusHandoffInput = LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffInput; +using LiteBridgeRuntimeBatch60StatusHandoffResult = LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffResult; + +static std::string batch60StatusHandoffBlockedSummary(const std::string& reason) +{ + return std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff=blocked; reason=") + reason; +} + +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffInput& input) +{ + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffResult result; + static_cast(result) = input.readinessProjection; + + if (result.status == LiteBridgeRuntimeStatus::Unavailable) { + return result; + } + + if (!input.readinessProjection.batch59ReadinessProjectionSurfaceReady) { + result.ok = false; + result.status = LiteBridgeRuntimeStatus::Failed; + result.issues.clear(); + result.error = "batch 60 requires ready batch 59 evidence before the promoted disabled status-handoff surface"; + result.issues.push_back(result.error); + result.summary = batch60StatusHandoffBlockedSummary("batch_59_evidence_required"); + return result; + } + + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffInput legacyInput = static_cast(input); + legacyInput.readinessProjection = input.readinessProjection; + auto legacyResult = evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff(legacyInput); + static_cast(result) = input.readinessProjection; + static_cast(result) = legacyResult; + result.batch60StatusHandoffSurfaceReady = legacyResult.ok && legacyResult.status == LiteBridgeRuntimeStatus::Ready; + return result; +} + +// Obsolete duplicate generated tail below aliases back to the already-defined Batch 50-52 public +// signatures. Keep it out of the build now that unique Batch54-60 surfaces are active. +#if 0 +using LiteBridgeRuntimeBatch54ResultHandoffInput = LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffInput; +using LiteBridgeRuntimeBatch54ResultHandoffResult = LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffResult; + +static std::string batch54ResultHandoffBlockedSummary(const std::string& reason) +{ + return std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff=blocked; reason=") + reason; +} + +static void addBatch54ResultHandoffIssue(LiteBridgeRuntimeBatch54ResultHandoffResult& result, + const std::string& message) +{ + result.issues.push_back(message); + if (result.error.empty()) result.error = message; +} + +static void setBatch54ResultHandoffAttemptEvidence(const LiteBridgeRuntimeBatch54ResultHandoffInput& input, + LiteBridgeRuntimeBatch54ResultHandoffResult& result) +{ + setBatch53PublicationGuardAttemptEvidence(input, result); + resetGeneratedLiteRuntimeCurrentExecutionGates(result); + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted; +} + +static bool batch54ResultHandoffAttempted(const LiteBridgeRuntimeBatch54ResultHandoffResult& result) +{ + return batch53PublicationGuardAttempted(result) || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted; +} + +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffInput& input) +{ + LiteBridgeRuntimeBatch54ResultHandoffResult result; + result.status = LiteBridgeRuntimeStatus::Configured; + const auto& publicationGuard = input.publicationGuard; + result.platform = normalizedPlatform(input.platform.empty() ? publicationGuard.platform : input.platform); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName; + setBatch54ResultHandoffAttemptEvidence(input, result); + resetGeneratedLiteRuntimeCurrentExecutionGates(result); + + if (batch54ResultHandoffAttempted(result)) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch54ResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff must stop before callback, dispatch result execution, status publication, readiness publication, result-handoff publication, and platform loader APIs"); + result.summary = batch54ResultHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_or_platform_api_attempted"); + return result; + } + + if (batch49PublicationGuardRuntimeActionRequested(result)) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch54ResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff must not request wallet runtime behavior"); + result.summary = batch54ResultHandoffBlockedSummary("runtime_action_requested"); + return result; + } + + if (result.platform.empty()) { + result.status = LiteBridgeRuntimeStatus::Unavailable; + addBatch54ResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff requires a target platform"); + result.summary = batch54ResultHandoffBlockedSummary("platform_missing"); + return result; + } + + if (isMacosPlatform(result.platform)) { + result.macosDeferred = true; + result.status = LiteBridgeRuntimeStatus::Unavailable; + addBatch54ResultHandoffIssue( + result, + input.macosDeferredByOperator + ? "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff is deferred by operator request" + : "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff requires a reviewed builder before promotion"); + result.summary = batch54ResultHandoffBlockedSummary("macos_deferred"); + return result; + } + + const bool linuxPlatform = isLinuxPlatform(result.platform); + const bool windowsPlatform = isWindowsPlatform(result.platform); + if (!linuxPlatform && !windowsPlatform) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch54ResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff supports only Linux and Windows in batch 54"); + result.summary = batch54ResultHandoffBlockedSummary("unsupported_platform"); + return result; + } + result.platformAccepted = true; + result.linuxPlatformAccepted = linuxPlatform; + result.windowsPlatformAccepted = windowsPlatform; + + if (!input.publicationGuardAccepted || !publicationGuard.ok || + !publicationGuard.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardReady || + publicationGuard.status != LiteBridgeRuntimeStatus::Ready || publicationGuard.platform != result.platform || + !publicationGuard.statusHandoffAccepted || !publicationGuard.publicationGuardRecordAccepted || + !publicationGuard.publicationGuardStatusHandoffMatchAccepted || !publicationGuard.disabledPublicationGuardAccepted || + !publicationGuard.callbackInvocationRefused || !publicationGuard.dispatchConsumptionStillGuarded || + !publicationGuard.dispatchResultExecutionBlocked || !publicationGuard.dispatchStatusPublicationBlocked || + !publicationGuard.readinessProjectionPublicationBlocked || !publicationGuard.statusHandoffPublicationBlocked || + !publicationGuard.publicationGuardPublicationBlocked || !publicationGuard.publicationGuardResultHandoffPublicationBlocked || + !publicationGuard.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked || + !publicationGuard.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked || + !publicationGuard.platformApiPreInvocationBlocked || !publicationGuard.disabledPublicationGuardStateAccepted || + !publicationGuard.publicationGuardFailureMappingAccepted || !publicationGuard.unloadExecutionBlocked || + !publicationGuard.symbolResolutionBlocked || !publicationGuard.productionLoaderDisabled || + !publicationGuard.realAdapterExecutionDisabled || !publicationGuard.loadOnlyExecutionDisabled || + !publicationGuard.separateExecutionBatchRequired || !publicationGuard.noRuntimePlatformDynamicLibraryLoaded || + !publicationGuard.noRuntimePlatformDynamicLibraryUnloaded || !publicationGuard.noRuntimePlatformSymbolResolution || + !publicationGuard.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch54ResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff requires matching ready disabled publication-guard evidence"); + result.summary = batch54ResultHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_required"); + return result; + } + + static_cast(result) = publicationGuard; + result.ok = false; + result.status = LiteBridgeRuntimeStatus::Configured; + result.issues.clear(); + result.error.clear(); + result.summary.clear(); + result.platformAccepted = true; + result.linuxPlatformAccepted = linuxPlatform; + result.windowsPlatformAccepted = windowsPlatform; + result.macosDeferred = false; + result.publicationGuardAccepted = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName; + setBatch54ResultHandoffAttemptEvidence(input, result); + resetGeneratedLiteRuntimeCurrentExecutionGates(result); + + if (!input.resultHandoffReviewed || !input.resultHandoffRecorded || !input.resultHandoffDisabled || + input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId.empty() || + input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch54ResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff requires a reviewed disabled result-handoff record"); + result.summary = batch54ResultHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_required"); + return result; + } + result.resultHandoffRecordAccepted = true; + + if (!input.resultHandoffMatchesPublicationGuardEvidence || result.adapterName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch54ResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff requires result-handoff-to-publication-guard match evidence"); + result.summary = batch54ResultHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_match_required"); + return result; + } + result.resultHandoffPublicationGuardMatchAccepted = true; + + if (!input.disabledResultHandoffRegistered || !input.resultHandoffAcceptsPublicationGuardEvidence || + !input.resultHandoffReturnsDisabledResult || + !input.resultHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch54ResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff requires disabled result-handoff evidence"); + result.summary = batch54ResultHandoffBlockedSummary( + "disabled_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_required"); + return result; + } + result.disabledResultHandoffAccepted = true; + + if (!input.callbackInvocationStillDisabled || !input.callbackInvocationRefused || !input.callbackInvocationRefusalReviewed || + !input.resultHandoffStopsBeforeCallbackInvocation || !input.resultHandoffStopsBeforeCallbackResultExecution || + !input.resultHandoffStopsBeforeDispatchConsumption || !input.resultHandoffStopsBeforeDispatchResultExecution || + !input.resultHandoffStopsBeforeDispatchStatusPublication || !input.resultHandoffStopsBeforeReadinessPublication || + !input.resultHandoffStopsBeforeStatusHandoffPublication || !input.resultHandoffStopsBeforePublicationGuardPublication || + !input.resultHandoffStopsBeforePublicationGuardResultHandoffPublication || + !input.resultHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication || + !input.resultHandoffStopsBeforePlatformApi || !input.resultHandoffRequiresSeparateExecutionBatch) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch54ResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff must remain disabled before callback, dispatch result execution, status publication, readiness publication, result publication, and platform APIs"); + result.summary = batch54ResultHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_disabled_state_required"); + return result; + } + result.callbackInvocationRefused = true; + result.dispatchConsumptionStillGuarded = true; + result.dispatchResultExecutionBlocked = true; + result.dispatchStatusPublicationBlocked = true; + result.readinessProjectionPublicationBlocked = true; + result.statusHandoffPublicationBlocked = true; + result.publicationGuardPublicationBlocked = true; + result.publicationGuardResultHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationBlocked = true; + result.platformApiPreInvocationBlocked = true; + + if (!input.resultHandoffProducesNoDynamicHandle || !input.resultHandoffStoresNoDynamicHandle || + !input.resultHandoffReleasesNoDynamicHandle || !input.resultHandoffResolvesNoSymbols || + !input.resultHandoffStoresNoSymbolTable || !input.resultHandoffCreatesNoRuntime) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch54ResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff must not create runtime loader state"); + result.summary = batch54ResultHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_runtime_state_required"); + return result; + } + result.disabledResultHandoffStateAccepted = true; + + if (!input.resultHandoffFailureMappingReviewed) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch54ResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff requires disabled result-handoff failure mapping review"); + result.summary = batch54ResultHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_failure_mapping_required"); + return result; + } + result.resultHandoffFailureMappingAccepted = true; + + if (!input.unloadExecutionStillDisabled || !input.symbolResolutionStillDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch54ResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff must keep unload and symbol resolution disabled"); + result.summary = batch54ResultHandoffBlockedSummary("non_load_execution_enabled"); + return result; + } + result.unloadExecutionBlocked = true; + result.symbolResolutionBlocked = true; + + if (!input.productionLoaderExecutionDisabled || !input.realAdapterExecutionDisabled || !input.loadOnlyExecutionDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch54ResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff must keep real loader execution disabled"); + result.summary = batch54ResultHandoffBlockedSummary("production_loader_enabled"); + return result; + } + result.productionLoaderDisabled = true; + result.realAdapterExecutionDisabled = true; + result.loadOnlyExecutionDisabled = true; + + if (!input.separateExecutionBatchRequired) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch54ResultHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff publication guard result handoff requires a separate execution batch"); + result.summary = batch54ResultHandoffBlockedSummary("separate_execution_batch_required"); + return result; + } + result.separateExecutionBatchRequired = true; + + result.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReady = true; + result.status = LiteBridgeRuntimeStatus::Ready; + result.ok = true; + result.summary = std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff=ready; platform=") + + result.platform + "; scope=load-only-disabled-callback-refusal-propagation-consumer-readiness-dispatch-consumption-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff; execution=disabled"; + return result; +} + +using LiteBridgeRuntimeBatch55ReadinessProjectionInput = LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionInput; +using LiteBridgeRuntimeBatch55ReadinessProjectionResult = LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionResult; + +static std::string batch55ReadinessProjectionBlockedSummary(const std::string& reason) +{ + return std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection=blocked; reason=") + reason; +} + +static void addBatch55ReadinessProjectionIssue(LiteBridgeRuntimeBatch55ReadinessProjectionResult& result, + const std::string& message) +{ + result.issues.push_back(message); + if (result.error.empty()) result.error = message; +} + +static void setBatch55ReadinessProjectionAttemptEvidence(const LiteBridgeRuntimeBatch55ReadinessProjectionInput& input, + LiteBridgeRuntimeBatch55ReadinessProjectionResult& result) +{ + setBatch54ResultHandoffAttemptEvidence(input, result); + resetGeneratedLiteRuntimeCurrentExecutionGates(result); + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted; +} + +static bool batch55ReadinessProjectionAttempted(const LiteBridgeRuntimeBatch55ReadinessProjectionResult& result) +{ + return batch54ResultHandoffAttempted(result) || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted; +} + +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionInput& input) +{ + LiteBridgeRuntimeBatch55ReadinessProjectionResult result; + result.status = LiteBridgeRuntimeStatus::Configured; + const auto& resultHandoff = input.resultHandoff; + result.platform = normalizedPlatform(input.platform.empty() ? resultHandoff.platform : input.platform); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName; + setBatch55ReadinessProjectionAttemptEvidence(input, result); + resetGeneratedLiteRuntimeCurrentExecutionGates(result); + + if (batch55ReadinessProjectionAttempted(result)) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch55ReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection must stop before callback, dispatch result execution, status publication, readiness publication, readiness-projection publication, and platform loader APIs"); + result.summary = batch55ReadinessProjectionBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_or_platform_api_attempted"); + return result; + } + + if (batch49PublicationGuardRuntimeActionRequested(result)) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch55ReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection must not request wallet runtime behavior"); + result.summary = batch55ReadinessProjectionBlockedSummary("runtime_action_requested"); + return result; + } + + if (result.platform.empty()) { + result.status = LiteBridgeRuntimeStatus::Unavailable; + addBatch55ReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection requires a target platform"); + result.summary = batch55ReadinessProjectionBlockedSummary("platform_missing"); + return result; + } + + if (isMacosPlatform(result.platform)) { + result.macosDeferred = true; + result.status = LiteBridgeRuntimeStatus::Unavailable; + addBatch55ReadinessProjectionIssue( + result, + input.macosDeferredByOperator + ? "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection is deferred by operator request" + : "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection requires a reviewed builder before promotion"); + result.summary = batch55ReadinessProjectionBlockedSummary("macos_deferred"); + return result; + } + + const bool linuxPlatform = isLinuxPlatform(result.platform); + const bool windowsPlatform = isWindowsPlatform(result.platform); + if (!linuxPlatform && !windowsPlatform) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch55ReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection supports only Linux and Windows in batch 55"); + result.summary = batch55ReadinessProjectionBlockedSummary("unsupported_platform"); + return result; + } + result.platformAccepted = true; + result.linuxPlatformAccepted = linuxPlatform; + result.windowsPlatformAccepted = windowsPlatform; + + if (!input.resultHandoffAccepted || !resultHandoff.ok || + !resultHandoff.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReady || + resultHandoff.status != LiteBridgeRuntimeStatus::Ready || resultHandoff.platform != result.platform || + !resultHandoff.publicationGuardAccepted || !resultHandoff.resultHandoffRecordAccepted || + !resultHandoff.resultHandoffPublicationGuardMatchAccepted || !resultHandoff.disabledResultHandoffAccepted || + !resultHandoff.callbackInvocationRefused || !resultHandoff.dispatchConsumptionStillGuarded || + !resultHandoff.dispatchResultExecutionBlocked || !resultHandoff.dispatchStatusPublicationBlocked || + !resultHandoff.readinessProjectionPublicationBlocked || !resultHandoff.statusHandoffPublicationBlocked || + !resultHandoff.publicationGuardPublicationBlocked || !resultHandoff.publicationGuardResultHandoffPublicationBlocked || + !resultHandoff.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationBlocked || + !resultHandoff.platformApiPreInvocationBlocked || !resultHandoff.disabledResultHandoffStateAccepted || + !resultHandoff.resultHandoffFailureMappingAccepted || !resultHandoff.unloadExecutionBlocked || + !resultHandoff.symbolResolutionBlocked || !resultHandoff.productionLoaderDisabled || + !resultHandoff.realAdapterExecutionDisabled || !resultHandoff.loadOnlyExecutionDisabled || + !resultHandoff.separateExecutionBatchRequired || !resultHandoff.noRuntimePlatformDynamicLibraryLoaded || + !resultHandoff.noRuntimePlatformDynamicLibraryUnloaded || !resultHandoff.noRuntimePlatformSymbolResolution || + !resultHandoff.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch55ReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection requires matching ready disabled result-handoff evidence"); + result.summary = batch55ReadinessProjectionBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_required"); + return result; + } + + static_cast(result) = resultHandoff; + result.ok = false; + result.status = LiteBridgeRuntimeStatus::Configured; + result.issues.clear(); + result.error.clear(); + result.summary.clear(); + result.platformAccepted = true; + result.linuxPlatformAccepted = linuxPlatform; + result.windowsPlatformAccepted = windowsPlatform; + result.macosDeferred = false; + result.resultHandoffAccepted = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName; + setBatch55ReadinessProjectionAttemptEvidence(input, result); + resetGeneratedLiteRuntimeCurrentExecutionGates(result); + + if (!input.readinessProjectionReviewed || !input.readinessProjectionRecorded || !input.readinessProjectionDisabled || + input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId.empty() || + input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch55ReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection requires a reviewed disabled readiness-projection record"); + result.summary = batch55ReadinessProjectionBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_required"); + return result; + } + result.readinessProjectionRecordAccepted = true; + + if (!input.readinessProjectionMatchesResultHandoffEvidence || result.adapterName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch55ReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection requires readiness-projection-to-result-handoff match evidence"); + result.summary = batch55ReadinessProjectionBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_match_required"); + return result; + } + result.readinessProjectionResultHandoffMatchAccepted = true; + + if (!input.disabledReadinessProjectionRegistered || !input.readinessProjectionAcceptsResultHandoffEvidence || + !input.readinessProjectionReturnsDisabledReadiness || + !input.readinessProjectionBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication || + !input.readinessProjectionBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch55ReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection requires disabled readiness-projection evidence"); + result.summary = batch55ReadinessProjectionBlockedSummary( + "disabled_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_required"); + return result; + } + result.disabledReadinessProjectionAccepted = true; + + if (!input.callbackInvocationStillDisabled || !input.callbackInvocationRefused || !input.callbackInvocationRefusalReviewed || + !input.readinessProjectionStopsBeforeCallbackInvocation || !input.readinessProjectionStopsBeforeCallbackResultExecution || + !input.readinessProjectionStopsBeforeDispatchConsumption || !input.readinessProjectionStopsBeforeDispatchResultExecution || + !input.readinessProjectionStopsBeforeDispatchStatusPublication || !input.readinessProjectionStopsBeforeReadinessPublication || + !input.readinessProjectionStopsBeforeStatusHandoffPublication || !input.readinessProjectionStopsBeforePublicationGuardPublication || + !input.readinessProjectionStopsBeforePublicationGuardResultHandoffPublication || + !input.readinessProjectionStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication || + !input.readinessProjectionStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication || + !input.readinessProjectionStopsBeforePlatformApi || !input.readinessProjectionRequiresSeparateExecutionBatch) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch55ReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection must remain disabled before callback, dispatch result execution, status publication, readiness publication, result projection, and platform APIs"); + result.summary = batch55ReadinessProjectionBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_disabled_state_required"); + return result; + } + result.callbackInvocationRefused = true; + result.dispatchConsumptionStillGuarded = true; + result.dispatchResultExecutionBlocked = true; + result.dispatchStatusPublicationBlocked = true; + result.readinessProjectionPublicationBlocked = true; + result.statusHandoffPublicationBlocked = true; + result.publicationGuardPublicationBlocked = true; + result.publicationGuardResultHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationBlocked = true; + result.platformApiPreInvocationBlocked = true; + + if (!input.readinessProjectionProducesNoDynamicHandle || !input.readinessProjectionStoresNoDynamicHandle || + !input.readinessProjectionReleasesNoDynamicHandle || !input.readinessProjectionResolvesNoSymbols || + !input.readinessProjectionStoresNoSymbolTable || !input.readinessProjectionCreatesNoRuntime) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch55ReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection must not create runtime loader state"); + result.summary = batch55ReadinessProjectionBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_runtime_state_required"); + return result; + } + result.disabledReadinessProjectionStateAccepted = true; + + if (!input.readinessProjectionFailureMappingReviewed) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch55ReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection requires disabled readiness-projection failure mapping review"); + result.summary = batch55ReadinessProjectionBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_failure_mapping_required"); + return result; + } + result.readinessProjectionFailureMappingAccepted = true; + + if (!input.unloadExecutionStillDisabled || !input.symbolResolutionStillDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch55ReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection must keep unload and symbol resolution disabled"); + result.summary = batch55ReadinessProjectionBlockedSummary("non_load_execution_enabled"); + return result; + } + result.unloadExecutionBlocked = true; + result.symbolResolutionBlocked = true; + + if (!input.productionLoaderExecutionDisabled || !input.realAdapterExecutionDisabled || !input.loadOnlyExecutionDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch55ReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection must keep real loader execution disabled"); + result.summary = batch55ReadinessProjectionBlockedSummary("production_loader_enabled"); + return result; + } + result.productionLoaderDisabled = true; + result.realAdapterExecutionDisabled = true; + result.loadOnlyExecutionDisabled = true; + + if (!input.separateExecutionBatchRequired) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch55ReadinessProjectionIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection requires a separate execution batch"); + result.summary = batch55ReadinessProjectionBlockedSummary("separate_execution_batch_required"); + return result; + } + result.separateExecutionBatchRequired = true; + + result.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionReady = true; + result.status = LiteBridgeRuntimeStatus::Ready; + result.ok = true; + result.summary = std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection=ready; platform=") + + result.platform + "; scope=load-only-disabled-callback-refusal-propagation-consumer-readiness-dispatch-consumption-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection; execution=disabled"; + return result; +} + +using LiteBridgeRuntimeBatch56StatusHandoffInput = LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffInput; +using LiteBridgeRuntimeBatch56StatusHandoffResult = LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffResult; + +static std::string batch56StatusHandoffBlockedSummary(const std::string& reason) +{ + return std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff=blocked; reason=") + reason; +} + +static void addBatch56StatusHandoffIssue(LiteBridgeRuntimeBatch56StatusHandoffResult& result, + const std::string& message) +{ + result.issues.push_back(message); + if (result.error.empty()) result.error = message; +} + +static void setBatch56StatusHandoffAttemptEvidence(const LiteBridgeRuntimeBatch56StatusHandoffInput& input, + LiteBridgeRuntimeBatch56StatusHandoffResult& result) +{ + setBatch55ReadinessProjectionAttemptEvidence(input, result); + resetGeneratedLiteRuntimeCurrentExecutionGates(result); + result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = !input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; +} + +static bool batch56StatusHandoffAttempted(const LiteBridgeRuntimeBatch56StatusHandoffResult& result) +{ + return batch55ReadinessProjectionAttempted(result) || + !result.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted; +} + +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffInput& input) +{ + LiteBridgeRuntimeBatch56StatusHandoffResult result; + result.status = LiteBridgeRuntimeStatus::Configured; + const auto& readinessProjection = input.readinessProjection; + result.platform = normalizedPlatform(input.platform.empty() ? readinessProjection.platform : input.platform); + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName; + setBatch56StatusHandoffAttemptEvidence(input, result); + resetGeneratedLiteRuntimeCurrentExecutionGates(result); + + if (batch56StatusHandoffAttempted(result)) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch56StatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff must stop before callback, dispatch result execution, status publication, readiness publication, status-handoff publication, and platform loader APIs"); + result.summary = batch56StatusHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_or_platform_api_attempted"); + return result; + } + + if (batch49PublicationGuardRuntimeActionRequested(result)) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch56StatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff must not request wallet runtime behavior"); + result.summary = batch56StatusHandoffBlockedSummary("runtime_action_requested"); + return result; + } + + if (result.platform.empty()) { + result.status = LiteBridgeRuntimeStatus::Unavailable; + addBatch56StatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff requires a target platform"); + result.summary = batch56StatusHandoffBlockedSummary("platform_missing"); + return result; + } + + if (isMacosPlatform(result.platform)) { + result.macosDeferred = true; + result.status = LiteBridgeRuntimeStatus::Unavailable; + addBatch56StatusHandoffIssue( + result, + input.macosDeferredByOperator + ? "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff is deferred by operator request" + : "macOS platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff requires a reviewed builder before promotion"); + result.summary = batch56StatusHandoffBlockedSummary("macos_deferred"); + return result; + } + + const bool linuxPlatform = isLinuxPlatform(result.platform); + const bool windowsPlatform = isWindowsPlatform(result.platform); + if (!linuxPlatform && !windowsPlatform) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch56StatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff supports only Linux and Windows in batch 56"); + result.summary = batch56StatusHandoffBlockedSummary("unsupported_platform"); + return result; + } + result.platformAccepted = true; + result.linuxPlatformAccepted = linuxPlatform; + result.windowsPlatformAccepted = windowsPlatform; + + if (!input.readinessProjectionAccepted || !readinessProjection.ok || + !readinessProjection.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionReady || + readinessProjection.status != LiteBridgeRuntimeStatus::Ready || readinessProjection.platform != result.platform || + !readinessProjection.resultHandoffAccepted || !readinessProjection.readinessProjectionRecordAccepted || + !readinessProjection.readinessProjectionResultHandoffMatchAccepted || !readinessProjection.disabledReadinessProjectionAccepted || + !readinessProjection.callbackInvocationRefused || !readinessProjection.dispatchConsumptionStillGuarded || + !readinessProjection.dispatchResultExecutionBlocked || !readinessProjection.dispatchStatusPublicationBlocked || + !readinessProjection.readinessProjectionPublicationBlocked || !readinessProjection.statusHandoffPublicationBlocked || + !readinessProjection.publicationGuardPublicationBlocked || !readinessProjection.publicationGuardResultHandoffPublicationBlocked || + !readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationBlocked || + !readinessProjection.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationBlocked || + !readinessProjection.platformApiPreInvocationBlocked || !readinessProjection.disabledReadinessProjectionStateAccepted || + !readinessProjection.readinessProjectionFailureMappingAccepted || !readinessProjection.unloadExecutionBlocked || + !readinessProjection.symbolResolutionBlocked || !readinessProjection.productionLoaderDisabled || + !readinessProjection.realAdapterExecutionDisabled || !readinessProjection.loadOnlyExecutionDisabled || + !readinessProjection.separateExecutionBatchRequired || !readinessProjection.noRuntimePlatformDynamicLibraryLoaded || + !readinessProjection.noRuntimePlatformDynamicLibraryUnloaded || !readinessProjection.noRuntimePlatformSymbolResolution || + !readinessProjection.noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch56StatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff requires matching ready disabled readiness-projection evidence"); + result.summary = batch56StatusHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_required"); + return result; + } + + static_cast(result) = readinessProjection; + result.ok = false; + result.status = LiteBridgeRuntimeStatus::Configured; + result.issues.clear(); + result.error.clear(); + result.summary.clear(); + result.platformAccepted = true; + result.linuxPlatformAccepted = linuxPlatform; + result.windowsPlatformAccepted = windowsPlatform; + result.macosDeferred = false; + result.readinessProjectionAccepted = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName = input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName; + setBatch56StatusHandoffAttemptEvidence(input, result); + resetGeneratedLiteRuntimeCurrentExecutionGates(result); + + if (!input.statusHandoffReviewed || !input.statusHandoffRecorded || !input.statusHandoffDisabled || + input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId.empty() || + input.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch56StatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff requires a reviewed disabled status-handoff record"); + result.summary = batch56StatusHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_required"); + return result; + } + result.statusHandoffRecordAccepted = true; + + if (!input.statusHandoffMatchesReadinessProjectionEvidence || result.adapterName.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch56StatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff requires status-handoff-to-readiness-projection match evidence"); + result.summary = batch56StatusHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_match_required"); + return result; + } + result.statusHandoffReadinessProjectionMatchAccepted = true; + + if (!input.disabledStatusHandoffRegistered || !input.statusHandoffAcceptsReadinessProjectionEvidence || + !input.statusHandoffReturnsDisabledStatus || !input.statusHandoffBlocksDispatchConsumption || + !input.statusHandoffBlocksDispatchResultExecution || !input.statusHandoffBlocksStatusPublication || + !input.statusHandoffBlocksReadinessPublication || !input.statusHandoffBlocksStatusHandoffPublication || + !input.statusHandoffBlocksPublicationGuardPublication || !input.statusHandoffBlocksPublicationGuardResultHandoffPublication || + !input.statusHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch56StatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff requires disabled status-handoff evidence"); + result.summary = batch56StatusHandoffBlockedSummary( + "disabled_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_required"); + return result; + } + result.disabledStatusHandoffAccepted = true; + + if (!input.callbackInvocationStillDisabled || !input.callbackInvocationRefused || !input.callbackInvocationRefusalReviewed || + !input.statusHandoffStopsBeforeCallbackInvocation || !input.statusHandoffStopsBeforeCallbackResultExecution || + !input.statusHandoffStopsBeforeDispatchConsumption || !input.statusHandoffStopsBeforeDispatchResultExecution || + !input.statusHandoffStopsBeforeDispatchStatusPublication || !input.statusHandoffStopsBeforeReadinessPublication || + !input.statusHandoffStopsBeforeStatusHandoffPublication || !input.statusHandoffStopsBeforePublicationGuardPublication || + !input.statusHandoffStopsBeforePublicationGuardResultHandoffPublication || + !input.statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication || + !input.statusHandoffStopsBeforePlatformApi || !input.statusHandoffRequiresSeparateExecutionBatch) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch56StatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff must remain disabled before callback, dispatch result execution, status publication, readiness publication, status handoff, and platform APIs"); + result.summary = batch56StatusHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_disabled_state_required"); + return result; + } + result.callbackInvocationRefused = true; + result.dispatchConsumptionStillGuarded = true; + result.dispatchResultExecutionBlocked = true; + result.dispatchStatusPublicationBlocked = true; + result.readinessProjectionPublicationBlocked = true; + result.statusHandoffPublicationBlocked = true; + result.publicationGuardPublicationBlocked = true; + result.publicationGuardResultHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationBlocked = true; + result.publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked = true; + result.platformApiPreInvocationBlocked = true; + + if (!input.statusHandoffProducesNoDynamicHandle || !input.statusHandoffStoresNoDynamicHandle || + !input.statusHandoffReleasesNoDynamicHandle || !input.statusHandoffResolvesNoSymbols || + !input.statusHandoffStoresNoSymbolTable || !input.statusHandoffCreatesNoRuntime) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch56StatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff must not create runtime loader state"); + result.summary = batch56StatusHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_runtime_state_required"); + return result; + } + result.disabledStatusHandoffStateAccepted = true; + + if (!input.statusHandoffFailureMappingReviewed) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch56StatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff requires disabled status-handoff failure mapping review"); + result.summary = batch56StatusHandoffBlockedSummary( + "publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_failure_mapping_required"); + return result; + } + result.statusHandoffFailureMappingAccepted = true; + + if (!input.unloadExecutionStillDisabled || !input.symbolResolutionStillDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch56StatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff must keep unload and symbol resolution disabled"); + result.summary = batch56StatusHandoffBlockedSummary("non_load_execution_enabled"); + return result; + } + result.unloadExecutionBlocked = true; + result.symbolResolutionBlocked = true; + + if (!input.productionLoaderExecutionDisabled || !input.realAdapterExecutionDisabled || !input.loadOnlyExecutionDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch56StatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff must keep real loader execution disabled"); + result.summary = batch56StatusHandoffBlockedSummary("production_loader_enabled"); + return result; + } + result.productionLoaderDisabled = true; + result.realAdapterExecutionDisabled = true; + result.loadOnlyExecutionDisabled = true; + + if (!input.separateExecutionBatchRequired) { + result.status = LiteBridgeRuntimeStatus::Failed; + addBatch56StatusHandoffIssue( + result, + "platform dynamic-loader real-adapter load-only execution disabled callback refusal propagation consumer-readiness dispatch-consumption guard result handoff readiness projection status handoff requires a separate execution batch"); + result.summary = batch56StatusHandoffBlockedSummary("separate_execution_batch_required"); + return result; + } + result.separateExecutionBatchRequired = true; + + result.loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffReady = true; + result.status = LiteBridgeRuntimeStatus::Ready; + result.ok = true; + result.summary = std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_load_only_execution_disabled_callback_refusal_propagation_consumer_readiness_dispatch_consumption_guard_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff_publication_guard_result_handoff_readiness_projection_status_handoff=ready; platform=") + + result.platform + "; scope=load-only-disabled-callback-refusal-propagation-consumer-readiness-dispatch-consumption-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff-publication-guard-result-handoff-readiness-projection-status-handoff; execution=disabled"; + return result; +} + +#endif + +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterImplementationReviewResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterImplementationReview( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterImplementationReviewInput& input) +{ + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterImplementationReviewResult result; + result.status = LiteBridgeRuntimeStatus::Configured; + result.platform = normalizedPlatform( + input.platform.empty() ? input.noOpAdapterSeam.platform : input.platform); + result.adapterName = input.adapterName; + result.requiredSymbolCount = input.requiredSymbolCount; + + result.noRuntimePlatformDynamicLibraryLoaded = !input.runtimePlatformLoadAttempted; + result.noRuntimePlatformDynamicLibraryUnloaded = !input.runtimePlatformUnloadAttempted; + result.noRuntimePlatformSymbolResolution = !input.runtimePlatformSymbolResolutionAttempted; + result.noSdxlCalls = !input.sdxlCallRequested; + result.noBridgeCalls = !input.bridgeCallRequested; + result.noServerConnectivityChecked = !input.serverConnectivityCheckRequested; + result.noWalletLifecycle = !input.walletLifecycleRequested; + result.noSyncStarted = !input.syncRequested; + result.noSyncStatusPolled = !input.syncStatusPollingRequested; + result.noWorkerQueueEnqueue = !input.workerQueueRequested; + result.noWalletStateMutation = !input.walletStateMutationRequested; + result.noWalletPersistence = !input.walletPersistenceRequested; + result.noSettingsPersistence = !input.settingsWriteRequested; + result.noSendImportExportExecution = !input.sendImportExportRequested; + result.noArtifactMutation = !input.artifactMutationRequested; + + if (!result.noRuntimePlatformDynamicLibraryLoaded || + !result.noRuntimePlatformDynamicLibraryUnloaded || + !result.noRuntimePlatformSymbolResolution) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterImplementationReviewIssue( + result, + "platform dynamic-loader real-adapter implementation review must not execute platform loader APIs in runtime"); + result.summary = platformDynamicLoaderRealAdapterImplementationReviewBlockedSummary( + "runtime_platform_api_attempted"); + return result; + } + + if (!result.noSdxlCalls || + !result.noBridgeCalls || + !result.noServerConnectivityChecked || + !result.noWalletLifecycle || + !result.noSyncStarted || + !result.noSyncStatusPolled || + !result.noWorkerQueueEnqueue || + !result.noWalletStateMutation || + !result.noWalletPersistence || + !result.noSettingsPersistence || + !result.noSendImportExportExecution || + !result.noArtifactMutation) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterImplementationReviewIssue( + result, + "platform dynamic-loader real-adapter implementation review must not request wallet runtime behavior"); + result.summary = platformDynamicLoaderRealAdapterImplementationReviewBlockedSummary( + "runtime_action_requested"); + return result; + } + + if (result.platform.empty()) { + result.status = LiteBridgeRuntimeStatus::Unavailable; + addPlatformDynamicLoaderRealAdapterImplementationReviewIssue( + result, + "platform dynamic-loader real-adapter implementation review requires a target platform"); + result.summary = platformDynamicLoaderRealAdapterImplementationReviewBlockedSummary( + "platform_missing"); + return result; + } + + if (isMacosPlatform(result.platform)) { + result.macosDeferred = true; + result.status = LiteBridgeRuntimeStatus::Unavailable; + addPlatformDynamicLoaderRealAdapterImplementationReviewIssue( + result, + input.macosDeferredByOperator + ? "macOS platform dynamic-loader real-adapter implementation review is deferred by operator request" + : "macOS platform dynamic-loader real-adapter implementation review requires a reviewed builder before promotion"); + result.summary = platformDynamicLoaderRealAdapterImplementationReviewBlockedSummary( + "macos_deferred"); + return result; + } + + const bool linuxPlatform = isLinuxPlatform(result.platform); + const bool windowsPlatform = isWindowsPlatform(result.platform); + if (!linuxPlatform && !windowsPlatform) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterImplementationReviewIssue( + result, + "platform dynamic-loader real-adapter implementation review supports only Linux and Windows in batch 14"); + result.summary = platformDynamicLoaderRealAdapterImplementationReviewBlockedSummary( + "unsupported_platform"); + return result; + } + + result.platformAccepted = true; + result.linuxPlatformAccepted = linuxPlatform; + result.windowsPlatformAccepted = windowsPlatform; + + const auto& seam = input.noOpAdapterSeam; + if (!input.noOpAdapterSeamAccepted || + !seam.ok || + !seam.noOpAdapterSeamReady || + seam.status != LiteBridgeRuntimeStatus::Ready || + seam.platform != result.platform) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterImplementationReviewIssue( + result, + "platform dynamic-loader real-adapter implementation review requires a matching ready no-op adapter seam"); + result.summary = platformDynamicLoaderRealAdapterImplementationReviewBlockedSummary( + "noop_adapter_seam_required"); + return result; + } + result.noOpAdapterSeamAccepted = true; + + const auto& binding = input.noOpAdapterBinding; + if (!input.noOpBindingEvidenceAccepted || + binding.ok || + binding.status != LiteBridgeRuntimeStatus::Configured || + !binding.dynamicLibraryBindingRequested || + !binding.noOpAdapterSeamResultAccepted || + !binding.noOpAdapterBindingEvidenceReady || + binding.symbolTableProduced || + binding.symbolTableReady || + binding.runtimeReady || + binding.dynamicLibraryHandlePresent || + !binding.noDynamicLibraryLoaded || + !binding.noPlatformSymbolResolution || + !binding.noOpAdapterProductionLoaderDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterImplementationReviewIssue( + result, + "platform dynamic-loader real-adapter implementation review requires disabled no-op binding evidence"); + result.summary = platformDynamicLoaderRealAdapterImplementationReviewBlockedSummary( + "noop_binding_evidence_required"); + return result; + } + result.noOpBindingEvidenceAccepted = true; + + if (!input.realAdapterSourceReviewed || + input.adapterName.empty() || + (linuxPlatform && !input.linuxRealAdapterImplementationAvailable) || + (windowsPlatform && !input.windowsRealAdapterImplementationAvailable)) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterImplementationReviewIssue( + result, + "platform dynamic-loader real-adapter implementation review requires reviewed source ownership for the target platform"); + result.summary = platformDynamicLoaderRealAdapterImplementationReviewBlockedSummary( + "real_adapter_source_review_required"); + return result; + } + result.realAdapterSourceAccepted = true; + + if ((linuxPlatform && !input.linuxDlopenDlsymDlcloseMappingReviewed) || + (windowsPlatform && !input.windowsLoadLibraryGetProcAddressFreeLibraryMappingReviewed)) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterImplementationReviewIssue( + result, + "platform dynamic-loader real-adapter implementation review requires reviewed platform API mapping"); + result.summary = platformDynamicLoaderRealAdapterImplementationReviewBlockedSummary( + "platform_api_mapping_required"); + return result; + } + result.platformApiMappingAccepted = true; + + if (!input.loadImplementationReviewed || !input.reviewedArtifactPathUse) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterImplementationReviewIssue( + result, + "platform dynamic-loader real-adapter implementation review requires load implementation and reviewed artifact path use"); + result.summary = platformDynamicLoaderRealAdapterImplementationReviewBlockedSummary( + "load_implementation_review_required"); + return result; + } + result.loadImplementationAccepted = true; + + if (!input.unloadImplementationReviewed || + !input.opaqueHandleOwnershipReviewed || + !input.unloadAfterRuntimeShutdownReviewed || + !input.unloadAfterOwnedStringsReviewed) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterImplementationReviewIssue( + result, + "platform dynamic-loader real-adapter implementation review requires unload and handle ownership review"); + result.summary = platformDynamicLoaderRealAdapterImplementationReviewBlockedSummary( + "unload_implementation_review_required"); + return result; + } + result.unloadImplementationAccepted = true; + result.handleOwnershipAccepted = true; + + if (!input.symbolLookupImplementationReviewed || + !input.symbolLookupContainedInRuntime || + !input.requiredSymbolCastPlanReviewed || + !input.rawSymbolPointerEscapeBlocked) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterImplementationReviewIssue( + result, + "platform dynamic-loader real-adapter implementation review requires contained symbol lookup and cast review"); + result.summary = platformDynamicLoaderRealAdapterImplementationReviewBlockedSummary( + "symbol_lookup_implementation_review_required"); + return result; + } + result.symbolLookupImplementationAccepted = true; + result.symbolCastingBoundaryAccepted = true; + + if (!input.pathEncodingReviewed || !input.errorMappingReviewed) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterImplementationReviewIssue( + result, + "platform dynamic-loader real-adapter implementation review requires path encoding and error mapping review"); + result.summary = platformDynamicLoaderRealAdapterImplementationReviewBlockedSummary( + "path_error_mapping_required"); + return result; + } + result.pathAndErrorMappingAccepted = true; + + if (!input.requiredSymbolMapReused || + input.requiredSymbolCount != liteBridgeRuntimeRequiredSymbolLogicalNames().size() || + !input.symbolTableReuseReviewed || + !input.stringOwnershipReused) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterImplementationReviewIssue( + result, + "platform dynamic-loader real-adapter implementation review requires existing symbol table and string ownership reuse"); + result.summary = platformDynamicLoaderRealAdapterImplementationReviewBlockedSummary( + "symbol_table_reuse_required"); + return result; + } + result.symbolTableReuseAccepted = true; + + if (!input.runtimePlatformImplementationDeferred || + !input.productionLoaderExecutionDisabled || + !input.realAdapterExecutionDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addPlatformDynamicLoaderRealAdapterImplementationReviewIssue( + result, + "platform dynamic-loader real-adapter implementation review must keep real adapter execution disabled"); + result.summary = platformDynamicLoaderRealAdapterImplementationReviewBlockedSummary( + "production_loader_enabled"); + return result; + } + result.runtimeDeferralAccepted = true; + result.productionLoaderDisabled = true; + + result.realAdapterImplementationReviewReady = true; + result.status = LiteBridgeRuntimeStatus::Ready; + result.ok = true; + result.summary = std::string("lite_bridge_runtime_platform_dynamic_loader_real_adapter_implementation_review=ready; platform=") + + result.platform + "; scope=implementation-review; execution=disabled"; + return result; +} + +LiteBridgeOwnedString::LiteBridgeOwnedString(char* rawValue, FreeStringFn freeString) + : rawValue_(rawValue), + freeString_(freeString), + rawPointerReceived_(rawValue != nullptr) +{ +} + +LiteBridgeOwnedString::LiteBridgeOwnedString( + char* rawValue, + FreeStringFn freeString, + std::shared_ptr teardownState) + : rawValue_(rawValue), + freeString_(freeString), + teardownState_(rawValue ? std::move(teardownState) : nullptr), + rawPointerReceived_(rawValue != nullptr) +{ + if (teardownState_) teardownState_->retainOwnedString(); +} + +LiteBridgeOwnedString::LiteBridgeOwnedString(LiteBridgeOwnedString&& other) noexcept +{ + moveFrom(std::move(other)); +} + +LiteBridgeOwnedString& LiteBridgeOwnedString::operator=(LiteBridgeOwnedString&& other) noexcept +{ + if (this == &other) return *this; + copyValueBeforeFree(); + releaseRawValue(); + wipeString(copiedValue_); + moveFrom(std::move(other)); + return *this; +} + +LiteBridgeOwnedString::~LiteBridgeOwnedString() +{ + copyValueBeforeFree(); + releaseRawValue(); + wipeString(copiedValue_); +} + +LiteBridgeStringResult LiteBridgeOwnedString::intoResult() +{ + if (resultTaken_) return {false, {}, "lite bridge string result already consumed"}; + resultTaken_ = true; + + if (!rawPointerReceived_) return {false, {}, "lite bridge returned a null string"}; + if (!rawValue_) return {false, {}, "lite bridge string was already released"}; + if (!freeString_) { + rawValue_ = nullptr; + releaseRuntimeOwnership(); + return {false, {}, "lite bridge freeString function is unavailable"}; + } + + copyValueBeforeFree(); + releaseRawValue(); + + const std::string resultValue = copiedValue_; + wipeString(copiedValue_); + if (looksLikeError(resultValue)) return {false, {}, resultValue}; + return {true, resultValue, {}}; +} + +void LiteBridgeOwnedString::copyValueBeforeFree() +{ + if (!rawValue_ || copiedBeforeFree_) return; + copiedValue_ = rawValue_; + copiedBeforeFree_ = true; +} + +void LiteBridgeOwnedString::releaseRawValue() +{ + if (!rawValue_) return; + if (freeString_) { + freeString_(rawValue_); + freed_ = true; + } + rawValue_ = nullptr; + releaseRuntimeOwnership(); +} + +void LiteBridgeOwnedString::releaseRuntimeOwnership() +{ + if (!teardownState_ || runtimeOwnershipReleased_) return; + teardownState_->releaseOwnedString(); + runtimeOwnershipReleased_ = true; + teardownState_.reset(); +} + +void LiteBridgeOwnedString::moveFrom(LiteBridgeOwnedString&& other) noexcept +{ + rawValue_ = other.rawValue_; + freeString_ = other.freeString_; + teardownState_ = std::move(other.teardownState_); + rawPointerReceived_ = other.rawPointerReceived_; + copiedBeforeFree_ = other.copiedBeforeFree_; + freed_ = other.freed_; + resultTaken_ = other.resultTaken_; + runtimeOwnershipReleased_ = other.runtimeOwnershipReleased_; + copiedValue_ = std::move(other.copiedValue_); + + other.rawValue_ = nullptr; + other.freeString_ = nullptr; + other.teardownState_.reset(); + other.rawPointerReceived_ = false; + other.copiedBeforeFree_ = false; + other.freed_ = false; + other.resultTaken_ = true; + other.runtimeOwnershipReleased_ = true; + wipeString(other.copiedValue_); +} + +LiteBridgeStringResult liteBridgeRuntimeTakeOwnedString( + char* rawValue, + LiteClientBridgeApi::FreeStringFn freeString) +{ + LiteBridgeOwnedString ownedString(rawValue, freeString); + return ownedString.intoResult(); +} + +LiteBridgeRuntime LiteBridgeRuntime::unavailable(std::string reason) +{ + return LiteBridgeRuntime({}, std::move(reason), LiteBridgeRuntimeStatus::Unavailable); +} + +LiteBridgeRuntime LiteBridgeRuntime::fromBindingResult(const LiteBridgeRuntimeBindingResult& result) +{ + if (!result.ok || !result.runtimeReady || !result.symbolTableReady) { + return unavailable(result.error.empty() ? "lite bridge runtime binding is not ready" : result.error); + } + auto runtime = result.dynamicLibraryHandlePresent + ? LiteBridgeRuntime(result.symbolTable.api, + {}, + LiteBridgeRuntimeStatus::Ready, + result.dynamicLibraryHandle) + : LiteBridgeRuntime(result.symbolTable.api, {}, LiteBridgeRuntimeStatus::Ready); + runtime.symbolSource_ = result.symbolTable.source; + runtime.fakeDispatchAllowed_ = + (result.providedSymbolTableAccepted || result.fakeDynamicLoaderResultAccepted) && + isFakeSymbolSource(result.symbolTable.source); + return runtime; +} + +LiteBridgeRuntime LiteBridgeRuntime::fromFakeDynamicLoaderResult( + const LiteBridgeRuntimeFakeDynamicLoaderResult& result) +{ + if (!result.ok || !result.runtimeReady || !result.symbolTableReady) { + return LiteBridgeRuntime({}, + result.error.empty() + ? "lite bridge fake dynamic loader result is not ready" + : result.error, + result.status); + } + auto runtime = LiteBridgeRuntime(result.symbolTable.api, + {}, + LiteBridgeRuntimeStatus::Ready, + result.handle); + runtime.symbolSource_ = result.symbolTable.source; + runtime.fakeDispatchAllowed_ = isFakeSymbolSource(result.symbolTable.source); + return runtime; +} + +LiteBridgeRuntime::LiteBridgeRuntime(LiteClientBridgeApi api, + std::string unavailableReason, + LiteBridgeRuntimeStatus status) + : api_(api), + unavailableReason_(std::move(unavailableReason)), + fallbackStatus_(status) +{ + if (status == LiteBridgeRuntimeStatus::Ready) { + teardownState_ = std::make_shared(); + teardownState_->shutdown = api_.shutdown; + teardownState_->status = LiteBridgeRuntimeStatus::Ready; + } +} + +LiteBridgeRuntime::LiteBridgeRuntime(LiteClientBridgeApi api, + std::string unavailableReason, + LiteBridgeRuntimeStatus status, + LiteBridgeRuntimeDynamicLibraryHandle dynamicLibraryHandle) + : LiteBridgeRuntime(api, std::move(unavailableReason), status) +{ + if (teardownState_) teardownState_->dynamicLibraryHandle = std::move(dynamicLibraryHandle); +} + +LiteBridgeRuntime::LiteBridgeRuntime(LiteBridgeRuntime&& other) noexcept + : api_(other.api_), + teardownState_(std::move(other.teardownState_)), + unavailableReason_(std::move(other.unavailableReason_)), + symbolSource_(std::move(other.symbolSource_)), + fallbackStatus_(other.fallbackStatus_), + fakeDispatchAllowed_(other.fakeDispatchAllowed_) +{ + other.api_ = {}; + other.fallbackStatus_ = LiteBridgeRuntimeStatus::Shutdown; + other.fakeDispatchAllowed_ = false; +} + +LiteBridgeRuntime& LiteBridgeRuntime::operator=(LiteBridgeRuntime&& other) noexcept +{ + if (this == &other) return *this; + shutdown(); + api_ = other.api_; + teardownState_ = std::move(other.teardownState_); + unavailableReason_ = std::move(other.unavailableReason_); + symbolSource_ = std::move(other.symbolSource_); + fallbackStatus_ = other.fallbackStatus_; + fakeDispatchAllowed_ = other.fakeDispatchAllowed_; + other.api_ = {}; + other.fallbackStatus_ = LiteBridgeRuntimeStatus::Shutdown; + other.fakeDispatchAllowed_ = false; + return *this; +} + +LiteBridgeRuntime::~LiteBridgeRuntime() +{ + shutdown(); +} + +bool LiteBridgeRuntime::available() const +{ + return teardownState_ && status() == LiteBridgeRuntimeStatus::Ready; +} + +LiteBridgeRuntimeStatus LiteBridgeRuntime::status() const +{ + return teardownState_ ? teardownState_->status : fallbackStatus_; +} + +bool LiteBridgeRuntime::shutdownCalled() const +{ + return teardownState_ ? teardownState_->shutdownCalled : fallbackStatus_ == LiteBridgeRuntimeStatus::Shutdown; +} + +bool LiteBridgeRuntime::shutdownPending() const +{ + return teardownState_ && teardownState_->shutdownRequested && !teardownState_->shutdownCalled; +} + +bool LiteBridgeRuntime::dynamicLibraryUnloadDeferred() const +{ + return !teardownState_ || teardownState_->dynamicLibraryUnloadDeferred; +} + +bool LiteBridgeRuntime::dynamicLibraryHandlePresent() const +{ + return teardownState_ && teardownState_->dynamicLibraryHandle.present; +} + +bool LiteBridgeRuntime::dynamicLibraryUnloadCalled() const +{ + return teardownState_ && teardownState_->dynamicLibraryUnloadCalled; +} + +std::size_t LiteBridgeRuntime::outstandingOwnedStringCount() const +{ + return teardownState_ ? teardownState_->outstandingOwnedStrings : 0; +} + +LiteBridgeOwnedString LiteBridgeRuntime::takeOwnedString(char* rawValue) +{ + if (!teardownState_) return LiteBridgeOwnedString(rawValue, api_.freeString); + return LiteBridgeOwnedString(rawValue, api_.freeString, teardownState_); +} + +LiteBridgeRuntimeDryDispatchResult LiteBridgeRuntime::makeDryDispatchResult( + LiteBridgeRuntimeDryDispatchOperation operation) const +{ + LiteBridgeRuntimeDryDispatchResult result; + result.operation = operation; + result.status = status(); + result.summary = std::string("lite_bridge_runtime_dry_dispatch=pending; operation=") + + liteBridgeRuntimeDryDispatchOperationName(operation); + return result; +} + +bool LiteBridgeRuntime::prepareDryDispatch(LiteBridgeRuntimeDryDispatchResult& result, + bool symbolAvailable) const +{ + if (!teardownState_) { + result.error = unavailableReason_.empty() + ? "lite bridge runtime is unavailable" + : unavailableReason_; + result.summary = dryDispatchBlockedSummary("runtime_unavailable"); + result.status = status(); + return false; + } + if (!fakeDispatchAllowed_) { + result.error = "lite bridge dry dispatch is available only for fake symbol tables"; + result.summary = dryDispatchBlockedSummary("fake_only_required"); + result.status = status(); + return false; + } + if (status() != LiteBridgeRuntimeStatus::Ready) { + result.error = "lite bridge runtime is not ready for dry dispatch"; + result.summary = dryDispatchBlockedSummary("runtime_not_ready"); + result.status = status(); + return false; + } + if (!symbolAvailable) { + result.error = "lite bridge dry dispatch symbol is unavailable"; + result.summary = dryDispatchBlockedSummary("symbol_unavailable"); + result.status = status(); + return false; + } + result.fakeCallAttempted = true; + return true; +} + +LiteBridgeRuntimeDryDispatchResult LiteBridgeRuntime::dryDispatchOwnedString( + LiteBridgeRuntimeDryDispatchOperation operation, + char* rawValue) +{ + auto result = makeDryDispatchResult(operation); + result.fakeCallAttempted = true; + auto ownedString = takeOwnedString(rawValue); + result.stringResult = ownedString.intoResult(); + result.ok = result.stringResult.ok; + result.error = result.stringResult.error; + result.status = status(); + result.summary = result.ok + ? std::string("lite_bridge_runtime_dry_dispatch=ok; operation=") + + liteBridgeRuntimeDryDispatchOperationName(operation) + : std::string("lite_bridge_runtime_dry_dispatch=failed; operation=") + + liteBridgeRuntimeDryDispatchOperationName(operation); + return result; +} + +LiteBridgeRuntimeDryDispatchResult LiteBridgeRuntime::dryDispatchWalletExists( + const std::string& chainName) +{ + auto result = makeDryDispatchResult(LiteBridgeRuntimeDryDispatchOperation::WalletExists); + if (!prepareDryDispatch(result, api_.walletExists != nullptr)) return result; + result.boolValue = api_.walletExists(chainName.c_str()); + result.ok = true; + result.status = status(); + result.summary = "lite_bridge_runtime_dry_dispatch=ok; operation=walletExists"; + return result; +} + +LiteBridgeRuntimeDryDispatchResult LiteBridgeRuntime::dryDispatchCheckServerOnline( + const std::string& server) +{ + auto result = makeDryDispatchResult(LiteBridgeRuntimeDryDispatchOperation::CheckServerOnline); + if (!prepareDryDispatch(result, api_.checkServerOnline != nullptr)) return result; + result.boolValue = api_.checkServerOnline(server.c_str()); + result.ok = true; + result.status = status(); + result.summary = "lite_bridge_runtime_dry_dispatch=ok; operation=checkServerOnline"; + return result; +} + +LiteBridgeRuntimeDryDispatchResult LiteBridgeRuntime::dryDispatchExecute( + const std::string& command, + const std::string& args) +{ + auto result = makeDryDispatchResult(LiteBridgeRuntimeDryDispatchOperation::Execute); + if (command.empty()) { + result.error = "lite bridge dry dispatch command is empty"; + result.summary = dryDispatchBlockedSummary("empty_command"); + return result; + } + if (!prepareDryDispatch(result, api_.execute != nullptr)) return result; + return dryDispatchOwnedString(LiteBridgeRuntimeDryDispatchOperation::Execute, + api_.execute(command.c_str(), args.c_str())); +} + +LiteBridgeRuntimeDryDispatchResult LiteBridgeRuntime::dryDispatchInitializeNew( + bool dangerous, + const std::string& server) +{ + auto result = makeDryDispatchResult(LiteBridgeRuntimeDryDispatchOperation::InitializeNew); + if (!prepareDryDispatch(result, api_.initializeNew != nullptr)) return result; + return dryDispatchOwnedString(LiteBridgeRuntimeDryDispatchOperation::InitializeNew, + api_.initializeNew(dangerous, server.c_str())); +} + +LiteBridgeRuntimeDryDispatchResult LiteBridgeRuntime::dryDispatchInitializeExisting( + bool dangerous, + const std::string& server) +{ + auto result = makeDryDispatchResult(LiteBridgeRuntimeDryDispatchOperation::InitializeExisting); + if (!prepareDryDispatch(result, api_.initializeExisting != nullptr)) return result; + return dryDispatchOwnedString(LiteBridgeRuntimeDryDispatchOperation::InitializeExisting, + api_.initializeExisting(dangerous, server.c_str())); +} + +LiteBridgeRuntimeDryDispatchResult LiteBridgeRuntime::dryDispatchInitializeNewFromPhrase( + bool dangerous, + const std::string& server, + const std::string& seed, + unsigned long long birthday, + unsigned long long account, + bool overwrite) +{ + auto result = makeDryDispatchResult(LiteBridgeRuntimeDryDispatchOperation::InitializeNewFromPhrase); + if (!prepareDryDispatch(result, api_.initializeNewFromPhrase != nullptr)) return result; + return dryDispatchOwnedString( + LiteBridgeRuntimeDryDispatchOperation::InitializeNewFromPhrase, + api_.initializeNewFromPhrase(dangerous, + server.c_str(), + seed.c_str(), + birthday, + account, + overwrite)); +} + +LiteBridgeRuntimeDryDispatchResult LiteBridgeRuntime::dryDispatchShutdown() +{ + auto result = makeDryDispatchResult(LiteBridgeRuntimeDryDispatchOperation::Shutdown); + if (!teardownState_) { + result.error = unavailableReason_.empty() + ? "lite bridge runtime is unavailable" + : unavailableReason_; + result.summary = dryDispatchBlockedSummary("runtime_unavailable"); + return result; + } + if (!fakeDispatchAllowed_) { + result.error = "lite bridge dry dispatch is available only for fake symbol tables"; + result.summary = dryDispatchBlockedSummary("fake_only_required"); + result.status = status(); + return result; + } + if (status() == LiteBridgeRuntimeStatus::Shutdown) { + result.ok = true; + result.status = status(); + result.summary = "lite_bridge_runtime_dry_dispatch=ok; operation=shutdown; already_shutdown=true"; + return result; + } + result.fakeCallAttempted = outstandingOwnedStringCount() == 0; + shutdown(); + result.ok = true; + result.status = status(); + result.summary = "lite_bridge_runtime_dry_dispatch=ok; operation=shutdown"; + return result; +} + +void LiteBridgeRuntime::shutdown() +{ + if (!teardownState_) { + fallbackStatus_ = LiteBridgeRuntimeStatus::Shutdown; + return; + } + teardownState_->requestShutdown(); +} + +LiteBridgeRuntimeBindingResult evaluateLiteBridgeRuntimeBinding( + const LiteBridgeRuntimeBindingInput& input, + LiteBridgeRuntimeBindingOptions options) +{ + LiteBridgeRuntimeBindingResult result; + result.config = input.config; + + if (options.rejectRuntimeActions && rejectRuntimeActions(input, result)) return result; + + if (options.requireArtifactContract && !input.artifactContract.ok) { + result.status = LiteBridgeRuntimeStatus::Unavailable; + addIssue(result, + LiteBridgeRuntimeIssue::ArtifactContractRejected, + input.artifactContract.error.empty() + ? "lite backend artifact contract is not ready" + : input.artifactContract.error); + result.summary = "lite_bridge_runtime=unavailable; reason=artifact_contract"; + return result; + } + + result.artifactContractAccepted = true; + if (result.config.abiVersion.empty()) { + result.config.abiVersion = liteBackendArtifactContractSupportedAbiVersion(); + } + if (result.config.artifactPath.empty()) { + result.config.artifactPath = input.artifactContract.resolverCandidate.artifactPath; + } + if (result.config.artifactSummary.empty()) { + result.config.artifactSummary = input.artifactContract.summary; + } + result.config.signatureRequiredForRelease = input.artifactContract.signatureRequiredForRelease; + result.config.signatureVerified = input.artifactContract.signatureVerified; + + if (options.requireImportedLinkMode && !input.artifactContract.importedLinkModeAccepted) { + result.status = LiteBridgeRuntimeStatus::Failed; + addIssue(result, + LiteBridgeRuntimeIssue::LinkModeNotImported, + "lite bridge runtime batch 1 requires the imported link contract"); + result.summary = "lite_bridge_runtime=blocked; reason=link_mode"; + return result; + } + + result.importedLinkModeAccepted = true; + result.configAccepted = true; + result.status = LiteBridgeRuntimeStatus::Configured; + + if (options.requireActivationRequest && !result.config.activationRequested) { + addIssue(result, + LiteBridgeRuntimeIssue::ActivationNotRequested, + "lite bridge runtime activation was not requested"); + result.summary = "lite_bridge_runtime=configured; activation=request_required"; + return result; + } + + result.activationAccepted = true; + + if (result.config.linkMode == LiteBridgeRuntimeLinkMode::DynamicLibrary) { + const int dynamicEvidenceSourceCount = + (input.useFakeDynamicLoaderResult ? 1 : 0) + + (input.useNoOpAdapterSeamResult ? 1 : 0) + + (input.useRealAdapterDisabledScaffoldResult ? 1 : 0); + if (dynamicEvidenceSourceCount > 1) { + result.status = LiteBridgeRuntimeStatus::Failed; + addIssue(result, + LiteBridgeRuntimeIssue::DynamicLibraryDeferred, + "dynamic-library binding requires exactly one loader evidence source"); + result.summary = "lite_bridge_runtime=blocked; reason=dynamic_library_evidence_conflict"; + return result; + } + if (dynamicEvidenceSourceCount == 0) { + result.status = LiteBridgeRuntimeStatus::Failed; + addIssue(result, + LiteBridgeRuntimeIssue::DynamicLibraryDeferred, + "dynamic-library runtime loading is deferred after imported-linked binding"); + result.summary = "lite_bridge_runtime=blocked; reason=dynamic_library_deferred"; + return result; + } + result.dynamicLibraryBindingRequested = true; + } else if (input.useFakeDynamicLoaderResult || + input.useNoOpAdapterSeamResult || + input.useRealAdapterDisabledScaffoldResult) { + result.status = LiteBridgeRuntimeStatus::Failed; + addIssue(result, + LiteBridgeRuntimeIssue::DynamicLibraryDeferred, + "dynamic-loader binding evidence requires dynamic-library link mode"); + result.summary = "lite_bridge_runtime=blocked; reason=dynamic_library_link_mode_required"; + return result; + } + + result.status = LiteBridgeRuntimeStatus::BindingSymbols; + + if (input.useFakeDynamicLoaderResult) { + const auto& loaderResult = input.fakeDynamicLoaderResult; + result.noDynamicLibraryLoaded = loaderResult.noPlatformDynamicLibraryLoaded; + result.noDynamicLibraryUnloaded = loaderResult.noPlatformDynamicLibraryUnloaded; + result.noPlatformSymbolResolution = loaderResult.noPlatformSymbolResolution; + result.noSdxlCalls = loaderResult.noSdxlCalls; + result.noBridgeCalls = loaderResult.noBridgeCalls; + result.noServerConnectivityChecked = loaderResult.noServerConnectivityChecked; + result.noWalletLifecycle = loaderResult.noWalletLifecycle; + result.noSyncStarted = loaderResult.noSyncStarted; + result.noSyncStatusPolled = loaderResult.noSyncStatusPolled; + result.noWorkerQueueEnqueue = loaderResult.noWorkerQueueEnqueue; + result.noWalletStateMutation = loaderResult.noWalletStateMutation; + result.noWalletPersistence = loaderResult.noWalletPersistence; + result.noSettingsPersistence = loaderResult.noSettingsPersistence; + result.noSendImportExportExecution = loaderResult.noSendImportExportExecution; + result.noArtifactMutation = loaderResult.noArtifactMutation; + result.dynamicLibraryHandle = loaderResult.handle; + result.dynamicLibraryHandleStored = loaderResult.handleStored; + result.dynamicLibraryHandlePresent = loaderResult.handlePresent && loaderResult.handle.present; + result.dynamicLibraryUnloadDeferred = loaderResult.dynamicLibraryUnloadDeferred; + + if (!loaderResult.fakeOnlyLoader || + !loaderResult.noPlatformDynamicLibraryLoaded || + !loaderResult.noPlatformDynamicLibraryUnloaded || + !loaderResult.noPlatformSymbolResolution) { + result.status = LiteBridgeRuntimeStatus::Failed; + addIssue(result, + LiteBridgeRuntimeIssue::DynamicLibraryLoadRequested, + "fake dynamic-loader binding must not use platform loader APIs"); + result.summary = "lite_bridge_runtime=blocked; reason=platform_dynamic_loader_requested"; + return result; + } + if (!loaderResult.symbolTableProduced) { + result.status = loaderResult.status == LiteBridgeRuntimeStatus::Unavailable + ? LiteBridgeRuntimeStatus::Unavailable + : LiteBridgeRuntimeStatus::Failed; + addIssue(result, + LiteBridgeRuntimeIssue::DynamicLibraryFakeLoaderFailed, + loaderResult.error.empty() + ? "fake dynamic-loader result did not produce a symbol table" + : loaderResult.error); + result.summary = "lite_bridge_runtime=blocked; reason=fake_dynamic_loader_failed"; + return result; + } + + result.symbolTable = loaderResult.symbolTable; + result.fakeDynamicLoaderResultAccepted = true; + } else if (input.useNoOpAdapterSeamResult) { + const auto& seamResult = input.noOpAdapterSeamResult; + result.noDynamicLibraryLoaded = seamResult.noRuntimePlatformDynamicLibraryLoaded; + result.noDynamicLibraryUnloaded = seamResult.noRuntimePlatformDynamicLibraryUnloaded; + result.noPlatformSymbolResolution = seamResult.noRuntimePlatformSymbolResolution; + result.noSdxlCalls = seamResult.noSdxlCalls; + result.noBridgeCalls = seamResult.noBridgeCalls; + result.noServerConnectivityChecked = seamResult.noServerConnectivityChecked; + result.noWalletLifecycle = seamResult.noWalletLifecycle; + result.noSyncStarted = seamResult.noSyncStarted; + result.noSyncStatusPolled = seamResult.noSyncStatusPolled; + result.noWorkerQueueEnqueue = seamResult.noWorkerQueueEnqueue; + result.noWalletStateMutation = seamResult.noWalletStateMutation; + result.noWalletPersistence = seamResult.noWalletPersistence; + result.noSettingsPersistence = seamResult.noSettingsPersistence; + result.noSendImportExportExecution = seamResult.noSendImportExportExecution; + result.noArtifactMutation = seamResult.noArtifactMutation; + result.noOpAdapterNoHandleProduced = seamResult.noHandleProduced; + result.noOpAdapterNoSymbolAddressProduced = seamResult.noSymbolAddressProduced; + result.noOpAdapterProductionLoaderDisabled = seamResult.productionLoaderDisabled; + + if (!seamResult.ok && + !seamResult.noOpAdapterSeamReady && + seamResult.status == LiteBridgeRuntimeStatus::Unavailable && + seamResult.error.empty() && + seamResult.summary.empty()) { + result.status = LiteBridgeRuntimeStatus::Unavailable; + addIssue(result, + LiteBridgeRuntimeIssue::DynamicLibraryNoOpAdapterSeamFailed, + "no-op dynamic-loader adapter seam result is not ready"); + result.summary = "lite_bridge_runtime=blocked; reason=noop_adapter_seam_required"; + return result; + } + + if (!result.noDynamicLibraryLoaded || + !result.noDynamicLibraryUnloaded || + !result.noPlatformSymbolResolution) { + result.status = LiteBridgeRuntimeStatus::Failed; + addIssue(result, + LiteBridgeRuntimeIssue::DynamicLibraryLoadRequested, + "no-op dynamic-loader binding evidence must not use platform loader APIs"); + result.summary = "lite_bridge_runtime=blocked; reason=platform_dynamic_loader_requested"; + return result; + } + + if (!result.noSdxlCalls || + !result.noBridgeCalls || + !result.noServerConnectivityChecked || + !result.noWalletLifecycle || + !result.noSyncStarted || + !result.noSyncStatusPolled || + !result.noWorkerQueueEnqueue || + !result.noWalletStateMutation || + !result.noWalletPersistence || + !result.noSettingsPersistence || + !result.noSendImportExportExecution || + !result.noArtifactMutation) { + result.status = LiteBridgeRuntimeStatus::Failed; + addIssue(result, + LiteBridgeRuntimeIssue::DynamicLibraryNoOpAdapterSeamFailed, + "no-op dynamic-loader binding evidence must not record wallet runtime behavior"); + result.summary = "lite_bridge_runtime=blocked; reason=noop_adapter_runtime_action_recorded"; + return result; + } + + if (!result.noOpAdapterNoHandleProduced || + !result.noOpAdapterNoSymbolAddressProduced || + !result.noOpAdapterProductionLoaderDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addIssue(result, + LiteBridgeRuntimeIssue::DynamicLibraryNoOpAdapterSeamFailed, + "no-op dynamic-loader binding evidence must not produce handles or symbol addresses"); + result.summary = "lite_bridge_runtime=blocked; reason=noop_adapter_evidence_unsafe"; + return result; + } + + if (!seamResult.ok || + !seamResult.noOpAdapterSeamReady || + seamResult.status != LiteBridgeRuntimeStatus::Ready) { + result.status = seamResult.status == LiteBridgeRuntimeStatus::Unavailable + ? LiteBridgeRuntimeStatus::Unavailable + : LiteBridgeRuntimeStatus::Failed; + addIssue(result, + LiteBridgeRuntimeIssue::DynamicLibraryNoOpAdapterSeamFailed, + seamResult.error.empty() + ? "no-op dynamic-loader adapter seam result is not ready" + : seamResult.error); + result.summary = "lite_bridge_runtime=blocked; reason=noop_adapter_seam_required"; + return result; + } + + result.noOpAdapterSeamResultAccepted = true; + result.noOpAdapterBindingEvidenceReady = true; + result.status = LiteBridgeRuntimeStatus::Configured; + addIssue(result, + LiteBridgeRuntimeIssue::DynamicLibraryDeferred, + "no-op dynamic-loader adapter binding evidence accepted; symbol binding remains disabled"); + result.summary = "lite_bridge_runtime=configured; link_mode=dynamic-library; loader=noop-adapter; symbols=disabled"; + return result; + } else if (input.useRealAdapterDisabledScaffoldResult) { + const auto& scaffoldResult = input.realAdapterDisabledScaffoldResult; + result.noDynamicLibraryLoaded = scaffoldResult.noRuntimePlatformDynamicLibraryLoaded; + result.noDynamicLibraryUnloaded = scaffoldResult.noRuntimePlatformDynamicLibraryUnloaded; + result.noPlatformSymbolResolution = scaffoldResult.noRuntimePlatformSymbolResolution; + result.noSdxlCalls = scaffoldResult.noSdxlCalls; + result.noBridgeCalls = scaffoldResult.noBridgeCalls; + result.noServerConnectivityChecked = scaffoldResult.noServerConnectivityChecked; + result.noWalletLifecycle = scaffoldResult.noWalletLifecycle; + result.noSyncStarted = scaffoldResult.noSyncStarted; + result.noSyncStatusPolled = scaffoldResult.noSyncStatusPolled; + result.noWorkerQueueEnqueue = scaffoldResult.noWorkerQueueEnqueue; + result.noWalletStateMutation = scaffoldResult.noWalletStateMutation; + result.noWalletPersistence = scaffoldResult.noWalletPersistence; + result.noSettingsPersistence = scaffoldResult.noSettingsPersistence; + result.noSendImportExportExecution = scaffoldResult.noSendImportExportExecution; + result.noArtifactMutation = scaffoldResult.noArtifactMutation; + result.realAdapterDisabledScaffoldNoHandleProduced = scaffoldResult.noHandleProduced; + result.realAdapterDisabledScaffoldNoHandleReleased = scaffoldResult.noHandleReleased; + result.realAdapterDisabledScaffoldNoSymbolAddressProduced = scaffoldResult.noSymbolAddressProduced; + result.realAdapterDisabledScaffoldProductionLoaderDisabled = scaffoldResult.productionLoaderDisabled; + result.realAdapterDisabledScaffoldExecutionDisabled = scaffoldResult.realAdapterExecutionDisabled; + + if (!scaffoldResult.ok && + !scaffoldResult.realAdapterDisabledScaffoldReady && + scaffoldResult.status == LiteBridgeRuntimeStatus::Unavailable && + scaffoldResult.error.empty() && + scaffoldResult.summary.empty()) { + result.status = LiteBridgeRuntimeStatus::Unavailable; + addIssue(result, + LiteBridgeRuntimeIssue::DynamicLibraryRealAdapterDisabledScaffoldFailed, + "disabled real-adapter scaffold result is not ready"); + result.summary = "lite_bridge_runtime=blocked; reason=real_adapter_disabled_scaffold_required"; + return result; + } + + if (!result.noDynamicLibraryLoaded || + !result.noDynamicLibraryUnloaded || + !result.noPlatformSymbolResolution) { + result.status = LiteBridgeRuntimeStatus::Failed; + addIssue(result, + LiteBridgeRuntimeIssue::DynamicLibraryLoadRequested, + "disabled real-adapter scaffold binding evidence must not use platform loader APIs"); + result.summary = "lite_bridge_runtime=blocked; reason=platform_dynamic_loader_requested"; + return result; + } + + if (!result.noSdxlCalls || + !result.noBridgeCalls || + !result.noServerConnectivityChecked || + !result.noWalletLifecycle || + !result.noSyncStarted || + !result.noSyncStatusPolled || + !result.noWorkerQueueEnqueue || + !result.noWalletStateMutation || + !result.noWalletPersistence || + !result.noSettingsPersistence || + !result.noSendImportExportExecution || + !result.noArtifactMutation) { + result.status = LiteBridgeRuntimeStatus::Failed; + addIssue(result, + LiteBridgeRuntimeIssue::DynamicLibraryRealAdapterDisabledScaffoldFailed, + "disabled real-adapter scaffold binding evidence must not record wallet runtime behavior"); + result.summary = "lite_bridge_runtime=blocked; reason=real_adapter_disabled_scaffold_runtime_action_recorded"; + return result; + } + + if (!result.realAdapterDisabledScaffoldNoHandleProduced || + !result.realAdapterDisabledScaffoldNoHandleReleased || + !result.realAdapterDisabledScaffoldNoSymbolAddressProduced || + !result.realAdapterDisabledScaffoldProductionLoaderDisabled || + !result.realAdapterDisabledScaffoldExecutionDisabled) { + result.status = LiteBridgeRuntimeStatus::Failed; + addIssue(result, + LiteBridgeRuntimeIssue::DynamicLibraryRealAdapterDisabledScaffoldFailed, + "disabled real-adapter scaffold binding evidence must not produce handles, release handles, or produce symbol addresses"); + result.summary = "lite_bridge_runtime=blocked; reason=real_adapter_disabled_scaffold_evidence_unsafe"; + return result; + } + + if (!scaffoldResult.ok || + !scaffoldResult.realAdapterDisabledScaffoldReady || + scaffoldResult.status != LiteBridgeRuntimeStatus::Ready) { + result.status = scaffoldResult.status == LiteBridgeRuntimeStatus::Unavailable + ? LiteBridgeRuntimeStatus::Unavailable + : LiteBridgeRuntimeStatus::Failed; + addIssue(result, + LiteBridgeRuntimeIssue::DynamicLibraryRealAdapterDisabledScaffoldFailed, + scaffoldResult.error.empty() + ? "disabled real-adapter scaffold result is not ready" + : scaffoldResult.error); + result.summary = "lite_bridge_runtime=blocked; reason=real_adapter_disabled_scaffold_required"; + return result; + } + + result.realAdapterDisabledScaffoldResultAccepted = true; + result.realAdapterDisabledScaffoldBindingEvidenceReady = true; + result.status = LiteBridgeRuntimeStatus::Configured; + addIssue(result, + LiteBridgeRuntimeIssue::DynamicLibraryDeferred, + "disabled real-adapter scaffold binding evidence accepted; symbol binding remains disabled"); + result.summary = "lite_bridge_runtime=configured; link_mode=dynamic-library; loader=real-adapter-disabled-scaffold; symbols=disabled"; + return result; + } else if (input.useProvidedSymbolTable) { + result.symbolTable = input.symbolTable; + result.providedSymbolTableAccepted = true; + } else if (input.bindImportedLinkedSymbols) { + result.symbolTable = liteBridgeRuntimeImportedLinkedSymbolTable(); + result.importedLinkedBindingRequested = true; + } else { + result.status = LiteBridgeRuntimeStatus::Unavailable; + addIssue(result, + LiteBridgeRuntimeIssue::SymbolTableMissing, + "no lite bridge runtime symbol table was provided or requested"); + result.summary = "lite_bridge_runtime=unavailable; reason=symbol_table_missing"; + return result; + } + + result.symbolTableProduced = true; + result.requiredSymbolCount = result.symbolTable.requiredSymbolCount; + result.availableSymbolCount = result.symbolTable.availableSymbolCount; + + if (result.importedLinkedBindingRequested && !tableHasAnySymbol(result.symbolTable)) { + result.status = LiteBridgeRuntimeStatus::Unavailable; + collectMissingSymbols(result.symbolTable, result.missingSymbols); + addIssue(result, + LiteBridgeRuntimeIssue::ImportedBackendNotLinked, + "lite backend imported symbols are not linked into this build"); + result.summary = "lite_bridge_runtime=unavailable; reason=imported_backend_not_linked"; + return result; + } + + collectMissingSymbols(result.symbolTable, result.missingSymbols); + if (options.requireCompleteSymbolTable && !result.missingSymbols.empty()) { + result.status = LiteBridgeRuntimeStatus::Failed; + addIssue(result, + LiteBridgeRuntimeIssue::RequiredSymbolMissing, + "lite bridge runtime symbol table is missing required symbols"); + result.summary = "lite_bridge_runtime=blocked; reason=missing_symbols"; + return result; + } + + result.symbolTableReady = true; + result.runtimeReady = true; + result.status = LiteBridgeRuntimeStatus::Ready; + result.ok = true; + result.summary = result.dynamicLibraryBindingRequested + ? "lite_bridge_runtime=ready; link_mode=dynamic-library; loader=fake; symbols=ready" + : "lite_bridge_runtime=ready; link_mode=imported-linked; symbols=ready"; + return result; +} + +} // namespace dragonx::wallet \ No newline at end of file diff --git a/src/wallet/lite_bridge_runtime.h b/src/wallet/lite_bridge_runtime.h new file mode 100644 index 0000000..e15439f --- /dev/null +++ b/src/wallet/lite_bridge_runtime.h @@ -0,0 +1,7268 @@ +#pragma once + +#include "lite_backend_artifact_contract.h" +#include "lite_client_bridge.h" + +#include +#include +#include +#include + +namespace dragonx::wallet { + +struct LiteBridgeRuntimeTeardownState; + +enum class LiteBridgeRuntimeLinkMode { + ImportedLinked, + DynamicLibrary, +}; + +enum class LiteBridgeRuntimeStatus { + Unavailable, + Configured, + BindingSymbols, + Ready, + Failed, + ShuttingDown, + Shutdown, +}; + +enum class LiteBridgeRuntimeDryDispatchOperation { + WalletExists, + CheckServerOnline, + Execute, + InitializeNew, + InitializeExisting, + InitializeNewFromPhrase, + Shutdown, +}; + +enum class LiteBridgeRuntimeIssue { + ArtifactContractRejected, + ActivationNotRequested, + LinkModeNotImported, + DynamicLibraryDeferred, + DynamicLibraryFakeLoaderFailed, + DynamicLibraryNoOpAdapterSeamFailed, + DynamicLibraryRealAdapterDisabledScaffoldFailed, + ImportedBackendNotLinked, + SymbolTableMissing, + RequiredSymbolMissing, + ArtifactMutationRequested, + DynamicLibraryLoadRequested, + DynamicLibraryUnloadRequested, + SymbolResolutionRequested, + SdxlCallRequested, + BridgeCallRequested, + ServerConnectivityCheckRequested, + WalletLifecycleRequested, + SyncRequested, + SyncStatusPollingRequested, + WorkerQueueRequested, + WalletStateMutationRequested, + WalletPersistenceRequested, + SettingsWriteRequested, + SendImportExportRequested, +}; + +struct LiteBridgeRuntimeConfig { + bool activationRequested = false; + LiteBridgeRuntimeLinkMode linkMode = LiteBridgeRuntimeLinkMode::ImportedLinked; + std::string abiVersion; + std::string artifactPath; + std::string artifactSummary; + bool signatureRequiredForRelease = false; + bool signatureVerified = false; + unsigned int defaultTimeoutMs = 30000; +}; + +struct LiteBridgeRuntimeSymbolBinding { + std::string logicalName; + std::string abiName; + bool required = true; + bool available = false; + std::string source; +}; + +struct LiteBridgeRuntimeSymbolTable { + LiteClientBridgeApi api; + std::string source; + std::vector bindings; + std::size_t requiredSymbolCount = 0; + std::size_t availableSymbolCount = 0; +}; + +using LiteBridgeRuntimeDynamicLibraryUnloadFn = void (*)(const char* handleLabel); + +struct LiteBridgeRuntimeDynamicLibraryHandle { + bool present = false; + bool fakeHandle = true; + std::string artifactPath; + std::string displayPath; + std::string platform; + std::string handleLabel; + LiteBridgeRuntimeDynamicLibraryUnloadFn unload = nullptr; +}; + +struct LiteBridgeRuntimeFakeDynamicLoaderInput { + bool artifactPathReviewed = false; + bool platformLoaderStrategyReady = false; + bool loadSequenceReady = false; + bool unloadSequenceReady = false; + bool handleStoreReady = false; + bool symbolLookupReady = false; + bool fakeHandleProvided = false; + bool failLoad = false; + std::string artifactPath; + std::string displayPath; + std::string platform; + std::string handleLabel; + std::string source = "fake-dynamic-library"; + std::string loadError; + LiteClientBridgeApi api; + LiteBridgeRuntimeDynamicLibraryUnloadFn unload = nullptr; +}; + +struct LiteBridgeRuntimeFakeDynamicLoaderResult { + bool ok = false; + bool fakeOnlyLoader = true; + bool fakeLoadAttempted = false; + bool fakeSymbolLookupAttempted = false; + bool fakeUnloadAttempted = false; + bool noPlatformDynamicLibraryLoaded = true; + bool noPlatformDynamicLibraryUnloaded = true; + bool noPlatformSymbolResolution = true; + bool noBridgeCalls = true; + bool noSdxlCalls = true; + bool noServerConnectivityChecked = true; + bool noWalletLifecycle = true; + bool noSyncStarted = true; + bool noSyncStatusPolled = true; + bool noWorkerQueueEnqueue = true; + bool noWalletStateMutation = true; + bool noWalletPersistence = true; + bool noSettingsPersistence = true; + bool noSendImportExportExecution = true; + bool noArtifactMutation = true; + + bool artifactPathReviewed = false; + bool platformLoaderStrategyReady = false; + bool loadSequenceReady = false; + bool unloadSequenceReady = false; + bool handleStoreReady = false; + bool symbolLookupReady = false; + bool handleStored = false; + bool handlePresent = false; + bool dynamicLibraryUnloadDeferred = true; + bool symbolTableProduced = false; + bool symbolTableReady = false; + bool runtimeReady = false; + + std::size_t requiredSymbolCount = 0; + std::size_t availableSymbolCount = 0; + LiteBridgeRuntimeStatus status = LiteBridgeRuntimeStatus::Unavailable; + LiteBridgeRuntimeDynamicLibraryHandle handle; + LiteBridgeRuntimeSymbolTable symbolTable; + std::vector missingSymbols; + std::string error; + std::string summary; +}; + +struct LiteBridgeRuntimePlatformLoaderReviewInput { + std::string platform; + std::string sharedArtifactPath; + std::string sharedArtifactSha256; + bool sharedArtifactEvidenceReviewed = false; + bool sharedArtifactIsSharedLibrary = false; + bool manifestRecordsSharedLibrary = false; + bool artifactSha256Reviewed = false; + bool requiredSymbolEvidenceReviewed = false; + bool requiredSymbolsPresent = false; + std::size_t requiredSymbolCount = 0; + bool linuxAdapterAvailable = false; + bool windowsAdapterAvailable = false; + bool macosDeferredByOperator = true; + bool loaderAdapterSeamReviewed = false; + bool unloadAdapterSeamReviewed = false; + bool symbolLookupAdapterSeamReviewed = false; + bool handleOwnershipReviewed = false; + bool teardownOrderingReviewed = false; + bool stringOwnershipReused = false; + bool fakeDynamicBindingGreen = false; + + bool platformLoadAttempted = false; + bool platformUnloadAttempted = false; + bool platformSymbolResolutionAttempted = false; + bool sdxlCallRequested = false; + bool bridgeCallRequested = false; + bool serverConnectivityCheckRequested = false; + bool walletLifecycleRequested = false; + bool syncRequested = false; + bool syncStatusPollingRequested = false; + bool workerQueueRequested = false; + bool walletStateMutationRequested = false; + bool walletPersistenceRequested = false; + bool settingsWriteRequested = false; + bool sendImportExportRequested = false; + bool artifactMutationRequested = false; +}; + +struct LiteBridgeRuntimePlatformLoaderReviewResult { + bool ok = false; + bool noPlatformDynamicLibraryLoaded = true; + bool noPlatformDynamicLibraryUnloaded = true; + bool noPlatformSymbolResolution = true; + bool noSdxlCalls = true; + bool noBridgeCalls = true; + bool noServerConnectivityChecked = true; + bool noWalletLifecycle = true; + bool noSyncStarted = true; + bool noSyncStatusPolled = true; + bool noWorkerQueueEnqueue = true; + bool noWalletStateMutation = true; + bool noWalletPersistence = true; + bool noSettingsPersistence = true; + bool noSendImportExportExecution = true; + bool noArtifactMutation = true; + + bool platformAccepted = false; + bool linuxPlatformAccepted = false; + bool windowsPlatformAccepted = false; + bool macosDeferred = false; + bool sharedArtifactEvidenceAccepted = false; + bool requiredSymbolEvidenceAccepted = false; + bool loaderAdapterSeamAccepted = false; + bool unloadAdapterSeamAccepted = false; + bool symbolLookupAdapterSeamAccepted = false; + bool handleOwnershipAccepted = false; + bool teardownOrderingAccepted = false; + bool stringOwnershipReuseAccepted = false; + bool fakeDynamicBindingAccepted = false; + bool platformLoaderReviewReady = false; + + std::size_t requiredSymbolCount = 0; + LiteBridgeRuntimeStatus status = LiteBridgeRuntimeStatus::Unavailable; + std::string platform; + std::vector issues; + std::string error; + std::string summary; +}; + +struct LiteBridgeRuntimeDynamicLoaderSmokeGateInput { + LiteBridgeRuntimePlatformLoaderReviewResult platformLoaderReview; + std::string platform; + std::string smokeArtifactPath; + std::string smokeArtifactSha256; + std::string smokeRunId; + bool platformLoaderReviewAccepted = false; + bool disposableSharedArtifactReviewed = false; + bool disposableSharedArtifactIsSharedLibrary = false; + bool disposableArtifactSha256Reviewed = false; + bool disposableArtifactNotReleaseArtifact = false; + bool smokeEnvironmentReviewed = false; + bool smokePlanReviewed = false; + bool loadOnlySmokeEvidenceReviewed = false; + bool unloadOnlySmokeEvidenceReviewed = false; + bool unloadObservedAfterLoad = false; + bool handleLifecycleEvidenceReviewed = false; + bool cleanupEvidenceReviewed = false; + bool noSymbolResolutionObserved = true; + bool noBridgeCallsObserved = true; + bool noSdxlCallsObserved = true; + bool noServerConnectivityObserved = true; + bool noWalletLifecycleObserved = true; + bool noSyncObserved = true; + bool noSyncStatusPollingObserved = true; + bool noWorkerQueueObserved = true; + bool noWalletStateMutationObserved = true; + bool noWalletPersistenceObserved = true; + bool noSettingsPersistenceObserved = true; + bool noSendImportExportObserved = true; + bool noArtifactMutationObserved = true; + bool macosDeferredByOperator = true; + + bool runtimePlatformLoadAttempted = false; + bool runtimePlatformUnloadAttempted = false; + bool runtimePlatformSymbolResolutionAttempted = false; + bool sdxlCallRequested = false; + bool bridgeCallRequested = false; + bool serverConnectivityCheckRequested = false; + bool walletLifecycleRequested = false; + bool syncRequested = false; + bool syncStatusPollingRequested = false; + bool workerQueueRequested = false; + bool walletStateMutationRequested = false; + bool walletPersistenceRequested = false; + bool settingsWriteRequested = false; + bool sendImportExportRequested = false; + bool artifactMutationRequested = false; +}; + +struct LiteBridgeRuntimeDynamicLoaderSmokeGateResult { + bool ok = false; + bool noRuntimePlatformDynamicLibraryLoaded = true; + bool noRuntimePlatformDynamicLibraryUnloaded = true; + bool noRuntimePlatformSymbolResolution = true; + bool noSdxlCalls = true; + bool noBridgeCalls = true; + bool noServerConnectivityChecked = true; + bool noWalletLifecycle = true; + bool noSyncStarted = true; + bool noSyncStatusPolled = true; + bool noWorkerQueueEnqueue = true; + bool noWalletStateMutation = true; + bool noWalletPersistence = true; + bool noSettingsPersistence = true; + bool noSendImportExportExecution = true; + bool noArtifactMutation = true; + + bool platformAccepted = false; + bool linuxPlatformAccepted = false; + bool windowsPlatformAccepted = false; + bool macosDeferred = false; + bool platformLoaderReviewAccepted = false; + bool disposableSmokeArtifactAccepted = false; + bool smokeEnvironmentAccepted = false; + bool smokePlanAccepted = false; + bool loadOnlySmokeEvidenceAccepted = false; + bool unloadOnlySmokeEvidenceAccepted = false; + bool handleLifecycleEvidenceAccepted = false; + bool cleanupEvidenceAccepted = false; + bool symbolResolutionBlocked = false; + bool dynamicLoaderSmokeGateReady = false; + + LiteBridgeRuntimeStatus status = LiteBridgeRuntimeStatus::Unavailable; + std::string platform; + std::vector issues; + std::string error; + std::string summary; +}; + +struct LiteBridgeRuntimeSharedArtifactSmokeEvidenceAcquisitionInput { + LiteBridgeRuntimeDynamicLoaderSmokeGateResult dynamicLoaderSmokeGate; + std::string platform; + std::string releaseBuilderId; + std::string smokeRunId; + std::string disposableWorkspacePath; + std::string smokeArtifactPath; + std::string smokeArtifactSha256; + std::string manifestPath; + std::string manifestSha256; + std::string loadUnloadRecordPath; + std::string cleanupRecordPath; + bool dynamicLoaderSmokeGateAccepted = false; + bool releaseBuilderReviewed = false; + bool linuxReleaseBuilderAvailable = false; + bool windowsReleaseBuilderAvailable = false; + bool disposableWorkspaceReviewed = false; + bool disposableWorkspaceIsIsolated = false; + bool sharedArtifactCaptured = false; + bool sharedArtifactIsSharedLibrary = false; + bool sharedArtifactSha256Captured = false; + bool manifestCaptured = false; + bool manifestSha256Captured = false; + bool manifestRecordsPlatform = false; + bool manifestRecordsBuilder = false; + bool manifestRecordsSmokeRunId = false; + bool manifestRecordsArtifactPath = false; + bool manifestRecordsArtifactSha256 = false; + bool manifestRecordsDisposableArtifact = false; + bool loadUnloadRecordCaptured = false; + bool loadRecordCaptured = false; + bool unloadRecordCaptured = false; + bool unloadRecordedAfterLoad = false; + bool loadUnloadRecordIsLoadUnloadOnly = false; + bool handleLifecycleRecordCaptured = false; + bool cleanupRecordCaptured = false; + bool cleanupRecordShowsHandleReleased = false; + bool cleanupRecordShowsArtifactRemoved = false; + bool cleanupRecordShowsWorkspaceRemoved = false; + bool noSymbolResolutionRecord = true; + bool noBridgeCallsRecord = true; + bool noSdxlCallsRecord = true; + bool noServerConnectivityRecord = true; + bool noWalletLifecycleRecord = true; + bool noSyncRecord = true; + bool noSyncStatusPollingRecord = true; + bool noWorkerQueueRecord = true; + bool noWalletStateMutationRecord = true; + bool noWalletPersistenceRecord = true; + bool noSettingsPersistenceRecord = true; + bool noSendImportExportRecord = true; + bool noArtifactMutationRecord = true; + bool macosDeferredByOperator = true; + + bool runtimePlatformLoadAttempted = false; + bool runtimePlatformUnloadAttempted = false; + bool runtimePlatformSymbolResolutionAttempted = false; + bool sdxlCallRequested = false; + bool bridgeCallRequested = false; + bool serverConnectivityCheckRequested = false; + bool walletLifecycleRequested = false; + bool syncRequested = false; + bool syncStatusPollingRequested = false; + bool workerQueueRequested = false; + bool walletStateMutationRequested = false; + bool walletPersistenceRequested = false; + bool settingsWriteRequested = false; + bool sendImportExportRequested = false; + bool artifactMutationRequested = false; +}; + +struct LiteBridgeRuntimeSharedArtifactSmokeEvidenceAcquisitionResult { + bool ok = false; + bool noRuntimePlatformDynamicLibraryLoaded = true; + bool noRuntimePlatformDynamicLibraryUnloaded = true; + bool noRuntimePlatformSymbolResolution = true; + bool noSymbolResolutionRecord = true; + bool noSdxlCalls = true; + bool noBridgeCalls = true; + bool noServerConnectivityChecked = true; + bool noWalletLifecycle = true; + bool noSyncStarted = true; + bool noSyncStatusPolled = true; + bool noWorkerQueueEnqueue = true; + bool noWalletStateMutation = true; + bool noWalletPersistence = true; + bool noSettingsPersistence = true; + bool noSendImportExportExecution = true; + bool noArtifactMutation = true; + + bool platformAccepted = false; + bool linuxPlatformAccepted = false; + bool windowsPlatformAccepted = false; + bool macosDeferred = false; + bool dynamicLoaderSmokeGateAccepted = false; + bool releaseBuilderAccepted = false; + bool disposableWorkspaceAccepted = false; + bool sharedArtifactRecordAccepted = false; + bool manifestRecordAccepted = false; + bool loadUnloadRecordAccepted = false; + bool handleLifecycleRecordAccepted = false; + bool cleanupProofAccepted = false; + bool smokeEvidenceAcquisitionReady = false; + + LiteBridgeRuntimeStatus status = LiteBridgeRuntimeStatus::Unavailable; + std::string platform; + std::string smokeRunId; + std::string manifestPath; + std::string loadUnloadRecordPath; + std::string cleanupRecordPath; + std::vector issues; + std::string error; + std::string summary; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderAdapterContractInput { + LiteBridgeRuntimeSharedArtifactSmokeEvidenceAcquisitionResult smokeEvidenceAcquisition; + std::string platform; + std::string adapterName; + bool smokeEvidenceAcquisitionAccepted = false; + bool adapterContractReviewed = false; + bool linuxAdapterContractAvailable = false; + bool windowsAdapterContractAvailable = false; + bool loadAdapterSignatureDefined = false; + bool unloadAdapterSignatureDefined = false; + bool symbolLookupAdapterSignatureDefined = false; + bool adapterUsesReviewedArtifactPath = false; + bool adapterReturnsOpaqueHandle = false; + bool adapterErrorMappingDefined = false; + bool adapterPathEncodingDefined = false; + bool handleOwnershipContractDefined = false; + bool unloadAfterRuntimeShutdownDefined = false; + bool unloadAfterOwnedStringsReleasedDefined = false; + bool symbolLookupResultStaysInsideRuntime = false; + bool rawSymbolPointerEscapeBlocked = false; + bool requiredSymbolMapDefined = false; + std::size_t requiredSymbolCount = 0; + bool symbolTableReuseDefined = false; + bool stringOwnershipReused = false; + bool fakeDynamicBindingStillRequired = false; + bool runtimePlatformImplementationDeferred = true; + bool productionLoaderExecutionDisabled = true; + bool macosDeferredByOperator = true; + + bool runtimePlatformLoadAttempted = false; + bool runtimePlatformUnloadAttempted = false; + bool runtimePlatformSymbolResolutionAttempted = false; + bool sdxlCallRequested = false; + bool bridgeCallRequested = false; + bool serverConnectivityCheckRequested = false; + bool walletLifecycleRequested = false; + bool syncRequested = false; + bool syncStatusPollingRequested = false; + bool workerQueueRequested = false; + bool walletStateMutationRequested = false; + bool walletPersistenceRequested = false; + bool settingsWriteRequested = false; + bool sendImportExportRequested = false; + bool artifactMutationRequested = false; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderAdapterContractResult { + bool ok = false; + bool noRuntimePlatformDynamicLibraryLoaded = true; + bool noRuntimePlatformDynamicLibraryUnloaded = true; + bool noRuntimePlatformSymbolResolution = true; + bool noSdxlCalls = true; + bool noBridgeCalls = true; + bool noServerConnectivityChecked = true; + bool noWalletLifecycle = true; + bool noSyncStarted = true; + bool noSyncStatusPolled = true; + bool noWorkerQueueEnqueue = true; + bool noWalletStateMutation = true; + bool noWalletPersistence = true; + bool noSettingsPersistence = true; + bool noSendImportExportExecution = true; + bool noArtifactMutation = true; + + bool platformAccepted = false; + bool linuxPlatformAccepted = false; + bool windowsPlatformAccepted = false; + bool macosDeferred = false; + bool smokeEvidenceAcquisitionAccepted = false; + bool adapterContractAccepted = false; + bool loadAdapterContractAccepted = false; + bool unloadAdapterContractAccepted = false; + bool symbolLookupAdapterContractAccepted = false; + bool pathAndErrorContractAccepted = false; + bool handleOwnershipContractAccepted = false; + bool symbolTableContractAccepted = false; + bool runtimeDeferralAccepted = false; + bool adapterContractReady = false; + + std::size_t requiredSymbolCount = 0; + LiteBridgeRuntimeStatus status = LiteBridgeRuntimeStatus::Unavailable; + std::string platform; + std::string adapterName; + std::vector issues; + std::string error; + std::string summary; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderAdapterCallResult { + bool ok = false; + bool disabled = true; + bool noPlatformDynamicLibraryLoaded = true; + bool noPlatformDynamicLibraryUnloaded = true; + bool noPlatformSymbolResolution = true; + bool noBridgeCalls = true; + bool noSdxlCalls = true; + bool noServerConnectivityChecked = true; + bool noWalletLifecycle = true; + bool noSyncStarted = true; + bool noSyncStatusPolled = true; + bool noWorkerQueueEnqueue = true; + bool noWalletStateMutation = true; + bool noWalletPersistence = true; + bool noSettingsPersistence = true; + bool noSendImportExportExecution = true; + bool noArtifactMutation = true; + bool handleProduced = false; + bool handleReleased = false; + bool symbolAddressProduced = false; + std::string error; + std::string summary; +}; + +using LiteBridgeRuntimePlatformDynamicLoaderAdapterLoadFn = + LiteBridgeRuntimePlatformDynamicLoaderAdapterCallResult (*)(const char* platform, + const char* artifactPath); +using LiteBridgeRuntimePlatformDynamicLoaderAdapterUnloadFn = + LiteBridgeRuntimePlatformDynamicLoaderAdapterCallResult (*)(const char* platform, + const char* handleLabel); +using LiteBridgeRuntimePlatformDynamicLoaderAdapterSymbolLookupFn = + LiteBridgeRuntimePlatformDynamicLoaderAdapterCallResult (*)(const char* platform, + const char* symbolName); + +struct LiteBridgeRuntimePlatformDynamicLoaderAdapter { + std::string name; + std::string platform; + bool noOpAdapter = true; + bool productionLoader = false; + LiteBridgeRuntimePlatformDynamicLoaderAdapterLoadFn load = nullptr; + LiteBridgeRuntimePlatformDynamicLoaderAdapterUnloadFn unload = nullptr; + LiteBridgeRuntimePlatformDynamicLoaderAdapterSymbolLookupFn symbolLookup = nullptr; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderNoOpAdapterSeamInput { + LiteBridgeRuntimePlatformDynamicLoaderAdapterContractResult adapterContract; + LiteBridgeRuntimePlatformDynamicLoaderAdapter adapter; + std::string platform; + std::string artifactPath; + std::string handleLabel; + std::string symbolName; + bool adapterContractAccepted = false; + bool noOpAdapterRegistered = false; + bool runtimeOwnsAdapter = false; + bool loadProbeRequested = false; + bool unloadProbeRequested = false; + bool symbolLookupProbeRequested = false; + bool productionLoaderExecutionDisabled = true; + bool macosDeferredByOperator = true; + + bool runtimePlatformLoadAttempted = false; + bool runtimePlatformUnloadAttempted = false; + bool runtimePlatformSymbolResolutionAttempted = false; + bool sdxlCallRequested = false; + bool bridgeCallRequested = false; + bool serverConnectivityCheckRequested = false; + bool walletLifecycleRequested = false; + bool syncRequested = false; + bool syncStatusPollingRequested = false; + bool workerQueueRequested = false; + bool walletStateMutationRequested = false; + bool walletPersistenceRequested = false; + bool settingsWriteRequested = false; + bool sendImportExportRequested = false; + bool artifactMutationRequested = false; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderNoOpAdapterSeamResult { + bool ok = false; + bool noRuntimePlatformDynamicLibraryLoaded = true; + bool noRuntimePlatformDynamicLibraryUnloaded = true; + bool noRuntimePlatformSymbolResolution = true; + bool noSdxlCalls = true; + bool noBridgeCalls = true; + bool noServerConnectivityChecked = true; + bool noWalletLifecycle = true; + bool noSyncStarted = true; + bool noSyncStatusPolled = true; + bool noWorkerQueueEnqueue = true; + bool noWalletStateMutation = true; + bool noWalletPersistence = true; + bool noSettingsPersistence = true; + bool noSendImportExportExecution = true; + bool noArtifactMutation = true; + + bool platformAccepted = false; + bool linuxPlatformAccepted = false; + bool windowsPlatformAccepted = false; + bool macosDeferred = false; + bool adapterContractAccepted = false; + bool noOpAdapterAccepted = false; + bool runtimeAdapterOwnershipAccepted = false; + bool loadProbeAccepted = false; + bool unloadProbeAccepted = false; + bool symbolLookupProbeAccepted = false; + bool noHandleProduced = true; + bool noSymbolAddressProduced = true; + bool productionLoaderDisabled = false; + bool noOpAdapterSeamReady = false; + + LiteBridgeRuntimeStatus status = LiteBridgeRuntimeStatus::Unavailable; + std::string platform; + std::string adapterName; + std::vector issues; + std::string error; + std::string summary; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterDisabledScaffoldResult { + bool ok = false; + bool noRuntimePlatformDynamicLibraryLoaded = true; + bool noRuntimePlatformDynamicLibraryUnloaded = true; + bool noRuntimePlatformSymbolResolution = true; + bool noSdxlCalls = true; + bool noBridgeCalls = true; + bool noServerConnectivityChecked = true; + bool noWalletLifecycle = true; + bool noSyncStarted = true; + bool noSyncStatusPolled = true; + bool noWorkerQueueEnqueue = true; + bool noWalletStateMutation = true; + bool noWalletPersistence = true; + bool noSettingsPersistence = true; + bool noSendImportExportExecution = true; + bool noArtifactMutation = true; + + bool platformAccepted = false; + bool linuxPlatformAccepted = false; + bool windowsPlatformAccepted = false; + bool macosDeferred = false; + bool implementationReviewAccepted = false; + bool realAdapterAccepted = false; + bool runtimeAdapterOwnershipAccepted = false; + bool loadScaffoldProbeAccepted = false; + bool unloadScaffoldProbeAccepted = false; + bool symbolLookupScaffoldProbeAccepted = false; + bool noHandleProduced = true; + bool noHandleReleased = true; + bool noSymbolAddressProduced = true; + bool productionLoaderDisabled = false; + bool realAdapterExecutionDisabled = false; + bool realAdapterDisabledScaffoldReady = false; + + LiteBridgeRuntimeStatus status = LiteBridgeRuntimeStatus::Unavailable; + std::string platform; + std::string adapterName; + std::vector issues; + std::string error; + std::string summary; +}; + +struct LiteBridgeRuntimeBindingInput { + LiteBackendArtifactContractResult artifactContract; + LiteBridgeRuntimeConfig config; + LiteBridgeRuntimeSymbolTable symbolTable; + LiteBridgeRuntimeFakeDynamicLoaderResult fakeDynamicLoaderResult; + LiteBridgeRuntimePlatformDynamicLoaderNoOpAdapterSeamResult noOpAdapterSeamResult; + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterDisabledScaffoldResult realAdapterDisabledScaffoldResult; + bool useProvidedSymbolTable = false; + bool bindImportedLinkedSymbols = false; + bool useFakeDynamicLoaderResult = false; + bool useNoOpAdapterSeamResult = false; + bool useRealAdapterDisabledScaffoldResult = false; + + bool artifactMutationRequested = false; + bool dynamicLibraryLoadRequested = false; + bool dynamicLibraryUnloadRequested = false; + bool symbolResolutionRequested = false; + bool sdxlCallRequested = false; + bool bridgeCallRequested = false; + bool serverConnectivityCheckRequested = false; + bool walletLifecycleRequested = false; + bool syncRequested = false; + bool syncStatusPollingRequested = false; + bool workerQueueRequested = false; + bool walletStateMutationRequested = false; + bool walletPersistenceRequested = false; + bool settingsWriteRequested = false; + bool sendImportExportRequested = false; +}; + +struct LiteBridgeRuntimeBindingOptions { + bool requireArtifactContract = true; + bool requireActivationRequest = true; + bool requireImportedLinkMode = true; + bool requireCompleteSymbolTable = true; + bool rejectRuntimeActions = true; +}; + +struct LiteBridgeRuntimeIssueInfo { + LiteBridgeRuntimeIssue issue = LiteBridgeRuntimeIssue::ArtifactContractRejected; + std::string message; +}; + +struct LiteBridgeRuntimeBindingResult { + bool ok = false; + bool noDynamicLibraryLoaded = true; + bool noDynamicLibraryUnloaded = true; + bool noPlatformSymbolResolution = true; + bool noSdxlCalls = true; + bool noBridgeCalls = true; + bool noServerConnectivityChecked = true; + bool noWalletLifecycle = true; + bool noSyncStarted = true; + bool noSyncStatusPolled = true; + bool noWorkerQueueEnqueue = true; + bool noWalletStateMutation = true; + bool noWalletPersistence = true; + bool noSettingsPersistence = true; + bool noSendImportExportExecution = true; + bool noArtifactMutation = true; + + bool artifactContractAccepted = false; + bool configAccepted = false; + bool activationAccepted = false; + bool importedLinkModeAccepted = false; + bool importedLinkedBindingRequested = false; + bool providedSymbolTableAccepted = false; + bool dynamicLibraryBindingRequested = false; + bool fakeDynamicLoaderResultAccepted = false; + bool noOpAdapterSeamResultAccepted = false; + bool noOpAdapterBindingEvidenceReady = false; + bool noOpAdapterNoHandleProduced = true; + bool noOpAdapterNoSymbolAddressProduced = true; + bool noOpAdapterProductionLoaderDisabled = false; + bool realAdapterDisabledScaffoldResultAccepted = false; + bool realAdapterDisabledScaffoldBindingEvidenceReady = false; + bool realAdapterDisabledScaffoldNoHandleProduced = true; + bool realAdapterDisabledScaffoldNoHandleReleased = true; + bool realAdapterDisabledScaffoldNoSymbolAddressProduced = true; + bool realAdapterDisabledScaffoldProductionLoaderDisabled = false; + bool realAdapterDisabledScaffoldExecutionDisabled = false; + bool dynamicLibraryHandleStored = false; + bool dynamicLibraryHandlePresent = false; + bool dynamicLibraryUnloadDeferred = true; + bool symbolTableProduced = false; + bool symbolTableReady = false; + bool runtimeReady = false; + + std::size_t requiredSymbolCount = 0; + std::size_t availableSymbolCount = 0; + LiteBridgeRuntimeStatus status = LiteBridgeRuntimeStatus::Unavailable; + LiteBridgeRuntimeConfig config; + LiteBridgeRuntimeSymbolTable symbolTable; + LiteBridgeRuntimeDynamicLibraryHandle dynamicLibraryHandle; + std::vector missingSymbols; + std::vector issues; + std::string error; + std::string summary; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterImplementationReviewInput { + LiteBridgeRuntimePlatformDynamicLoaderNoOpAdapterSeamResult noOpAdapterSeam; + LiteBridgeRuntimeBindingResult noOpAdapterBinding; + std::string platform; + std::string adapterName; + bool noOpAdapterSeamAccepted = false; + bool noOpBindingEvidenceAccepted = false; + bool realAdapterSourceReviewed = false; + bool linuxRealAdapterImplementationAvailable = false; + bool windowsRealAdapterImplementationAvailable = false; + bool linuxDlopenDlsymDlcloseMappingReviewed = false; + bool windowsLoadLibraryGetProcAddressFreeLibraryMappingReviewed = false; + bool loadImplementationReviewed = false; + bool unloadImplementationReviewed = false; + bool symbolLookupImplementationReviewed = false; + bool reviewedArtifactPathUse = false; + bool pathEncodingReviewed = false; + bool errorMappingReviewed = false; + bool opaqueHandleOwnershipReviewed = false; + bool unloadAfterRuntimeShutdownReviewed = false; + bool unloadAfterOwnedStringsReviewed = false; + bool symbolLookupContainedInRuntime = false; + bool requiredSymbolCastPlanReviewed = false; + bool rawSymbolPointerEscapeBlocked = false; + bool requiredSymbolMapReused = false; + std::size_t requiredSymbolCount = 0; + bool symbolTableReuseReviewed = false; + bool stringOwnershipReused = false; + bool runtimePlatformImplementationDeferred = true; + bool productionLoaderExecutionDisabled = true; + bool realAdapterExecutionDisabled = true; + bool macosDeferredByOperator = true; + + bool runtimePlatformLoadAttempted = false; + bool runtimePlatformUnloadAttempted = false; + bool runtimePlatformSymbolResolutionAttempted = false; + bool sdxlCallRequested = false; + bool bridgeCallRequested = false; + bool serverConnectivityCheckRequested = false; + bool walletLifecycleRequested = false; + bool syncRequested = false; + bool syncStatusPollingRequested = false; + bool workerQueueRequested = false; + bool walletStateMutationRequested = false; + bool walletPersistenceRequested = false; + bool settingsWriteRequested = false; + bool sendImportExportRequested = false; + bool artifactMutationRequested = false; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterImplementationReviewResult { + bool ok = false; + bool noRuntimePlatformDynamicLibraryLoaded = true; + bool noRuntimePlatformDynamicLibraryUnloaded = true; + bool noRuntimePlatformSymbolResolution = true; + bool noSdxlCalls = true; + bool noBridgeCalls = true; + bool noServerConnectivityChecked = true; + bool noWalletLifecycle = true; + bool noSyncStarted = true; + bool noSyncStatusPolled = true; + bool noWorkerQueueEnqueue = true; + bool noWalletStateMutation = true; + bool noWalletPersistence = true; + bool noSettingsPersistence = true; + bool noSendImportExportExecution = true; + bool noArtifactMutation = true; + + bool platformAccepted = false; + bool linuxPlatformAccepted = false; + bool windowsPlatformAccepted = false; + bool macosDeferred = false; + bool noOpAdapterSeamAccepted = false; + bool noOpBindingEvidenceAccepted = false; + bool realAdapterSourceAccepted = false; + bool platformApiMappingAccepted = false; + bool loadImplementationAccepted = false; + bool unloadImplementationAccepted = false; + bool symbolLookupImplementationAccepted = false; + bool pathAndErrorMappingAccepted = false; + bool handleOwnershipAccepted = false; + bool symbolCastingBoundaryAccepted = false; + bool symbolTableReuseAccepted = false; + bool runtimeDeferralAccepted = false; + bool productionLoaderDisabled = false; + bool realAdapterImplementationReviewReady = false; + + std::size_t requiredSymbolCount = 0; + LiteBridgeRuntimeStatus status = LiteBridgeRuntimeStatus::Unavailable; + std::string platform; + std::string adapterName; + std::vector issues; + std::string error; + std::string summary; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterDisabledScaffoldInput { + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterImplementationReviewResult implementationReview; + LiteBridgeRuntimePlatformDynamicLoaderAdapter adapter; + std::string platform; + std::string artifactPath; + std::string handleLabel; + std::string symbolName; + bool implementationReviewAccepted = false; + bool realAdapterRegistered = false; + bool runtimeOwnsAdapter = false; + bool loadScaffoldProbeRequested = false; + bool unloadScaffoldProbeRequested = false; + bool symbolLookupScaffoldProbeRequested = false; + bool productionLoaderExecutionDisabled = true; + bool realAdapterExecutionDisabled = true; + bool macosDeferredByOperator = true; + + bool runtimePlatformLoadAttempted = false; + bool runtimePlatformUnloadAttempted = false; + bool runtimePlatformSymbolResolutionAttempted = false; + bool sdxlCallRequested = false; + bool bridgeCallRequested = false; + bool serverConnectivityCheckRequested = false; + bool walletLifecycleRequested = false; + bool syncRequested = false; + bool syncStatusPollingRequested = false; + bool workerQueueRequested = false; + bool walletStateMutationRequested = false; + bool walletPersistenceRequested = false; + bool settingsWriteRequested = false; + bool sendImportExportRequested = false; + bool artifactMutationRequested = false; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionPreflightInput { + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterDisabledScaffoldResult disabledScaffold; + LiteBridgeRuntimeBindingResult disabledScaffoldBinding; + std::string platform; + std::string artifactPath; + std::string adapterName; + bool disabledScaffoldAccepted = false; + bool disabledScaffoldBindingAccepted = false; + bool artifactPathReviewed = false; + bool loadOnlyScopeReviewed = false; + bool loadCallbackIsolationReviewed = false; + bool linuxPlatformLoadApiReviewed = false; + bool windowsPlatformLoadApiReviewed = false; + bool loadFailureMappingReviewed = false; + bool opaqueHandleStoragePlanReviewed = false; + bool handleCleanupFallbackReviewed = false; + bool unloadExecutionStillDisabled = true; + bool symbolResolutionStillDisabled = true; + bool productionLoaderExecutionDisabled = true; + bool realAdapterExecutionDisabled = true; + bool loadOnlyExecutionDisabled = true; + bool operatorApprovalRequired = true; + bool macosDeferredByOperator = true; + + bool runtimePlatformLoadAttempted = false; + bool runtimePlatformUnloadAttempted = false; + bool runtimePlatformSymbolResolutionAttempted = false; + bool sdxlCallRequested = false; + bool bridgeCallRequested = false; + bool serverConnectivityCheckRequested = false; + bool walletLifecycleRequested = false; + bool syncRequested = false; + bool syncStatusPollingRequested = false; + bool workerQueueRequested = false; + bool walletStateMutationRequested = false; + bool walletPersistenceRequested = false; + bool settingsWriteRequested = false; + bool sendImportExportRequested = false; + bool artifactMutationRequested = false; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionPreflightResult { + bool ok = false; + bool noRuntimePlatformDynamicLibraryLoaded = true; + bool noRuntimePlatformDynamicLibraryUnloaded = true; + bool noRuntimePlatformSymbolResolution = true; + bool noSdxlCalls = true; + bool noBridgeCalls = true; + bool noServerConnectivityChecked = true; + bool noWalletLifecycle = true; + bool noSyncStarted = true; + bool noSyncStatusPolled = true; + bool noWorkerQueueEnqueue = true; + bool noWalletStateMutation = true; + bool noWalletPersistence = true; + bool noSettingsPersistence = true; + bool noSendImportExportExecution = true; + bool noArtifactMutation = true; + + bool platformAccepted = false; + bool linuxPlatformAccepted = false; + bool windowsPlatformAccepted = false; + bool macosDeferred = false; + bool disabledScaffoldAccepted = false; + bool disabledScaffoldBindingAccepted = false; + bool artifactPathAccepted = false; + bool loadOnlyScopeAccepted = false; + bool loadCallbackIsolationAccepted = false; + bool platformLoadApiReviewAccepted = false; + bool loadFailureMappingAccepted = false; + bool handleStoragePlanAccepted = false; + bool unloadExecutionBlocked = false; + bool symbolResolutionBlocked = false; + bool productionLoaderDisabled = false; + bool realAdapterExecutionDisabled = false; + bool loadOnlyExecutionDisabled = false; + bool operatorApprovalRequired = false; + bool loadOnlyExecutionPreflightReady = false; + + LiteBridgeRuntimeStatus status = LiteBridgeRuntimeStatus::Unavailable; + std::string platform; + std::string adapterName; + std::vector issues; + std::string error; + std::string summary; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionApprovalGateInput { + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionPreflightResult loadOnlyPreflight; + std::string platform; + std::string adapterName; + std::string approvalId; + std::string releaseBuilderId; + std::string loadOnlyEvidenceId; + std::string artifactPath; + std::string artifactSha256; + bool loadOnlyPreflightAccepted = false; + bool operatorApprovalGranted = false; + bool operatorApprovalRecorded = false; + bool operatorApprovalScopeReviewed = false; + bool releaseBuilderIdentityReviewed = false; + bool releaseBuilderTrusted = false; + bool loadOnlyEvidenceReviewed = false; + bool loadOnlyEvidenceMatchesPreflight = false; + bool loadOnlyEvidenceRecordsLoadOnly = false; + bool loadOnlyEvidenceNoSymbolResolution = true; + bool loadOnlyEvidenceNoWalletRuntime = true; + bool artifactPathReviewed = false; + bool artifactSha256Reviewed = false; + bool handleCleanupEvidenceReviewed = false; + bool changeControlReviewed = false; + bool rollbackPlanReviewed = false; + bool unloadExecutionStillDisabled = true; + bool symbolResolutionStillDisabled = true; + bool productionLoaderExecutionDisabled = true; + bool realAdapterExecutionDisabled = true; + bool loadOnlyExecutionDisabled = true; + bool separateExecutionBatchRequired = true; + bool macosDeferredByOperator = true; + + bool runtimePlatformLoadAttempted = false; + bool runtimePlatformUnloadAttempted = false; + bool runtimePlatformSymbolResolutionAttempted = false; + bool sdxlCallRequested = false; + bool bridgeCallRequested = false; + bool serverConnectivityCheckRequested = false; + bool walletLifecycleRequested = false; + bool syncRequested = false; + bool syncStatusPollingRequested = false; + bool workerQueueRequested = false; + bool walletStateMutationRequested = false; + bool walletPersistenceRequested = false; + bool settingsWriteRequested = false; + bool sendImportExportRequested = false; + bool artifactMutationRequested = false; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionApprovalGateResult { + bool ok = false; + bool noRuntimePlatformDynamicLibraryLoaded = true; + bool noRuntimePlatformDynamicLibraryUnloaded = true; + bool noRuntimePlatformSymbolResolution = true; + bool noSdxlCalls = true; + bool noBridgeCalls = true; + bool noServerConnectivityChecked = true; + bool noWalletLifecycle = true; + bool noSyncStarted = true; + bool noSyncStatusPolled = true; + bool noWorkerQueueEnqueue = true; + bool noWalletStateMutation = true; + bool noWalletPersistence = true; + bool noSettingsPersistence = true; + bool noSendImportExportExecution = true; + bool noArtifactMutation = true; + + bool platformAccepted = false; + bool linuxPlatformAccepted = false; + bool windowsPlatformAccepted = false; + bool macosDeferred = false; + bool loadOnlyPreflightAccepted = false; + bool operatorApprovalAccepted = false; + bool releaseBuilderEvidenceAccepted = false; + bool loadOnlyEvidenceAccepted = false; + bool artifactEvidenceAccepted = false; + bool handleCleanupEvidenceAccepted = false; + bool changeControlAccepted = false; + bool rollbackPlanAccepted = false; + bool unloadExecutionBlocked = false; + bool symbolResolutionBlocked = false; + bool productionLoaderDisabled = false; + bool realAdapterExecutionDisabled = false; + bool loadOnlyExecutionDisabled = false; + bool separateExecutionBatchRequired = false; + bool loadOnlyExecutionApprovalGateReady = false; + + LiteBridgeRuntimeStatus status = LiteBridgeRuntimeStatus::Unavailable; + std::string platform; + std::string adapterName; + std::string approvalId; + std::string releaseBuilderId; + std::string loadOnlyEvidenceId; + std::vector issues; + std::string error; + std::string summary; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledOwnerHandoffInput { + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionApprovalGateResult approvalGate; + std::string platform; + std::string adapterName; + std::string ownerName; + std::string handoffId; + std::string loadCallbackBoundaryName; + bool approvalGateAccepted = false; + bool runtimeOwnerIdentified = false; + bool runtimeOwnerHandoffReviewed = false; + bool loadCallbackBoundaryNamed = false; + bool loadCallbackBoundaryReviewed = false; + bool loadCallbackExecutionStillDisabled = true; + bool loadCallbackRequiresSeparateExecutionBatch = true; + bool ownerStoresNoDynamicHandle = true; + bool ownerReleasesNoDynamicHandle = true; + bool ownerStoresNoSymbolTable = true; + bool unloadExecutionStillDisabled = true; + bool symbolResolutionStillDisabled = true; + bool productionLoaderExecutionDisabled = true; + bool realAdapterExecutionDisabled = true; + bool loadOnlyExecutionDisabled = true; + bool separateExecutionBatchRequired = true; + bool macosDeferredByOperator = true; + + bool runtimePlatformLoadAttempted = false; + bool runtimePlatformUnloadAttempted = false; + bool runtimePlatformSymbolResolutionAttempted = false; + bool sdxlCallRequested = false; + bool bridgeCallRequested = false; + bool serverConnectivityCheckRequested = false; + bool walletLifecycleRequested = false; + bool syncRequested = false; + bool syncStatusPollingRequested = false; + bool workerQueueRequested = false; + bool walletStateMutationRequested = false; + bool walletPersistenceRequested = false; + bool settingsWriteRequested = false; + bool sendImportExportRequested = false; + bool artifactMutationRequested = false; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledOwnerHandoffResult { + bool ok = false; + bool noRuntimePlatformDynamicLibraryLoaded = true; + bool noRuntimePlatformDynamicLibraryUnloaded = true; + bool noRuntimePlatformSymbolResolution = true; + bool noSdxlCalls = true; + bool noBridgeCalls = true; + bool noServerConnectivityChecked = true; + bool noWalletLifecycle = true; + bool noSyncStarted = true; + bool noSyncStatusPolled = true; + bool noWorkerQueueEnqueue = true; + bool noWalletStateMutation = true; + bool noWalletPersistence = true; + bool noSettingsPersistence = true; + bool noSendImportExportExecution = true; + bool noArtifactMutation = true; + + bool platformAccepted = false; + bool linuxPlatformAccepted = false; + bool windowsPlatformAccepted = false; + bool macosDeferred = false; + bool approvalGateAccepted = false; + bool runtimeOwnerHandoffAccepted = false; + bool loadCallbackBoundaryAccepted = false; + bool loadCallbackExecutionBlocked = false; + bool disabledOwnerStateAccepted = false; + bool unloadExecutionBlocked = false; + bool symbolResolutionBlocked = false; + bool productionLoaderDisabled = false; + bool realAdapterExecutionDisabled = false; + bool loadOnlyExecutionDisabled = false; + bool separateExecutionBatchRequired = false; + bool loadOnlyExecutionDisabledOwnerHandoffReady = false; + + LiteBridgeRuntimeStatus status = LiteBridgeRuntimeStatus::Unavailable; + std::string platform; + std::string adapterName; + std::string ownerName; + std::string handoffId; + std::string loadCallbackBoundaryName; + std::vector issues; + std::string error; + std::string summary; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackBindingInput { + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledOwnerHandoffResult disabledOwnerHandoff; + std::string platform; + std::string adapterName; + std::string ownerName; + std::string handoffId; + std::string loadCallbackBoundaryName; + std::string callbackBindingId; + std::string callbackName; + bool disabledOwnerHandoffAccepted = false; + bool callbackBindingRecordReviewed = false; + bool callbackBindingRecordDisabled = true; + bool callbackOwnerMatchesHandoff = false; + bool callbackBoundaryMatchesHandoff = false; + bool callbackEntryPointNamed = false; + bool callbackEntryPointReviewed = false; + bool callbackInvocationStillDisabled = true; + bool callbackRequiresSeparateExecutionBatch = true; + bool callbackProducesNoDynamicHandle = true; + bool callbackStoresNoDynamicHandle = true; + bool callbackReleasesNoDynamicHandle = true; + bool callbackResolvesNoSymbols = true; + bool callbackStoresNoSymbolTable = true; + bool callbackCreatesNoRuntime = true; + bool callbackFailureMappingReviewed = false; + bool unloadExecutionStillDisabled = true; + bool symbolResolutionStillDisabled = true; + bool productionLoaderExecutionDisabled = true; + bool realAdapterExecutionDisabled = true; + bool loadOnlyExecutionDisabled = true; + bool separateExecutionBatchRequired = true; + bool macosDeferredByOperator = true; + + bool runtimePlatformLoadAttempted = false; + bool runtimePlatformUnloadAttempted = false; + bool runtimePlatformSymbolResolutionAttempted = false; + bool sdxlCallRequested = false; + bool bridgeCallRequested = false; + bool serverConnectivityCheckRequested = false; + bool walletLifecycleRequested = false; + bool syncRequested = false; + bool syncStatusPollingRequested = false; + bool workerQueueRequested = false; + bool walletStateMutationRequested = false; + bool walletPersistenceRequested = false; + bool settingsWriteRequested = false; + bool sendImportExportRequested = false; + bool artifactMutationRequested = false; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackBindingResult { + bool ok = false; + bool noRuntimePlatformDynamicLibraryLoaded = true; + bool noRuntimePlatformDynamicLibraryUnloaded = true; + bool noRuntimePlatformSymbolResolution = true; + bool noSdxlCalls = true; + bool noBridgeCalls = true; + bool noServerConnectivityChecked = true; + bool noWalletLifecycle = true; + bool noSyncStarted = true; + bool noSyncStatusPolled = true; + bool noWorkerQueueEnqueue = true; + bool noWalletStateMutation = true; + bool noWalletPersistence = true; + bool noSettingsPersistence = true; + bool noSendImportExportExecution = true; + bool noArtifactMutation = true; + + bool platformAccepted = false; + bool linuxPlatformAccepted = false; + bool windowsPlatformAccepted = false; + bool macosDeferred = false; + bool disabledOwnerHandoffAccepted = false; + bool callbackBindingRecordAccepted = false; + bool callbackOwnerBoundaryAccepted = false; + bool callbackEntryPointAccepted = false; + bool callbackInvocationBlocked = false; + bool disabledCallbackStateAccepted = false; + bool callbackFailureMappingAccepted = false; + bool unloadExecutionBlocked = false; + bool symbolResolutionBlocked = false; + bool productionLoaderDisabled = false; + bool realAdapterExecutionDisabled = false; + bool loadOnlyExecutionDisabled = false; + bool separateExecutionBatchRequired = false; + bool loadOnlyExecutionDisabledCallbackBindingReady = false; + + LiteBridgeRuntimeStatus status = LiteBridgeRuntimeStatus::Unavailable; + std::string platform; + std::string adapterName; + std::string ownerName; + std::string handoffId; + std::string loadCallbackBoundaryName; + std::string callbackBindingId; + std::string callbackName; + std::vector issues; + std::string error; + std::string summary; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackPreInvocationGuardInput { + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackBindingResult disabledCallbackBinding; + std::string platform; + std::string adapterName; + std::string ownerName; + std::string handoffId; + std::string loadCallbackBoundaryName; + std::string callbackBindingId; + std::string callbackName; + std::string guardId; + bool disabledCallbackBindingAccepted = false; + bool preInvocationGuardReviewed = false; + bool preInvocationGuardActive = false; + bool guardOwnerMatchesCallbackBinding = false; + bool guardBoundaryMatchesCallbackBinding = false; + bool guardCallbackMatchesCallbackBinding = false; + bool callbackInvocationStillDisabled = true; + bool callbackInvocationRefused = true; + bool callbackInvocationRefusalReviewed = false; + bool guardStopsBeforePlatformApi = true; + bool guardReturnsDisabledResult = true; + bool guardRequiresSeparateExecutionBatch = true; + bool guardProducesNoDynamicHandle = true; + bool guardStoresNoDynamicHandle = true; + bool guardReleasesNoDynamicHandle = true; + bool guardResolvesNoSymbols = true; + bool guardStoresNoSymbolTable = true; + bool guardCreatesNoRuntime = true; + bool guardFailureMappingReviewed = false; + bool unloadExecutionStillDisabled = true; + bool symbolResolutionStillDisabled = true; + bool productionLoaderExecutionDisabled = true; + bool realAdapterExecutionDisabled = true; + bool loadOnlyExecutionDisabled = true; + bool separateExecutionBatchRequired = true; + bool macosDeferredByOperator = true; + + bool callbackInvocationAttempted = false; + bool runtimePlatformLoadAttempted = false; + bool runtimePlatformUnloadAttempted = false; + bool runtimePlatformSymbolResolutionAttempted = false; + bool sdxlCallRequested = false; + bool bridgeCallRequested = false; + bool serverConnectivityCheckRequested = false; + bool walletLifecycleRequested = false; + bool syncRequested = false; + bool syncStatusPollingRequested = false; + bool workerQueueRequested = false; + bool walletStateMutationRequested = false; + bool walletPersistenceRequested = false; + bool settingsWriteRequested = false; + bool sendImportExportRequested = false; + bool artifactMutationRequested = false; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackPreInvocationGuardResult { + bool ok = false; + bool noCallbackInvocationAttempted = true; + bool noRuntimePlatformDynamicLibraryLoaded = true; + bool noRuntimePlatformDynamicLibraryUnloaded = true; + bool noRuntimePlatformSymbolResolution = true; + bool noSdxlCalls = true; + bool noBridgeCalls = true; + bool noServerConnectivityChecked = true; + bool noWalletLifecycle = true; + bool noSyncStarted = true; + bool noSyncStatusPolled = true; + bool noWorkerQueueEnqueue = true; + bool noWalletStateMutation = true; + bool noWalletPersistence = true; + bool noSettingsPersistence = true; + bool noSendImportExportExecution = true; + bool noArtifactMutation = true; + + bool platformAccepted = false; + bool linuxPlatformAccepted = false; + bool windowsPlatformAccepted = false; + bool macosDeferred = false; + bool disabledCallbackBindingAccepted = false; + bool preInvocationGuardAccepted = false; + bool guardCallbackBindingMatchAccepted = false; + bool callbackInvocationRefused = false; + bool platformApiPreInvocationBlocked = false; + bool disabledGuardStateAccepted = false; + bool guardFailureMappingAccepted = false; + bool unloadExecutionBlocked = false; + bool symbolResolutionBlocked = false; + bool productionLoaderDisabled = false; + bool realAdapterExecutionDisabled = false; + bool loadOnlyExecutionDisabled = false; + bool separateExecutionBatchRequired = false; + bool loadOnlyExecutionDisabledCallbackPreInvocationGuardReady = false; + + LiteBridgeRuntimeStatus status = LiteBridgeRuntimeStatus::Unavailable; + std::string platform; + std::string adapterName; + std::string ownerName; + std::string handoffId; + std::string loadCallbackBoundaryName; + std::string callbackBindingId; + std::string callbackName; + std::string guardId; + std::vector issues; + std::string error; + std::string summary; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultInput { + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackPreInvocationGuardResult preInvocationGuard; + std::string platform; + std::string adapterName; + std::string ownerName; + std::string handoffId; + std::string loadCallbackBoundaryName; + std::string callbackBindingId; + std::string callbackName; + std::string guardId; + std::string refusalResultId; + bool preInvocationGuardAccepted = false; + bool refusalResultReviewed = false; + bool refusalResultRecorded = false; + bool refusalResultDisabled = true; + bool refusalResultOwnerMatchesGuard = false; + bool refusalResultBoundaryMatchesGuard = false; + bool refusalResultCallbackMatchesGuard = false; + bool refusalResultGuardMatchesPreInvocationGuard = false; + bool callbackInvocationStillDisabled = true; + bool callbackInvocationRefused = true; + bool callbackInvocationRefusalReviewed = false; + bool refusalResultCarriesGuardEvidence = false; + bool refusalResultStopsBeforeCallbackInvocation = true; + bool refusalResultStopsBeforePlatformApi = true; + bool refusalResultReturnsDisabledOutcome = true; + bool refusalResultRequiresSeparateExecutionBatch = true; + bool refusalResultProducesNoDynamicHandle = true; + bool refusalResultStoresNoDynamicHandle = true; + bool refusalResultReleasesNoDynamicHandle = true; + bool refusalResultResolvesNoSymbols = true; + bool refusalResultStoresNoSymbolTable = true; + bool refusalResultCreatesNoRuntime = true; + bool refusalResultFailureMappingReviewed = false; + bool unloadExecutionStillDisabled = true; + bool symbolResolutionStillDisabled = true; + bool productionLoaderExecutionDisabled = true; + bool realAdapterExecutionDisabled = true; + bool loadOnlyExecutionDisabled = true; + bool separateExecutionBatchRequired = true; + bool macosDeferredByOperator = true; + + bool callbackInvocationAttempted = false; + bool callbackResultExecutionAttempted = false; + bool runtimePlatformLoadAttempted = false; + bool runtimePlatformUnloadAttempted = false; + bool runtimePlatformSymbolResolutionAttempted = false; + bool sdxlCallRequested = false; + bool bridgeCallRequested = false; + bool serverConnectivityCheckRequested = false; + bool walletLifecycleRequested = false; + bool syncRequested = false; + bool syncStatusPollingRequested = false; + bool workerQueueRequested = false; + bool walletStateMutationRequested = false; + bool walletPersistenceRequested = false; + bool settingsWriteRequested = false; + bool sendImportExportRequested = false; + bool artifactMutationRequested = false; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultResult { + bool ok = false; + bool noCallbackInvocationAttempted = true; + bool noCallbackResultExecutionAttempted = true; + bool noRuntimePlatformDynamicLibraryLoaded = true; + bool noRuntimePlatformDynamicLibraryUnloaded = true; + bool noRuntimePlatformSymbolResolution = true; + bool noSdxlCalls = true; + bool noBridgeCalls = true; + bool noServerConnectivityChecked = true; + bool noWalletLifecycle = true; + bool noSyncStarted = true; + bool noSyncStatusPolled = true; + bool noWorkerQueueEnqueue = true; + bool noWalletStateMutation = true; + bool noWalletPersistence = true; + bool noSettingsPersistence = true; + bool noSendImportExportExecution = true; + bool noArtifactMutation = true; + + bool platformAccepted = false; + bool linuxPlatformAccepted = false; + bool windowsPlatformAccepted = false; + bool macosDeferred = false; + bool preInvocationGuardAccepted = false; + bool refusalResultAccepted = false; + bool refusalResultGuardMatchAccepted = false; + bool callbackInvocationRefused = false; + bool callbackRefusalResultProjected = false; + bool platformApiPreInvocationBlocked = false; + bool disabledRefusalResultStateAccepted = false; + bool refusalResultFailureMappingAccepted = false; + bool unloadExecutionBlocked = false; + bool symbolResolutionBlocked = false; + bool productionLoaderDisabled = false; + bool realAdapterExecutionDisabled = false; + bool loadOnlyExecutionDisabled = false; + bool separateExecutionBatchRequired = false; + bool loadOnlyExecutionDisabledCallbackRefusalResultReady = false; + + LiteBridgeRuntimeStatus status = LiteBridgeRuntimeStatus::Unavailable; + std::string platform; + std::string adapterName; + std::string ownerName; + std::string handoffId; + std::string loadCallbackBoundaryName; + std::string callbackBindingId; + std::string callbackName; + std::string guardId; + std::string refusalResultId; + std::vector issues; + std::string error; + std::string summary; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultPropagationInput { + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultResult refusalResult; + std::string platform; + std::string adapterName; + std::string ownerName; + std::string handoffId; + std::string loadCallbackBoundaryName; + std::string callbackBindingId; + std::string callbackName; + std::string guardId; + std::string refusalResultId; + std::string propagationId; + std::string dispatchHandoffId; + std::string statusRecordId; + bool refusalResultAccepted = false; + bool propagationRecordReviewed = false; + bool propagationRecordRecorded = false; + bool propagationRecordDisabled = true; + bool propagationOwnerMatchesRefusalResult = false; + bool propagationBoundaryMatchesRefusalResult = false; + bool propagationCallbackMatchesRefusalResult = false; + bool propagationGuardMatchesRefusalResult = false; + bool propagationResultMatchesRefusalResult = false; + bool disabledDispatchHandoffReviewed = false; + bool disabledDispatchHandoffRecorded = false; + bool disabledStatusRecordReviewed = false; + bool disabledStatusRecordRecorded = false; + bool propagationCarriesRefusalResultEvidence = false; + bool propagationReturnsDisabledDispatchStatus = true; + bool callbackInvocationStillDisabled = true; + bool callbackInvocationRefused = true; + bool callbackInvocationRefusalReviewed = false; + bool propagationStopsBeforeCallbackInvocation = true; + bool propagationStopsBeforeCallbackResultExecution = true; + bool propagationStopsBeforePlatformApi = true; + bool propagationRequiresSeparateExecutionBatch = true; + bool propagationProducesNoDynamicHandle = true; + bool propagationStoresNoDynamicHandle = true; + bool propagationReleasesNoDynamicHandle = true; + bool propagationResolvesNoSymbols = true; + bool propagationStoresNoSymbolTable = true; + bool propagationCreatesNoRuntime = true; + bool propagationFailureMappingReviewed = false; + bool unloadExecutionStillDisabled = true; + bool symbolResolutionStillDisabled = true; + bool productionLoaderExecutionDisabled = true; + bool realAdapterExecutionDisabled = true; + bool loadOnlyExecutionDisabled = true; + bool separateExecutionBatchRequired = true; + bool macosDeferredByOperator = true; + + bool callbackInvocationAttempted = false; + bool callbackResultExecutionAttempted = false; + bool dispatchHandoffExecutionAttempted = false; + bool dispatchStatusPublicationAttempted = false; + bool runtimePlatformLoadAttempted = false; + bool runtimePlatformUnloadAttempted = false; + bool runtimePlatformSymbolResolutionAttempted = false; + bool sdxlCallRequested = false; + bool bridgeCallRequested = false; + bool serverConnectivityCheckRequested = false; + bool walletLifecycleRequested = false; + bool syncRequested = false; + bool syncStatusPollingRequested = false; + bool workerQueueRequested = false; + bool walletStateMutationRequested = false; + bool walletPersistenceRequested = false; + bool settingsWriteRequested = false; + bool sendImportExportRequested = false; + bool artifactMutationRequested = false; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultPropagationResult { + bool ok = false; + bool noCallbackInvocationAttempted = true; + bool noCallbackResultExecutionAttempted = true; + bool noDispatchHandoffExecutionAttempted = true; + bool noDispatchStatusPublicationAttempted = true; + bool noRuntimePlatformDynamicLibraryLoaded = true; + bool noRuntimePlatformDynamicLibraryUnloaded = true; + bool noRuntimePlatformSymbolResolution = true; + bool noSdxlCalls = true; + bool noBridgeCalls = true; + bool noServerConnectivityChecked = true; + bool noWalletLifecycle = true; + bool noSyncStarted = true; + bool noSyncStatusPolled = true; + bool noWorkerQueueEnqueue = true; + bool noWalletStateMutation = true; + bool noWalletPersistence = true; + bool noSettingsPersistence = true; + bool noSendImportExportExecution = true; + bool noArtifactMutation = true; + + bool platformAccepted = false; + bool linuxPlatformAccepted = false; + bool windowsPlatformAccepted = false; + bool macosDeferred = false; + bool refusalResultAccepted = false; + bool propagationRecordAccepted = false; + bool propagationRefusalResultMatchAccepted = false; + bool disabledDispatchHandoffAccepted = false; + bool disabledDispatchStatusAccepted = false; + bool callbackInvocationRefused = false; + bool callbackRefusalResultPropagated = false; + bool platformApiPreInvocationBlocked = false; + bool disabledPropagationStateAccepted = false; + bool propagationFailureMappingAccepted = false; + bool unloadExecutionBlocked = false; + bool symbolResolutionBlocked = false; + bool productionLoaderDisabled = false; + bool realAdapterExecutionDisabled = false; + bool loadOnlyExecutionDisabled = false; + bool separateExecutionBatchRequired = false; + bool loadOnlyExecutionDisabledCallbackRefusalResultPropagationReady = false; + + LiteBridgeRuntimeStatus status = LiteBridgeRuntimeStatus::Unavailable; + std::string platform; + std::string adapterName; + std::string ownerName; + std::string handoffId; + std::string loadCallbackBoundaryName; + std::string callbackBindingId; + std::string callbackName; + std::string guardId; + std::string refusalResultId; + std::string propagationId; + std::string dispatchHandoffId; + std::string statusRecordId; + std::vector issues; + std::string error; + std::string summary; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessInput { + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultPropagationResult refusalPropagation; + std::string platform; + std::string adapterName; + std::string ownerName; + std::string handoffId; + std::string loadCallbackBoundaryName; + std::string callbackBindingId; + std::string callbackName; + std::string guardId; + std::string refusalResultId; + std::string propagationId; + std::string dispatchHandoffId; + std::string statusRecordId; + std::string consumerReadinessId; + std::string consumerName; + bool refusalPropagationAccepted = false; + bool consumerReadinessReviewed = false; + bool consumerReadinessRecorded = false; + bool consumerReadinessDisabled = true; + bool consumerOwnerMatchesPropagation = false; + bool consumerBoundaryMatchesPropagation = false; + bool consumerCallbackMatchesPropagation = false; + bool consumerGuardMatchesPropagation = false; + bool consumerRefusalResultMatchesPropagation = false; + bool consumerPropagationMatchesPropagation = false; + bool consumerDispatchHandoffMatchesPropagation = false; + bool consumerStatusRecordMatchesPropagation = false; + bool disabledConsumerRegistered = false; + bool disabledConsumerAcceptsPropagationEvidence = false; + bool consumerReturnsDisabledReadiness = true; + bool consumerBlocksDispatchConsumption = true; + bool consumerBlocksStatusPublication = true; + bool callbackInvocationStillDisabled = true; + bool callbackInvocationRefused = true; + bool callbackInvocationRefusalReviewed = false; + bool consumerStopsBeforeCallbackInvocation = true; + bool consumerStopsBeforeCallbackResultExecution = true; + bool consumerStopsBeforeDispatchExecution = true; + bool consumerStopsBeforePlatformApi = true; + bool consumerRequiresSeparateExecutionBatch = true; + bool consumerProducesNoDynamicHandle = true; + bool consumerStoresNoDynamicHandle = true; + bool consumerReleasesNoDynamicHandle = true; + bool consumerResolvesNoSymbols = true; + bool consumerStoresNoSymbolTable = true; + bool consumerCreatesNoRuntime = true; + bool consumerReadinessFailureMappingReviewed = false; + bool unloadExecutionStillDisabled = true; + bool symbolResolutionStillDisabled = true; + bool productionLoaderExecutionDisabled = true; + bool realAdapterExecutionDisabled = true; + bool loadOnlyExecutionDisabled = true; + bool separateExecutionBatchRequired = true; + bool macosDeferredByOperator = true; + + bool callbackInvocationAttempted = false; + bool callbackResultExecutionAttempted = false; + bool dispatchHandoffExecutionAttempted = false; + bool dispatchStatusPublicationAttempted = false; + bool dispatchConsumerConsumptionAttempted = false; + bool consumerReadinessStatusPublicationAttempted = false; + bool runtimePlatformLoadAttempted = false; + bool runtimePlatformUnloadAttempted = false; + bool runtimePlatformSymbolResolutionAttempted = false; + bool sdxlCallRequested = false; + bool bridgeCallRequested = false; + bool serverConnectivityCheckRequested = false; + bool walletLifecycleRequested = false; + bool syncRequested = false; + bool syncStatusPollingRequested = false; + bool workerQueueRequested = false; + bool walletStateMutationRequested = false; + bool walletPersistenceRequested = false; + bool settingsWriteRequested = false; + bool sendImportExportRequested = false; + bool artifactMutationRequested = false; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessResult { + bool ok = false; + bool noCallbackInvocationAttempted = true; + bool noCallbackResultExecutionAttempted = true; + bool noDispatchHandoffExecutionAttempted = true; + bool noDispatchStatusPublicationAttempted = true; + bool noDispatchConsumerConsumptionAttempted = true; + bool noConsumerReadinessStatusPublicationAttempted = true; + bool noRuntimePlatformDynamicLibraryLoaded = true; + bool noRuntimePlatformDynamicLibraryUnloaded = true; + bool noRuntimePlatformSymbolResolution = true; + bool noSdxlCalls = true; + bool noBridgeCalls = true; + bool noServerConnectivityChecked = true; + bool noWalletLifecycle = true; + bool noSyncStarted = true; + bool noSyncStatusPolled = true; + bool noWorkerQueueEnqueue = true; + bool noWalletStateMutation = true; + bool noWalletPersistence = true; + bool noSettingsPersistence = true; + bool noSendImportExportExecution = true; + bool noArtifactMutation = true; + + bool platformAccepted = false; + bool linuxPlatformAccepted = false; + bool windowsPlatformAccepted = false; + bool macosDeferred = false; + bool refusalPropagationAccepted = false; + bool consumerReadinessRecordAccepted = false; + bool consumerPropagationMatchAccepted = false; + bool disabledConsumerReadinessAccepted = false; + bool callbackInvocationRefused = false; + bool callbackRefusalPropagationConsumerReady = false; + bool platformApiPreInvocationBlocked = false; + bool disabledConsumerStateAccepted = false; + bool consumerReadinessFailureMappingAccepted = false; + bool unloadExecutionBlocked = false; + bool symbolResolutionBlocked = false; + bool productionLoaderDisabled = false; + bool realAdapterExecutionDisabled = false; + bool loadOnlyExecutionDisabled = false; + bool separateExecutionBatchRequired = false; + bool loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessReady = false; + + LiteBridgeRuntimeStatus status = LiteBridgeRuntimeStatus::Unavailable; + std::string platform; + std::string adapterName; + std::string ownerName; + std::string handoffId; + std::string loadCallbackBoundaryName; + std::string callbackBindingId; + std::string callbackName; + std::string guardId; + std::string refusalResultId; + std::string propagationId; + std::string dispatchHandoffId; + std::string statusRecordId; + std::string consumerReadinessId; + std::string consumerName; + std::vector issues; + std::string error; + std::string summary; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardInput { + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessResult consumerReadiness; + std::string platform; + std::string adapterName; + std::string ownerName; + std::string handoffId; + std::string loadCallbackBoundaryName; + std::string callbackBindingId; + std::string callbackName; + std::string guardId; + std::string refusalResultId; + std::string propagationId; + std::string dispatchHandoffId; + std::string statusRecordId; + std::string consumerReadinessId; + std::string consumerName; + std::string dispatchConsumptionGuardId; + std::string dispatchConsumerName; + bool consumerReadinessAccepted = false; + bool dispatchConsumptionGuardReviewed = false; + bool dispatchConsumptionGuardRecorded = false; + bool dispatchConsumptionGuardDisabled = true; + bool guardOwnerMatchesConsumerReadiness = false; + bool guardBoundaryMatchesConsumerReadiness = false; + bool guardCallbackMatchesConsumerReadiness = false; + bool guardPreInvocationGuardMatchesConsumerReadiness = false; + bool guardRefusalResultMatchesConsumerReadiness = false; + bool guardPropagationMatchesConsumerReadiness = false; + bool guardDispatchHandoffMatchesConsumerReadiness = false; + bool guardStatusRecordMatchesConsumerReadiness = false; + bool guardConsumerReadinessMatchesConsumerReadiness = false; + bool guardConsumerNameMatchesConsumerReadiness = false; + bool disabledDispatchConsumptionGuardRegistered = false; + bool dispatchConsumptionGuardAcceptsConsumerReadinessEvidence = false; + bool dispatchConsumptionGuardReturnsDisabledConsumption = true; + bool dispatchConsumptionGuardBlocksDispatchConsumption = true; + bool dispatchConsumptionGuardBlocksStatusPublication = true; + bool callbackInvocationStillDisabled = true; + bool callbackInvocationRefused = true; + bool callbackInvocationRefusalReviewed = false; + bool guardStopsBeforeCallbackInvocation = true; + bool guardStopsBeforeCallbackResultExecution = true; + bool guardStopsBeforeDispatchConsumption = true; + bool guardStopsBeforeDispatchStatusPublication = true; + bool guardStopsBeforePlatformApi = true; + bool guardRequiresSeparateExecutionBatch = true; + bool guardProducesNoDynamicHandle = true; + bool guardStoresNoDynamicHandle = true; + bool guardReleasesNoDynamicHandle = true; + bool guardResolvesNoSymbols = true; + bool guardStoresNoSymbolTable = true; + bool guardCreatesNoRuntime = true; + bool dispatchConsumptionFailureMappingReviewed = false; + bool unloadExecutionStillDisabled = true; + bool symbolResolutionStillDisabled = true; + bool productionLoaderExecutionDisabled = true; + bool realAdapterExecutionDisabled = true; + bool loadOnlyExecutionDisabled = true; + bool separateExecutionBatchRequired = true; + bool macosDeferredByOperator = true; + + bool callbackInvocationAttempted = false; + bool callbackResultExecutionAttempted = false; + bool dispatchHandoffExecutionAttempted = false; + bool dispatchStatusPublicationAttempted = false; + bool dispatchConsumerConsumptionAttempted = false; + bool dispatchConsumptionGuardStatusPublicationAttempted = false; + bool runtimePlatformLoadAttempted = false; + bool runtimePlatformUnloadAttempted = false; + bool runtimePlatformSymbolResolutionAttempted = false; + bool sdxlCallRequested = false; + bool bridgeCallRequested = false; + bool serverConnectivityCheckRequested = false; + bool walletLifecycleRequested = false; + bool syncRequested = false; + bool syncStatusPollingRequested = false; + bool workerQueueRequested = false; + bool walletStateMutationRequested = false; + bool walletPersistenceRequested = false; + bool settingsWriteRequested = false; + bool sendImportExportRequested = false; + bool artifactMutationRequested = false; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResult { + bool ok = false; + bool noCallbackInvocationAttempted = true; + bool noCallbackResultExecutionAttempted = true; + bool noDispatchHandoffExecutionAttempted = true; + bool noDispatchStatusPublicationAttempted = true; + bool noDispatchConsumerConsumptionAttempted = true; + bool noDispatchConsumptionGuardStatusPublicationAttempted = true; + bool noRuntimePlatformDynamicLibraryLoaded = true; + bool noRuntimePlatformDynamicLibraryUnloaded = true; + bool noRuntimePlatformSymbolResolution = true; + bool noSdxlCalls = true; + bool noBridgeCalls = true; + bool noServerConnectivityChecked = true; + bool noWalletLifecycle = true; + bool noSyncStarted = true; + bool noSyncStatusPolled = true; + bool noWorkerQueueEnqueue = true; + bool noWalletStateMutation = true; + bool noWalletPersistence = true; + bool noSettingsPersistence = true; + bool noSendImportExportExecution = true; + bool noArtifactMutation = true; + + bool platformAccepted = false; + bool linuxPlatformAccepted = false; + bool windowsPlatformAccepted = false; + bool macosDeferred = false; + bool consumerReadinessAccepted = false; + bool dispatchConsumptionGuardRecordAccepted = false; + bool guardConsumerReadinessMatchAccepted = false; + bool disabledDispatchConsumptionGuardAccepted = false; + bool callbackInvocationRefused = false; + bool dispatchConsumptionGuarded = false; + bool dispatchStatusPublicationBlocked = false; + bool platformApiPreInvocationBlocked = false; + bool disabledDispatchConsumptionGuardStateAccepted = false; + bool dispatchConsumptionFailureMappingAccepted = false; + bool unloadExecutionBlocked = false; + bool symbolResolutionBlocked = false; + bool productionLoaderDisabled = false; + bool realAdapterExecutionDisabled = false; + bool loadOnlyExecutionDisabled = false; + bool separateExecutionBatchRequired = false; + bool loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardReady = false; + + LiteBridgeRuntimeStatus status = LiteBridgeRuntimeStatus::Unavailable; + std::string platform; + std::string adapterName; + std::string ownerName; + std::string handoffId; + std::string loadCallbackBoundaryName; + std::string callbackBindingId; + std::string callbackName; + std::string guardId; + std::string refusalResultId; + std::string propagationId; + std::string dispatchHandoffId; + std::string statusRecordId; + std::string consumerReadinessId; + std::string consumerName; + std::string dispatchConsumptionGuardId; + std::string dispatchConsumerName; + std::vector issues; + std::string error; + std::string summary; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffInput { + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResult dispatchConsumptionGuard; + std::string platform; + std::string adapterName; + std::string ownerName; + std::string handoffId; + std::string loadCallbackBoundaryName; + std::string callbackBindingId; + std::string callbackName; + std::string guardId; + std::string refusalResultId; + std::string propagationId; + std::string dispatchHandoffId; + std::string statusRecordId; + std::string consumerReadinessId; + std::string consumerName; + std::string dispatchConsumptionGuardId; + std::string dispatchConsumerName; + std::string resultHandoffId; + std::string resultConsumerName; + bool dispatchConsumptionGuardAccepted = false; + bool resultHandoffReviewed = false; + bool resultHandoffRecorded = false; + bool resultHandoffDisabled = true; + bool handoffOwnerMatchesDispatchGuard = false; + bool handoffBoundaryMatchesDispatchGuard = false; + bool handoffCallbackMatchesDispatchGuard = false; + bool handoffPreInvocationGuardMatchesDispatchGuard = false; + bool handoffRefusalResultMatchesDispatchGuard = false; + bool handoffPropagationMatchesDispatchGuard = false; + bool handoffDispatchHandoffMatchesDispatchGuard = false; + bool handoffStatusRecordMatchesDispatchGuard = false; + bool handoffConsumerReadinessMatchesDispatchGuard = false; + bool handoffConsumerNameMatchesDispatchGuard = false; + bool handoffDispatchConsumptionGuardMatchesDispatchGuard = false; + bool handoffDispatchConsumerNameMatchesDispatchGuard = false; + bool disabledResultHandoffRegistered = false; + bool resultHandoffAcceptsDispatchConsumptionGuardEvidence = false; + bool resultHandoffReturnsDisabledResult = true; + bool resultHandoffBlocksDispatchConsumption = true; + bool resultHandoffBlocksDispatchResultExecution = true; + bool resultHandoffBlocksStatusPublication = true; + bool callbackInvocationStillDisabled = true; + bool callbackInvocationRefused = true; + bool callbackInvocationRefusalReviewed = false; + bool handoffStopsBeforeCallbackInvocation = true; + bool handoffStopsBeforeCallbackResultExecution = true; + bool handoffStopsBeforeDispatchConsumption = true; + bool handoffStopsBeforeDispatchResultExecution = true; + bool handoffStopsBeforeDispatchStatusPublication = true; + bool handoffStopsBeforePlatformApi = true; + bool handoffRequiresSeparateExecutionBatch = true; + bool handoffProducesNoDynamicHandle = true; + bool handoffStoresNoDynamicHandle = true; + bool handoffReleasesNoDynamicHandle = true; + bool handoffResolvesNoSymbols = true; + bool handoffStoresNoSymbolTable = true; + bool handoffCreatesNoRuntime = true; + bool resultHandoffFailureMappingReviewed = false; + bool unloadExecutionStillDisabled = true; + bool symbolResolutionStillDisabled = true; + bool productionLoaderExecutionDisabled = true; + bool realAdapterExecutionDisabled = true; + bool loadOnlyExecutionDisabled = true; + bool separateExecutionBatchRequired = true; + bool macosDeferredByOperator = true; + + bool callbackInvocationAttempted = false; + bool callbackResultExecutionAttempted = false; + bool dispatchHandoffExecutionAttempted = false; + bool dispatchStatusPublicationAttempted = false; + bool dispatchConsumerConsumptionAttempted = false; + bool dispatchResultExecutionAttempted = false; + bool resultHandoffStatusPublicationAttempted = false; + bool runtimePlatformLoadAttempted = false; + bool runtimePlatformUnloadAttempted = false; + bool runtimePlatformSymbolResolutionAttempted = false; + bool sdxlCallRequested = false; + bool bridgeCallRequested = false; + bool serverConnectivityCheckRequested = false; + bool walletLifecycleRequested = false; + bool syncRequested = false; + bool syncStatusPollingRequested = false; + bool workerQueueRequested = false; + bool walletStateMutationRequested = false; + bool walletPersistenceRequested = false; + bool settingsWriteRequested = false; + bool sendImportExportRequested = false; + bool artifactMutationRequested = false; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffResult { + bool ok = false; + bool noCallbackInvocationAttempted = true; + bool noCallbackResultExecutionAttempted = true; + bool noDispatchHandoffExecutionAttempted = true; + bool noDispatchStatusPublicationAttempted = true; + bool noDispatchConsumerConsumptionAttempted = true; + bool noDispatchResultExecutionAttempted = true; + bool noResultHandoffStatusPublicationAttempted = true; + bool noRuntimePlatformDynamicLibraryLoaded = true; + bool noRuntimePlatformDynamicLibraryUnloaded = true; + bool noRuntimePlatformSymbolResolution = true; + bool noSdxlCalls = true; + bool noBridgeCalls = true; + bool noServerConnectivityChecked = true; + bool noWalletLifecycle = true; + bool noSyncStarted = true; + bool noSyncStatusPolled = true; + bool noWorkerQueueEnqueue = true; + bool noWalletStateMutation = true; + bool noWalletPersistence = true; + bool noSettingsPersistence = true; + bool noSendImportExportExecution = true; + bool noArtifactMutation = true; + + bool platformAccepted = false; + bool linuxPlatformAccepted = false; + bool windowsPlatformAccepted = false; + bool macosDeferred = false; + bool dispatchConsumptionGuardAccepted = false; + bool resultHandoffRecordAccepted = false; + bool handoffDispatchGuardMatchAccepted = false; + bool disabledResultHandoffAccepted = false; + bool callbackInvocationRefused = false; + bool dispatchConsumptionStillGuarded = false; + bool dispatchResultExecutionBlocked = false; + bool dispatchStatusPublicationBlocked = false; + bool platformApiPreInvocationBlocked = false; + bool disabledResultHandoffStateAccepted = false; + bool resultHandoffFailureMappingAccepted = false; + bool unloadExecutionBlocked = false; + bool symbolResolutionBlocked = false; + bool productionLoaderDisabled = false; + bool realAdapterExecutionDisabled = false; + bool loadOnlyExecutionDisabled = false; + bool separateExecutionBatchRequired = false; + bool loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReady = false; + + LiteBridgeRuntimeStatus status = LiteBridgeRuntimeStatus::Unavailable; + std::string platform; + std::string adapterName; + std::string ownerName; + std::string handoffId; + std::string loadCallbackBoundaryName; + std::string callbackBindingId; + std::string callbackName; + std::string guardId; + std::string refusalResultId; + std::string propagationId; + std::string dispatchHandoffId; + std::string statusRecordId; + std::string consumerReadinessId; + std::string consumerName; + std::string dispatchConsumptionGuardId; + std::string dispatchConsumerName; + std::string resultHandoffId; + std::string resultConsumerName; + std::vector issues; + std::string error; + std::string summary; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionInput { + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffResult resultHandoff; + std::string platform; + std::string adapterName; + std::string ownerName; + std::string handoffId; + std::string loadCallbackBoundaryName; + std::string callbackBindingId; + std::string callbackName; + std::string guardId; + std::string refusalResultId; + std::string propagationId; + std::string dispatchHandoffId; + std::string statusRecordId; + std::string consumerReadinessId; + std::string consumerName; + std::string dispatchConsumptionGuardId; + std::string dispatchConsumerName; + std::string resultHandoffId; + std::string resultConsumerName; + std::string readinessProjectionId; + std::string readinessConsumerName; + bool resultHandoffAccepted = false; + bool readinessProjectionReviewed = false; + bool readinessProjectionRecorded = false; + bool readinessProjectionDisabled = true; + bool projectionOwnerMatchesResultHandoff = false; + bool projectionBoundaryMatchesResultHandoff = false; + bool projectionCallbackMatchesResultHandoff = false; + bool projectionPreInvocationGuardMatchesResultHandoff = false; + bool projectionRefusalResultMatchesResultHandoff = false; + bool projectionPropagationMatchesResultHandoff = false; + bool projectionDispatchHandoffMatchesResultHandoff = false; + bool projectionStatusRecordMatchesResultHandoff = false; + bool projectionConsumerReadinessMatchesResultHandoff = false; + bool projectionConsumerNameMatchesResultHandoff = false; + bool projectionDispatchConsumptionGuardMatchesResultHandoff = false; + bool projectionDispatchConsumerNameMatchesResultHandoff = false; + bool projectionResultHandoffMatchesResultHandoff = false; + bool projectionResultConsumerNameMatchesResultHandoff = false; + bool disabledReadinessProjectionRegistered = false; + bool readinessProjectionAcceptsResultHandoffEvidence = false; + bool readinessProjectionReturnsDisabledReadiness = true; + bool readinessProjectionBlocksDispatchConsumption = true; + bool readinessProjectionBlocksDispatchResultExecution = true; + bool readinessProjectionBlocksStatusPublication = true; + bool readinessProjectionBlocksReadinessPublication = true; + bool callbackInvocationStillDisabled = true; + bool callbackInvocationRefused = true; + bool callbackInvocationRefusalReviewed = false; + bool projectionStopsBeforeCallbackInvocation = true; + bool projectionStopsBeforeCallbackResultExecution = true; + bool projectionStopsBeforeDispatchConsumption = true; + bool projectionStopsBeforeDispatchResultExecution = true; + bool projectionStopsBeforeDispatchStatusPublication = true; + bool projectionStopsBeforeReadinessPublication = true; + bool projectionStopsBeforePlatformApi = true; + bool projectionRequiresSeparateExecutionBatch = true; + bool projectionProducesNoDynamicHandle = true; + bool projectionStoresNoDynamicHandle = true; + bool projectionReleasesNoDynamicHandle = true; + bool projectionResolvesNoSymbols = true; + bool projectionStoresNoSymbolTable = true; + bool projectionCreatesNoRuntime = true; + bool readinessProjectionFailureMappingReviewed = false; + bool unloadExecutionStillDisabled = true; + bool symbolResolutionStillDisabled = true; + bool productionLoaderExecutionDisabled = true; + bool realAdapterExecutionDisabled = true; + bool loadOnlyExecutionDisabled = true; + bool separateExecutionBatchRequired = true; + bool macosDeferredByOperator = true; + + bool callbackInvocationAttempted = false; + bool callbackResultExecutionAttempted = false; + bool dispatchHandoffExecutionAttempted = false; + bool dispatchStatusPublicationAttempted = false; + bool dispatchConsumerConsumptionAttempted = false; + bool dispatchResultExecutionAttempted = false; + bool resultHandoffStatusPublicationAttempted = false; + bool readinessProjectionStatusPublicationAttempted = false; + bool runtimePlatformLoadAttempted = false; + bool runtimePlatformUnloadAttempted = false; + bool runtimePlatformSymbolResolutionAttempted = false; + bool sdxlCallRequested = false; + bool bridgeCallRequested = false; + bool serverConnectivityCheckRequested = false; + bool walletLifecycleRequested = false; + bool syncRequested = false; + bool syncStatusPollingRequested = false; + bool workerQueueRequested = false; + bool walletStateMutationRequested = false; + bool walletPersistenceRequested = false; + bool settingsWriteRequested = false; + bool sendImportExportRequested = false; + bool artifactMutationRequested = false; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionResult { + bool ok = false; + bool noCallbackInvocationAttempted = true; + bool noCallbackResultExecutionAttempted = true; + bool noDispatchHandoffExecutionAttempted = true; + bool noDispatchStatusPublicationAttempted = true; + bool noDispatchConsumerConsumptionAttempted = true; + bool noDispatchResultExecutionAttempted = true; + bool noResultHandoffStatusPublicationAttempted = true; + bool noReadinessProjectionStatusPublicationAttempted = true; + bool noRuntimePlatformDynamicLibraryLoaded = true; + bool noRuntimePlatformDynamicLibraryUnloaded = true; + bool noRuntimePlatformSymbolResolution = true; + bool noSdxlCalls = true; + bool noBridgeCalls = true; + bool noServerConnectivityChecked = true; + bool noWalletLifecycle = true; + bool noSyncStarted = true; + bool noSyncStatusPolled = true; + bool noWorkerQueueEnqueue = true; + bool noWalletStateMutation = true; + bool noWalletPersistence = true; + bool noSettingsPersistence = true; + bool noSendImportExportExecution = true; + bool noArtifactMutation = true; + + bool platformAccepted = false; + bool linuxPlatformAccepted = false; + bool windowsPlatformAccepted = false; + bool macosDeferred = false; + bool resultHandoffAccepted = false; + bool readinessProjectionRecordAccepted = false; + bool projectionResultHandoffMatchAccepted = false; + bool disabledReadinessProjectionAccepted = false; + bool callbackInvocationRefused = false; + bool dispatchConsumptionStillGuarded = false; + bool dispatchResultExecutionBlocked = false; + bool dispatchStatusPublicationBlocked = false; + bool readinessProjectionPublicationBlocked = false; + bool platformApiPreInvocationBlocked = false; + bool disabledReadinessProjectionStateAccepted = false; + bool readinessProjectionFailureMappingAccepted = false; + bool unloadExecutionBlocked = false; + bool symbolResolutionBlocked = false; + bool productionLoaderDisabled = false; + bool realAdapterExecutionDisabled = false; + bool loadOnlyExecutionDisabled = false; + bool separateExecutionBatchRequired = false; + bool loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionReady = false; + + LiteBridgeRuntimeStatus status = LiteBridgeRuntimeStatus::Unavailable; + std::string platform; + std::string adapterName; + std::string ownerName; + std::string handoffId; + std::string loadCallbackBoundaryName; + std::string callbackBindingId; + std::string callbackName; + std::string guardId; + std::string refusalResultId; + std::string propagationId; + std::string dispatchHandoffId; + std::string statusRecordId; + std::string consumerReadinessId; + std::string consumerName; + std::string dispatchConsumptionGuardId; + std::string dispatchConsumerName; + std::string resultHandoffId; + std::string resultConsumerName; + std::string readinessProjectionId; + std::string readinessConsumerName; + std::vector issues; + std::string error; + std::string summary; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffInput { + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionResult readinessProjection; + std::string platform; + std::string adapterName; + std::string ownerName; + std::string handoffId; + std::string loadCallbackBoundaryName; + std::string callbackBindingId; + std::string callbackName; + std::string guardId; + std::string refusalResultId; + std::string propagationId; + std::string dispatchHandoffId; + std::string statusRecordId; + std::string consumerReadinessId; + std::string consumerName; + std::string dispatchConsumptionGuardId; + std::string dispatchConsumerName; + std::string resultHandoffId; + std::string resultConsumerName; + std::string readinessProjectionId; + std::string readinessConsumerName; + std::string statusHandoffId; + std::string statusConsumerName; + bool readinessProjectionAccepted = false; + bool statusHandoffReviewed = false; + bool statusHandoffRecorded = false; + bool statusHandoffDisabled = true; + bool statusHandoffOwnerMatchesReadinessProjection = false; + bool statusHandoffBoundaryMatchesReadinessProjection = false; + bool statusHandoffCallbackMatchesReadinessProjection = false; + bool statusHandoffPreInvocationGuardMatchesReadinessProjection = false; + bool statusHandoffRefusalResultMatchesReadinessProjection = false; + bool statusHandoffPropagationMatchesReadinessProjection = false; + bool statusHandoffDispatchHandoffMatchesReadinessProjection = false; + bool statusHandoffStatusRecordMatchesReadinessProjection = false; + bool statusHandoffConsumerReadinessMatchesReadinessProjection = false; + bool statusHandoffConsumerNameMatchesReadinessProjection = false; + bool statusHandoffDispatchConsumptionGuardMatchesReadinessProjection = false; + bool statusHandoffDispatchConsumerNameMatchesReadinessProjection = false; + bool statusHandoffResultHandoffMatchesReadinessProjection = false; + bool statusHandoffResultConsumerNameMatchesReadinessProjection = false; + bool statusHandoffReadinessProjectionMatchesReadinessProjection = false; + bool statusHandoffReadinessConsumerNameMatchesReadinessProjection = false; + bool disabledStatusHandoffRegistered = false; + bool statusHandoffAcceptsReadinessProjectionEvidence = false; + bool statusHandoffReturnsDisabledStatus = true; + bool statusHandoffBlocksDispatchConsumption = true; + bool statusHandoffBlocksDispatchResultExecution = true; + bool statusHandoffBlocksStatusPublication = true; + bool statusHandoffBlocksReadinessPublication = true; + bool callbackInvocationStillDisabled = true; + bool callbackInvocationRefused = true; + bool callbackInvocationRefusalReviewed = false; + bool statusHandoffStopsBeforeCallbackInvocation = true; + bool statusHandoffStopsBeforeCallbackResultExecution = true; + bool statusHandoffStopsBeforeDispatchConsumption = true; + bool statusHandoffStopsBeforeDispatchResultExecution = true; + bool statusHandoffStopsBeforeDispatchStatusPublication = true; + bool statusHandoffStopsBeforeReadinessPublication = true; + bool statusHandoffStopsBeforeStatusPublication = true; + bool statusHandoffStopsBeforePlatformApi = true; + bool statusHandoffRequiresSeparateExecutionBatch = true; + bool statusHandoffProducesNoDynamicHandle = true; + bool statusHandoffStoresNoDynamicHandle = true; + bool statusHandoffReleasesNoDynamicHandle = true; + bool statusHandoffResolvesNoSymbols = true; + bool statusHandoffStoresNoSymbolTable = true; + bool statusHandoffCreatesNoRuntime = true; + bool statusHandoffFailureMappingReviewed = false; + bool unloadExecutionStillDisabled = true; + bool symbolResolutionStillDisabled = true; + bool productionLoaderExecutionDisabled = true; + bool realAdapterExecutionDisabled = true; + bool loadOnlyExecutionDisabled = true; + bool separateExecutionBatchRequired = true; + bool macosDeferredByOperator = true; + + bool callbackInvocationAttempted = false; + bool callbackResultExecutionAttempted = false; + bool dispatchHandoffExecutionAttempted = false; + bool dispatchStatusPublicationAttempted = false; + bool dispatchConsumerConsumptionAttempted = false; + bool dispatchResultExecutionAttempted = false; + bool resultHandoffStatusPublicationAttempted = false; + bool readinessProjectionStatusPublicationAttempted = false; + bool statusHandoffPublicationAttempted = false; + bool runtimePlatformLoadAttempted = false; + bool runtimePlatformUnloadAttempted = false; + bool runtimePlatformSymbolResolutionAttempted = false; + bool sdxlCallRequested = false; + bool bridgeCallRequested = false; + bool serverConnectivityCheckRequested = false; + bool walletLifecycleRequested = false; + bool syncRequested = false; + bool syncStatusPollingRequested = false; + bool workerQueueRequested = false; + bool walletStateMutationRequested = false; + bool walletPersistenceRequested = false; + bool settingsWriteRequested = false; + bool sendImportExportRequested = false; + bool artifactMutationRequested = false; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffResult { + bool ok = false; + bool noCallbackInvocationAttempted = true; + bool noCallbackResultExecutionAttempted = true; + bool noDispatchHandoffExecutionAttempted = true; + bool noDispatchStatusPublicationAttempted = true; + bool noDispatchConsumerConsumptionAttempted = true; + bool noDispatchResultExecutionAttempted = true; + bool noResultHandoffStatusPublicationAttempted = true; + bool noReadinessProjectionStatusPublicationAttempted = true; + bool noStatusHandoffPublicationAttempted = true; + bool noRuntimePlatformDynamicLibraryLoaded = true; + bool noRuntimePlatformDynamicLibraryUnloaded = true; + bool noRuntimePlatformSymbolResolution = true; + bool noSdxlCalls = true; + bool noBridgeCalls = true; + bool noServerConnectivityChecked = true; + bool noWalletLifecycle = true; + bool noSyncStarted = true; + bool noSyncStatusPolled = true; + bool noWorkerQueueEnqueue = true; + bool noWalletStateMutation = true; + bool noWalletPersistence = true; + bool noSettingsPersistence = true; + bool noSendImportExportExecution = true; + bool noArtifactMutation = true; + + bool platformAccepted = false; + bool linuxPlatformAccepted = false; + bool windowsPlatformAccepted = false; + bool macosDeferred = false; + bool readinessProjectionAccepted = false; + bool statusHandoffRecordAccepted = false; + bool statusHandoffReadinessProjectionMatchAccepted = false; + bool disabledStatusHandoffAccepted = false; + bool callbackInvocationRefused = false; + bool dispatchConsumptionStillGuarded = false; + bool dispatchResultExecutionBlocked = false; + bool dispatchStatusPublicationBlocked = false; + bool readinessProjectionPublicationBlocked = false; + bool statusHandoffPublicationBlocked = false; + bool platformApiPreInvocationBlocked = false; + bool disabledStatusHandoffStateAccepted = false; + bool statusHandoffFailureMappingAccepted = false; + bool unloadExecutionBlocked = false; + bool symbolResolutionBlocked = false; + bool productionLoaderDisabled = false; + bool realAdapterExecutionDisabled = false; + bool loadOnlyExecutionDisabled = false; + bool separateExecutionBatchRequired = false; + bool loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffReady = false; + + LiteBridgeRuntimeStatus status = LiteBridgeRuntimeStatus::Unavailable; + std::string platform; + std::string adapterName; + std::string ownerName; + std::string handoffId; + std::string loadCallbackBoundaryName; + std::string callbackBindingId; + std::string callbackName; + std::string guardId; + std::string refusalResultId; + std::string propagationId; + std::string dispatchHandoffId; + std::string statusRecordId; + std::string consumerReadinessId; + std::string consumerName; + std::string dispatchConsumptionGuardId; + std::string dispatchConsumerName; + std::string resultHandoffId; + std::string resultConsumerName; + std::string readinessProjectionId; + std::string readinessConsumerName; + std::string statusHandoffId; + std::string statusConsumerName; + std::vector issues; + std::string error; + std::string summary; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardInput { + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffResult statusHandoff; + std::string platform; + std::string adapterName; + std::string ownerName; + std::string handoffId; + std::string loadCallbackBoundaryName; + std::string callbackBindingId; + std::string callbackName; + std::string guardId; + std::string refusalResultId; + std::string propagationId; + std::string dispatchHandoffId; + std::string statusRecordId; + std::string consumerReadinessId; + std::string consumerName; + std::string dispatchConsumptionGuardId; + std::string dispatchConsumerName; + std::string resultHandoffId; + std::string resultConsumerName; + std::string readinessProjectionId; + std::string readinessConsumerName; + std::string statusHandoffId; + std::string statusConsumerName; + std::string publicationGuardId; + std::string publicationConsumerName; + bool statusHandoffAccepted = false; + bool publicationGuardReviewed = false; + bool publicationGuardRecorded = false; + bool publicationGuardDisabled = true; + bool publicationGuardOwnerMatchesStatusHandoff = false; + bool publicationGuardBoundaryMatchesStatusHandoff = false; + bool publicationGuardCallbackMatchesStatusHandoff = false; + bool publicationGuardPreInvocationGuardMatchesStatusHandoff = false; + bool publicationGuardRefusalResultMatchesStatusHandoff = false; + bool publicationGuardPropagationMatchesStatusHandoff = false; + bool publicationGuardDispatchHandoffMatchesStatusHandoff = false; + bool publicationGuardStatusRecordMatchesStatusHandoff = false; + bool publicationGuardConsumerReadinessMatchesStatusHandoff = false; + bool publicationGuardConsumerNameMatchesStatusHandoff = false; + bool publicationGuardDispatchConsumptionGuardMatchesStatusHandoff = false; + bool publicationGuardDispatchConsumerNameMatchesStatusHandoff = false; + bool publicationGuardResultHandoffMatchesStatusHandoff = false; + bool publicationGuardResultConsumerNameMatchesStatusHandoff = false; + bool publicationGuardReadinessProjectionMatchesStatusHandoff = false; + bool publicationGuardReadinessConsumerNameMatchesStatusHandoff = false; + bool publicationGuardStatusHandoffMatchesStatusHandoff = false; + bool publicationGuardStatusConsumerNameMatchesStatusHandoff = false; + bool disabledPublicationGuardRegistered = false; + bool publicationGuardAcceptsStatusHandoffEvidence = false; + bool publicationGuardReturnsDisabledPublication = true; + bool publicationGuardBlocksDispatchConsumption = true; + bool publicationGuardBlocksDispatchResultExecution = true; + bool publicationGuardBlocksStatusPublication = true; + bool publicationGuardBlocksReadinessPublication = true; + bool publicationGuardBlocksStatusHandoffPublication = true; + bool callbackInvocationStillDisabled = true; + bool callbackInvocationRefused = true; + bool callbackInvocationRefusalReviewed = false; + bool publicationGuardStopsBeforeCallbackInvocation = true; + bool publicationGuardStopsBeforeCallbackResultExecution = true; + bool publicationGuardStopsBeforeDispatchConsumption = true; + bool publicationGuardStopsBeforeDispatchResultExecution = true; + bool publicationGuardStopsBeforeDispatchStatusPublication = true; + bool publicationGuardStopsBeforeReadinessPublication = true; + bool publicationGuardStopsBeforeStatusHandoffPublication = true; + bool publicationGuardStopsBeforePublication = true; + bool publicationGuardStopsBeforePlatformApi = true; + bool publicationGuardRequiresSeparateExecutionBatch = true; + bool publicationGuardProducesNoDynamicHandle = true; + bool publicationGuardStoresNoDynamicHandle = true; + bool publicationGuardReleasesNoDynamicHandle = true; + bool publicationGuardResolvesNoSymbols = true; + bool publicationGuardStoresNoSymbolTable = true; + bool publicationGuardCreatesNoRuntime = true; + bool publicationGuardFailureMappingReviewed = false; + bool unloadExecutionStillDisabled = true; + bool symbolResolutionStillDisabled = true; + bool productionLoaderExecutionDisabled = true; + bool realAdapterExecutionDisabled = true; + bool loadOnlyExecutionDisabled = true; + bool separateExecutionBatchRequired = true; + bool macosDeferredByOperator = true; + + bool callbackInvocationAttempted = false; + bool callbackResultExecutionAttempted = false; + bool dispatchHandoffExecutionAttempted = false; + bool dispatchStatusPublicationAttempted = false; + bool dispatchConsumerConsumptionAttempted = false; + bool dispatchResultExecutionAttempted = false; + bool resultHandoffStatusPublicationAttempted = false; + bool readinessProjectionStatusPublicationAttempted = false; + bool statusHandoffPublicationAttempted = false; + bool publicationGuardPublicationAttempted = false; + bool runtimePlatformLoadAttempted = false; + bool runtimePlatformUnloadAttempted = false; + bool runtimePlatformSymbolResolutionAttempted = false; + bool sdxlCallRequested = false; + bool bridgeCallRequested = false; + bool serverConnectivityCheckRequested = false; + bool walletLifecycleRequested = false; + bool syncRequested = false; + bool syncStatusPollingRequested = false; + bool workerQueueRequested = false; + bool walletStateMutationRequested = false; + bool walletPersistenceRequested = false; + bool settingsWriteRequested = false; + bool sendImportExportRequested = false; + bool artifactMutationRequested = false; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResult { + bool ok = false; + bool noCallbackInvocationAttempted = true; + bool noCallbackResultExecutionAttempted = true; + bool noDispatchHandoffExecutionAttempted = true; + bool noDispatchStatusPublicationAttempted = true; + bool noDispatchConsumerConsumptionAttempted = true; + bool noDispatchResultExecutionAttempted = true; + bool noResultHandoffStatusPublicationAttempted = true; + bool noReadinessProjectionStatusPublicationAttempted = true; + bool noStatusHandoffPublicationAttempted = true; + bool noPublicationGuardPublicationAttempted = true; + bool noRuntimePlatformDynamicLibraryLoaded = true; + bool noRuntimePlatformDynamicLibraryUnloaded = true; + bool noRuntimePlatformSymbolResolution = true; + bool noSdxlCalls = true; + bool noBridgeCalls = true; + bool noServerConnectivityChecked = true; + bool noWalletLifecycle = true; + bool noSyncStarted = true; + bool noSyncStatusPolled = true; + bool noWorkerQueueEnqueue = true; + bool noWalletStateMutation = true; + bool noWalletPersistence = true; + bool noSettingsPersistence = true; + bool noSendImportExportExecution = true; + bool noArtifactMutation = true; + + bool platformAccepted = false; + bool linuxPlatformAccepted = false; + bool windowsPlatformAccepted = false; + bool macosDeferred = false; + bool statusHandoffAccepted = false; + bool publicationGuardRecordAccepted = false; + bool publicationGuardStatusHandoffMatchAccepted = false; + bool disabledPublicationGuardAccepted = false; + bool callbackInvocationRefused = false; + bool dispatchConsumptionStillGuarded = false; + bool dispatchResultExecutionBlocked = false; + bool dispatchStatusPublicationBlocked = false; + bool readinessProjectionPublicationBlocked = false; + bool statusHandoffPublicationBlocked = false; + bool publicationGuardPublicationBlocked = false; + bool platformApiPreInvocationBlocked = false; + bool disabledPublicationGuardStateAccepted = false; + bool publicationGuardFailureMappingAccepted = false; + bool unloadExecutionBlocked = false; + bool symbolResolutionBlocked = false; + bool productionLoaderDisabled = false; + bool realAdapterExecutionDisabled = false; + bool loadOnlyExecutionDisabled = false; + bool separateExecutionBatchRequired = false; + bool loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardReady = false; + + LiteBridgeRuntimeStatus status = LiteBridgeRuntimeStatus::Unavailable; + std::string platform; + std::string adapterName; + std::string ownerName; + std::string handoffId; + std::string loadCallbackBoundaryName; + std::string callbackBindingId; + std::string callbackName; + std::string guardId; + std::string refusalResultId; + std::string propagationId; + std::string dispatchHandoffId; + std::string statusRecordId; + std::string consumerReadinessId; + std::string consumerName; + std::string dispatchConsumptionGuardId; + std::string dispatchConsumerName; + std::string resultHandoffId; + std::string resultConsumerName; + std::string readinessProjectionId; + std::string readinessConsumerName; + std::string statusHandoffId; + std::string statusConsumerName; + std::string publicationGuardId; + std::string publicationConsumerName; + std::vector issues; + std::string error; + std::string summary; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffInput { + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResult publicationGuard; + std::string platform; + std::string adapterName; + std::string ownerName; + std::string handoffId; + std::string loadCallbackBoundaryName; + std::string callbackBindingId; + std::string callbackName; + std::string guardId; + std::string refusalResultId; + std::string propagationId; + std::string dispatchHandoffId; + std::string statusRecordId; + std::string consumerReadinessId; + std::string consumerName; + std::string dispatchConsumptionGuardId; + std::string dispatchConsumerName; + std::string resultHandoffId; + std::string resultConsumerName; + std::string readinessProjectionId; + std::string readinessConsumerName; + std::string statusHandoffId; + std::string statusConsumerName; + std::string publicationGuardId; + std::string publicationConsumerName; + std::string publicationGuardResultHandoffId; + std::string publicationGuardResultConsumerName; + bool publicationGuardAccepted = false; + bool publicationGuardResultHandoffReviewed = false; + bool publicationGuardResultHandoffRecorded = false; + bool publicationGuardResultHandoffDisabled = true; + bool publicationGuardResultHandoffOwnerMatchesPublicationGuard = false; + bool publicationGuardResultHandoffBoundaryMatchesPublicationGuard = false; + bool publicationGuardResultHandoffCallbackMatchesPublicationGuard = false; + bool publicationGuardResultHandoffPreInvocationGuardMatchesPublicationGuard = false; + bool publicationGuardResultHandoffRefusalResultMatchesPublicationGuard = false; + bool publicationGuardResultHandoffPropagationMatchesPublicationGuard = false; + bool publicationGuardResultHandoffDispatchHandoffMatchesPublicationGuard = false; + bool publicationGuardResultHandoffStatusRecordMatchesPublicationGuard = false; + bool publicationGuardResultHandoffConsumerReadinessMatchesPublicationGuard = false; + bool publicationGuardResultHandoffConsumerNameMatchesPublicationGuard = false; + bool publicationGuardResultHandoffDispatchConsumptionGuardMatchesPublicationGuard = false; + bool publicationGuardResultHandoffDispatchConsumerNameMatchesPublicationGuard = false; + bool publicationGuardResultHandoffResultHandoffMatchesPublicationGuard = false; + bool publicationGuardResultHandoffResultConsumerNameMatchesPublicationGuard = false; + bool publicationGuardResultHandoffReadinessProjectionMatchesPublicationGuard = false; + bool publicationGuardResultHandoffReadinessConsumerNameMatchesPublicationGuard = false; + bool publicationGuardResultHandoffStatusHandoffMatchesPublicationGuard = false; + bool publicationGuardResultHandoffStatusConsumerNameMatchesPublicationGuard = false; + bool publicationGuardResultHandoffPublicationGuardMatchesPublicationGuard = false; + bool publicationGuardResultHandoffPublicationConsumerNameMatchesPublicationGuard = false; + bool disabledPublicationGuardResultHandoffRegistered = false; + bool publicationGuardResultHandoffAcceptsPublicationGuardEvidence = false; + bool publicationGuardResultHandoffReturnsDisabledResult = true; + bool publicationGuardResultHandoffBlocksDispatchConsumption = true; + bool publicationGuardResultHandoffBlocksDispatchResultExecution = true; + bool publicationGuardResultHandoffBlocksStatusPublication = true; + bool publicationGuardResultHandoffBlocksReadinessPublication = true; + bool publicationGuardResultHandoffBlocksStatusHandoffPublication = true; + bool publicationGuardResultHandoffBlocksPublicationGuardPublication = true; + bool callbackInvocationStillDisabled = true; + bool callbackInvocationRefused = true; + bool callbackInvocationRefusalReviewed = false; + bool publicationGuardResultHandoffStopsBeforeCallbackInvocation = true; + bool publicationGuardResultHandoffStopsBeforeCallbackResultExecution = true; + bool publicationGuardResultHandoffStopsBeforeDispatchConsumption = true; + bool publicationGuardResultHandoffStopsBeforeDispatchResultExecution = true; + bool publicationGuardResultHandoffStopsBeforeDispatchStatusPublication = true; + bool publicationGuardResultHandoffStopsBeforeReadinessPublication = true; + bool publicationGuardResultHandoffStopsBeforeStatusHandoffPublication = true; + bool publicationGuardResultHandoffStopsBeforePublicationGuardPublication = true; + bool publicationGuardResultHandoffStopsBeforeResultPublication = true; + bool publicationGuardResultHandoffStopsBeforePlatformApi = true; + bool publicationGuardResultHandoffRequiresSeparateExecutionBatch = true; + bool publicationGuardResultHandoffProducesNoDynamicHandle = true; + bool publicationGuardResultHandoffStoresNoDynamicHandle = true; + bool publicationGuardResultHandoffReleasesNoDynamicHandle = true; + bool publicationGuardResultHandoffResolvesNoSymbols = true; + bool publicationGuardResultHandoffStoresNoSymbolTable = true; + bool publicationGuardResultHandoffCreatesNoRuntime = true; + bool publicationGuardResultHandoffFailureMappingReviewed = false; + bool unloadExecutionStillDisabled = true; + bool symbolResolutionStillDisabled = true; + bool productionLoaderExecutionDisabled = true; + bool realAdapterExecutionDisabled = true; + bool loadOnlyExecutionDisabled = true; + bool separateExecutionBatchRequired = true; + bool macosDeferredByOperator = true; + + bool callbackInvocationAttempted = false; + bool callbackResultExecutionAttempted = false; + bool dispatchHandoffExecutionAttempted = false; + bool dispatchStatusPublicationAttempted = false; + bool dispatchConsumerConsumptionAttempted = false; + bool dispatchResultExecutionAttempted = false; + bool resultHandoffStatusPublicationAttempted = false; + bool readinessProjectionStatusPublicationAttempted = false; + bool statusHandoffPublicationAttempted = false; + bool publicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffPublicationAttempted = false; + bool runtimePlatformLoadAttempted = false; + bool runtimePlatformUnloadAttempted = false; + bool runtimePlatformSymbolResolutionAttempted = false; + bool sdxlCallRequested = false; + bool bridgeCallRequested = false; + bool serverConnectivityCheckRequested = false; + bool walletLifecycleRequested = false; + bool syncRequested = false; + bool syncStatusPollingRequested = false; + bool workerQueueRequested = false; + bool walletStateMutationRequested = false; + bool walletPersistenceRequested = false; + bool settingsWriteRequested = false; + bool sendImportExportRequested = false; + bool artifactMutationRequested = false; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffResult { + bool ok = false; + bool noCallbackInvocationAttempted = true; + bool noCallbackResultExecutionAttempted = true; + bool noDispatchHandoffExecutionAttempted = true; + bool noDispatchStatusPublicationAttempted = true; + bool noDispatchConsumerConsumptionAttempted = true; + bool noDispatchResultExecutionAttempted = true; + bool noResultHandoffStatusPublicationAttempted = true; + bool noReadinessProjectionStatusPublicationAttempted = true; + bool noStatusHandoffPublicationAttempted = true; + bool noPublicationGuardPublicationAttempted = true; + bool noPublicationGuardResultHandoffPublicationAttempted = true; + bool noRuntimePlatformDynamicLibraryLoaded = true; + bool noRuntimePlatformDynamicLibraryUnloaded = true; + bool noRuntimePlatformSymbolResolution = true; + bool noSdxlCalls = true; + bool noBridgeCalls = true; + bool noServerConnectivityChecked = true; + bool noWalletLifecycle = true; + bool noSyncStarted = true; + bool noSyncStatusPolled = true; + bool noWorkerQueueEnqueue = true; + bool noWalletStateMutation = true; + bool noWalletPersistence = true; + bool noSettingsPersistence = true; + bool noSendImportExportExecution = true; + bool noArtifactMutation = true; + + bool platformAccepted = false; + bool linuxPlatformAccepted = false; + bool windowsPlatformAccepted = false; + bool macosDeferred = false; + bool publicationGuardAccepted = false; + bool publicationGuardResultHandoffRecordAccepted = false; + bool publicationGuardResultHandoffPublicationGuardMatchAccepted = false; + bool disabledPublicationGuardResultHandoffAccepted = false; + bool callbackInvocationRefused = false; + bool dispatchConsumptionStillGuarded = false; + bool dispatchResultExecutionBlocked = false; + bool dispatchStatusPublicationBlocked = false; + bool readinessProjectionPublicationBlocked = false; + bool statusHandoffPublicationBlocked = false; + bool publicationGuardPublicationBlocked = false; + bool publicationGuardResultHandoffPublicationBlocked = false; + bool platformApiPreInvocationBlocked = false; + bool disabledPublicationGuardResultHandoffStateAccepted = false; + bool publicationGuardResultHandoffFailureMappingAccepted = false; + bool unloadExecutionBlocked = false; + bool symbolResolutionBlocked = false; + bool productionLoaderDisabled = false; + bool realAdapterExecutionDisabled = false; + bool loadOnlyExecutionDisabled = false; + bool separateExecutionBatchRequired = false; + bool loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReady = false; + + LiteBridgeRuntimeStatus status = LiteBridgeRuntimeStatus::Unavailable; + std::string platform; + std::string adapterName; + std::string ownerName; + std::string handoffId; + std::string loadCallbackBoundaryName; + std::string callbackBindingId; + std::string callbackName; + std::string guardId; + std::string refusalResultId; + std::string propagationId; + std::string dispatchHandoffId; + std::string statusRecordId; + std::string consumerReadinessId; + std::string consumerName; + std::string dispatchConsumptionGuardId; + std::string dispatchConsumerName; + std::string resultHandoffId; + std::string resultConsumerName; + std::string readinessProjectionId; + std::string readinessConsumerName; + std::string statusHandoffId; + std::string statusConsumerName; + std::string publicationGuardId; + std::string publicationConsumerName; + std::string publicationGuardResultHandoffId; + std::string publicationGuardResultConsumerName; + std::vector issues; + std::string error; + std::string summary; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionInput { + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffResult publicationGuardResultHandoff; + std::string platform; + std::string adapterName; + std::string ownerName; + std::string handoffId; + std::string loadCallbackBoundaryName; + std::string callbackBindingId; + std::string callbackName; + std::string guardId; + std::string refusalResultId; + std::string propagationId; + std::string dispatchHandoffId; + std::string statusRecordId; + std::string consumerReadinessId; + std::string consumerName; + std::string dispatchConsumptionGuardId; + std::string dispatchConsumerName; + std::string resultHandoffId; + std::string resultConsumerName; + std::string readinessProjectionId; + std::string readinessConsumerName; + std::string statusHandoffId; + std::string statusConsumerName; + std::string publicationGuardId; + std::string publicationConsumerName; + std::string publicationGuardResultHandoffId; + std::string publicationGuardResultConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionId; + std::string publicationGuardResultHandoffReadinessConsumerName; + bool publicationGuardResultHandoffAccepted = false; + bool publicationGuardResultHandoffReadinessProjectionReviewed = false; + bool publicationGuardResultHandoffReadinessProjectionRecorded = false; + bool publicationGuardResultHandoffReadinessProjectionDisabled = true; + bool projectionOwnerMatchesPublicationGuardResultHandoff = false; + bool projectionBoundaryMatchesPublicationGuardResultHandoff = false; + bool projectionCallbackMatchesPublicationGuardResultHandoff = false; + bool projectionPreInvocationGuardMatchesPublicationGuardResultHandoff = false; + bool projectionRefusalResultMatchesPublicationGuardResultHandoff = false; + bool projectionPropagationMatchesPublicationGuardResultHandoff = false; + bool projectionDispatchHandoffMatchesPublicationGuardResultHandoff = false; + bool projectionStatusRecordMatchesPublicationGuardResultHandoff = false; + bool projectionConsumerReadinessMatchesPublicationGuardResultHandoff = false; + bool projectionConsumerNameMatchesPublicationGuardResultHandoff = false; + bool projectionDispatchConsumptionGuardMatchesPublicationGuardResultHandoff = false; + bool projectionDispatchConsumerNameMatchesPublicationGuardResultHandoff = false; + bool projectionResultHandoffMatchesPublicationGuardResultHandoff = false; + bool projectionResultConsumerNameMatchesPublicationGuardResultHandoff = false; + bool projectionReadinessProjectionMatchesPublicationGuardResultHandoff = false; + bool projectionReadinessConsumerNameMatchesPublicationGuardResultHandoff = false; + bool projectionStatusHandoffMatchesPublicationGuardResultHandoff = false; + bool projectionStatusConsumerNameMatchesPublicationGuardResultHandoff = false; + bool projectionPublicationGuardMatchesPublicationGuardResultHandoff = false; + bool projectionPublicationConsumerNameMatchesPublicationGuardResultHandoff = false; + bool projectionPublicationGuardResultHandoffMatchesPublicationGuardResultHandoff = false; + bool projectionPublicationGuardResultConsumerNameMatchesPublicationGuardResultHandoff = false; + bool disabledPublicationGuardResultHandoffReadinessProjectionRegistered = false; + bool publicationGuardResultHandoffReadinessProjectionAcceptsResultHandoffEvidence = false; + bool publicationGuardResultHandoffReadinessProjectionReturnsDisabledReadiness = true; + bool publicationGuardResultHandoffReadinessProjectionBlocksDispatchConsumption = true; + bool publicationGuardResultHandoffReadinessProjectionBlocksDispatchResultExecution = true; + bool publicationGuardResultHandoffReadinessProjectionBlocksStatusPublication = true; + bool publicationGuardResultHandoffReadinessProjectionBlocksReadinessPublication = true; + bool publicationGuardResultHandoffReadinessProjectionBlocksStatusHandoffPublication = true; + bool publicationGuardResultHandoffReadinessProjectionBlocksPublicationGuardPublication = true; + bool publicationGuardResultHandoffReadinessProjectionBlocksResultHandoffPublication = true; + bool callbackInvocationStillDisabled = true; + bool callbackInvocationRefused = true; + bool callbackInvocationRefusalReviewed = false; + bool projectionStopsBeforeCallbackInvocation = true; + bool projectionStopsBeforeCallbackResultExecution = true; + bool projectionStopsBeforeDispatchConsumption = true; + bool projectionStopsBeforeDispatchResultExecution = true; + bool projectionStopsBeforeDispatchStatusPublication = true; + bool projectionStopsBeforeReadinessPublication = true; + bool projectionStopsBeforeStatusHandoffPublication = true; + bool projectionStopsBeforePublicationGuardPublication = true; + bool projectionStopsBeforePublicationGuardResultHandoffPublication = true; + bool projectionStopsBeforeReadinessProjectionPublication = true; + bool projectionStopsBeforePlatformApi = true; + bool projectionRequiresSeparateExecutionBatch = true; + bool projectionProducesNoDynamicHandle = true; + bool projectionStoresNoDynamicHandle = true; + bool projectionReleasesNoDynamicHandle = true; + bool projectionResolvesNoSymbols = true; + bool projectionStoresNoSymbolTable = true; + bool projectionCreatesNoRuntime = true; + bool publicationGuardResultHandoffReadinessProjectionFailureMappingReviewed = false; + bool unloadExecutionStillDisabled = true; + bool symbolResolutionStillDisabled = true; + bool productionLoaderExecutionDisabled = true; + bool realAdapterExecutionDisabled = true; + bool loadOnlyExecutionDisabled = true; + bool separateExecutionBatchRequired = true; + bool macosDeferredByOperator = true; + + bool callbackInvocationAttempted = false; + bool callbackResultExecutionAttempted = false; + bool dispatchHandoffExecutionAttempted = false; + bool dispatchStatusPublicationAttempted = false; + bool dispatchConsumerConsumptionAttempted = false; + bool dispatchResultExecutionAttempted = false; + bool resultHandoffStatusPublicationAttempted = false; + bool readinessProjectionStatusPublicationAttempted = false; + bool statusHandoffPublicationAttempted = false; + bool publicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool runtimePlatformLoadAttempted = false; + bool runtimePlatformUnloadAttempted = false; + bool runtimePlatformSymbolResolutionAttempted = false; + bool sdxlCallRequested = false; + bool bridgeCallRequested = false; + bool serverConnectivityCheckRequested = false; + bool walletLifecycleRequested = false; + bool syncRequested = false; + bool syncStatusPollingRequested = false; + bool workerQueueRequested = false; + bool walletStateMutationRequested = false; + bool walletPersistenceRequested = false; + bool settingsWriteRequested = false; + bool sendImportExportRequested = false; + bool artifactMutationRequested = false; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionResult { + bool ok = false; + bool noCallbackInvocationAttempted = true; + bool noCallbackResultExecutionAttempted = true; + bool noDispatchHandoffExecutionAttempted = true; + bool noDispatchStatusPublicationAttempted = true; + bool noDispatchConsumerConsumptionAttempted = true; + bool noDispatchResultExecutionAttempted = true; + bool noResultHandoffStatusPublicationAttempted = true; + bool noReadinessProjectionStatusPublicationAttempted = true; + bool noStatusHandoffPublicationAttempted = true; + bool noPublicationGuardPublicationAttempted = true; + bool noPublicationGuardResultHandoffPublicationAttempted = true; + bool noPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = true; + bool noRuntimePlatformDynamicLibraryLoaded = true; + bool noRuntimePlatformDynamicLibraryUnloaded = true; + bool noRuntimePlatformSymbolResolution = true; + bool noSdxlCalls = true; + bool noBridgeCalls = true; + bool noServerConnectivityChecked = true; + bool noWalletLifecycle = true; + bool noSyncStarted = true; + bool noSyncStatusPolled = true; + bool noWorkerQueueEnqueue = true; + bool noWalletStateMutation = true; + bool noWalletPersistence = true; + bool noSettingsPersistence = true; + bool noSendImportExportExecution = true; + bool noArtifactMutation = true; + + bool platformAccepted = false; + bool linuxPlatformAccepted = false; + bool windowsPlatformAccepted = false; + bool macosDeferred = false; + bool publicationGuardResultHandoffAccepted = false; + bool publicationGuardResultHandoffReadinessProjectionRecordAccepted = false; + bool projectionPublicationGuardResultHandoffMatchAccepted = false; + bool disabledPublicationGuardResultHandoffReadinessProjectionAccepted = false; + bool callbackInvocationRefused = false; + bool dispatchConsumptionStillGuarded = false; + bool dispatchResultExecutionBlocked = false; + bool dispatchStatusPublicationBlocked = false; + bool readinessProjectionPublicationBlocked = false; + bool statusHandoffPublicationBlocked = false; + bool publicationGuardPublicationBlocked = false; + bool publicationGuardResultHandoffPublicationBlocked = false; + bool publicationGuardResultHandoffReadinessProjectionPublicationBlocked = false; + bool platformApiPreInvocationBlocked = false; + bool disabledPublicationGuardResultHandoffReadinessProjectionStateAccepted = false; + bool publicationGuardResultHandoffReadinessProjectionFailureMappingAccepted = false; + bool unloadExecutionBlocked = false; + bool symbolResolutionBlocked = false; + bool productionLoaderDisabled = false; + bool realAdapterExecutionDisabled = false; + bool loadOnlyExecutionDisabled = false; + bool separateExecutionBatchRequired = false; + bool loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionReady = false; + + LiteBridgeRuntimeStatus status = LiteBridgeRuntimeStatus::Unavailable; + std::string platform; + std::string adapterName; + std::string ownerName; + std::string handoffId; + std::string loadCallbackBoundaryName; + std::string callbackBindingId; + std::string callbackName; + std::string guardId; + std::string refusalResultId; + std::string propagationId; + std::string dispatchHandoffId; + std::string statusRecordId; + std::string consumerReadinessId; + std::string consumerName; + std::string dispatchConsumptionGuardId; + std::string dispatchConsumerName; + std::string resultHandoffId; + std::string resultConsumerName; + std::string readinessProjectionId; + std::string readinessConsumerName; + std::string statusHandoffId; + std::string statusConsumerName; + std::string publicationGuardId; + std::string publicationConsumerName; + std::string publicationGuardResultHandoffId; + std::string publicationGuardResultConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionId; + std::string publicationGuardResultHandoffReadinessConsumerName; + std::vector issues; + std::string error; + std::string summary; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffInput { + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionResult publicationGuardResultHandoffReadinessProjection; + std::string platform; + std::string adapterName; + std::string ownerName; + std::string handoffId; + std::string loadCallbackBoundaryName; + std::string callbackBindingId; + std::string callbackName; + std::string guardId; + std::string refusalResultId; + std::string propagationId; + std::string dispatchHandoffId; + std::string statusRecordId; + std::string consumerReadinessId; + std::string consumerName; + std::string dispatchConsumptionGuardId; + std::string dispatchConsumerName; + std::string resultHandoffId; + std::string resultConsumerName; + std::string readinessProjectionId; + std::string readinessConsumerName; + std::string statusHandoffId; + std::string statusConsumerName; + std::string publicationGuardId; + std::string publicationConsumerName; + std::string publicationGuardResultHandoffId; + std::string publicationGuardResultConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionId; + std::string publicationGuardResultHandoffReadinessConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffId; + std::string publicationGuardResultHandoffReadinessProjectionStatusConsumerName; + bool publicationGuardResultHandoffReadinessProjectionAccepted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffReviewed = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffRecorded = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffDisabled = true; + bool statusHandoffOwnerMatchesPublicationGuardResultHandoffReadinessProjection = false; + bool statusHandoffBoundaryMatchesPublicationGuardResultHandoffReadinessProjection = false; + bool statusHandoffCallbackMatchesPublicationGuardResultHandoffReadinessProjection = false; + bool statusHandoffPreInvocationGuardMatchesPublicationGuardResultHandoffReadinessProjection = false; + bool statusHandoffRefusalResultMatchesPublicationGuardResultHandoffReadinessProjection = false; + bool statusHandoffPropagationMatchesPublicationGuardResultHandoffReadinessProjection = false; + bool statusHandoffDispatchHandoffMatchesPublicationGuardResultHandoffReadinessProjection = false; + bool statusHandoffStatusRecordMatchesPublicationGuardResultHandoffReadinessProjection = false; + bool statusHandoffConsumerReadinessMatchesPublicationGuardResultHandoffReadinessProjection = false; + bool statusHandoffConsumerNameMatchesPublicationGuardResultHandoffReadinessProjection = false; + bool statusHandoffDispatchConsumptionGuardMatchesPublicationGuardResultHandoffReadinessProjection = false; + bool statusHandoffDispatchConsumerNameMatchesPublicationGuardResultHandoffReadinessProjection = false; + bool statusHandoffResultHandoffMatchesPublicationGuardResultHandoffReadinessProjection = false; + bool statusHandoffResultConsumerNameMatchesPublicationGuardResultHandoffReadinessProjection = false; + bool statusHandoffReadinessProjectionMatchesPublicationGuardResultHandoffReadinessProjection = false; + bool statusHandoffReadinessConsumerNameMatchesPublicationGuardResultHandoffReadinessProjection = false; + bool statusHandoffStatusHandoffMatchesPublicationGuardResultHandoffReadinessProjection = false; + bool statusHandoffStatusConsumerNameMatchesPublicationGuardResultHandoffReadinessProjection = false; + bool statusHandoffPublicationGuardMatchesPublicationGuardResultHandoffReadinessProjection = false; + bool statusHandoffPublicationConsumerNameMatchesPublicationGuardResultHandoffReadinessProjection = false; + bool statusHandoffPublicationGuardResultHandoffMatchesPublicationGuardResultHandoffReadinessProjection = false; + bool statusHandoffPublicationGuardResultConsumerNameMatchesPublicationGuardResultHandoffReadinessProjection = false; + bool statusHandoffPublicationGuardResultHandoffReadinessProjectionMatchesPublicationGuardResultHandoffReadinessProjection = false; + bool statusHandoffPublicationGuardResultHandoffReadinessConsumerNameMatchesPublicationGuardResultHandoffReadinessProjection = false; + bool disabledPublicationGuardResultHandoffReadinessProjectionStatusHandoffRegistered = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffAcceptsReadinessProjectionEvidence = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffReturnsDisabledStatus = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffBlocksDispatchConsumption = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffBlocksDispatchResultExecution = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffBlocksStatusPublication = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffBlocksReadinessPublication = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffBlocksStatusHandoffPublication = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffBlocksPublicationGuardPublication = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffBlocksResultHandoffPublication = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffBlocksReadinessProjectionPublication = true; + bool callbackInvocationStillDisabled = true; + bool callbackInvocationRefused = true; + bool callbackInvocationRefusalReviewed = false; + bool statusHandoffStopsBeforeCallbackInvocation = true; + bool statusHandoffStopsBeforeCallbackResultExecution = true; + bool statusHandoffStopsBeforeDispatchConsumption = true; + bool statusHandoffStopsBeforeDispatchResultExecution = true; + bool statusHandoffStopsBeforeDispatchStatusPublication = true; + bool statusHandoffStopsBeforeReadinessPublication = true; + bool statusHandoffStopsBeforeStatusHandoffPublication = true; + bool statusHandoffStopsBeforePublicationGuardPublication = true; + bool statusHandoffStopsBeforePublicationGuardResultHandoffPublication = true; + bool statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionPublication = true; + bool statusHandoffStopsBeforeStatusPublication = true; + bool statusHandoffStopsBeforePlatformApi = true; + bool statusHandoffRequiresSeparateExecutionBatch = true; + bool statusHandoffProducesNoDynamicHandle = true; + bool statusHandoffStoresNoDynamicHandle = true; + bool statusHandoffReleasesNoDynamicHandle = true; + bool statusHandoffResolvesNoSymbols = true; + bool statusHandoffStoresNoSymbolTable = true; + bool statusHandoffCreatesNoRuntime = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffFailureMappingReviewed = false; + bool unloadExecutionStillDisabled = true; + bool symbolResolutionStillDisabled = true; + bool productionLoaderExecutionDisabled = true; + bool realAdapterExecutionDisabled = true; + bool loadOnlyExecutionDisabled = true; + bool separateExecutionBatchRequired = true; + bool macosDeferredByOperator = true; + + bool callbackInvocationAttempted = false; + bool callbackResultExecutionAttempted = false; + bool dispatchHandoffExecutionAttempted = false; + bool dispatchStatusPublicationAttempted = false; + bool dispatchConsumerConsumptionAttempted = false; + bool dispatchResultExecutionAttempted = false; + bool resultHandoffStatusPublicationAttempted = false; + bool readinessProjectionStatusPublicationAttempted = false; + bool statusHandoffPublicationAttempted = false; + bool publicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool runtimePlatformLoadAttempted = false; + bool runtimePlatformUnloadAttempted = false; + bool runtimePlatformSymbolResolutionAttempted = false; + bool sdxlCallRequested = false; + bool bridgeCallRequested = false; + bool serverConnectivityCheckRequested = false; + bool walletLifecycleRequested = false; + bool syncRequested = false; + bool syncStatusPollingRequested = false; + bool workerQueueRequested = false; + bool walletStateMutationRequested = false; + bool walletPersistenceRequested = false; + bool settingsWriteRequested = false; + bool sendImportExportRequested = false; + bool artifactMutationRequested = false; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffResult { + bool ok = false; + bool noCallbackInvocationAttempted = true; + bool noCallbackResultExecutionAttempted = true; + bool noDispatchHandoffExecutionAttempted = true; + bool noDispatchStatusPublicationAttempted = true; + bool noDispatchConsumerConsumptionAttempted = true; + bool noDispatchResultExecutionAttempted = true; + bool noResultHandoffStatusPublicationAttempted = true; + bool noReadinessProjectionStatusPublicationAttempted = true; + bool noStatusHandoffPublicationAttempted = true; + bool noPublicationGuardPublicationAttempted = true; + bool noPublicationGuardResultHandoffPublicationAttempted = true; + bool noPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = true; + bool noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = true; + bool noRuntimePlatformDynamicLibraryLoaded = true; + bool noRuntimePlatformDynamicLibraryUnloaded = true; + bool noRuntimePlatformSymbolResolution = true; + bool noSdxlCalls = true; + bool noBridgeCalls = true; + bool noServerConnectivityChecked = true; + bool noWalletLifecycle = true; + bool noSyncStarted = true; + bool noSyncStatusPolled = true; + bool noWorkerQueueEnqueue = true; + bool noWalletStateMutation = true; + bool noWalletPersistence = true; + bool noSettingsPersistence = true; + bool noSendImportExportExecution = true; + bool noArtifactMutation = true; + + bool platformAccepted = false; + bool linuxPlatformAccepted = false; + bool windowsPlatformAccepted = false; + bool macosDeferred = false; + bool publicationGuardResultHandoffReadinessProjectionAccepted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffRecordAccepted = false; + bool statusHandoffPublicationGuardResultHandoffReadinessProjectionMatchAccepted = false; + bool disabledPublicationGuardResultHandoffReadinessProjectionStatusHandoffAccepted = false; + bool callbackInvocationRefused = false; + bool dispatchConsumptionStillGuarded = false; + bool dispatchResultExecutionBlocked = false; + bool dispatchStatusPublicationBlocked = false; + bool readinessProjectionPublicationBlocked = false; + bool statusHandoffPublicationBlocked = false; + bool publicationGuardPublicationBlocked = false; + bool publicationGuardResultHandoffPublicationBlocked = false; + bool publicationGuardResultHandoffReadinessProjectionPublicationBlocked = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked = false; + bool platformApiPreInvocationBlocked = false; + bool disabledPublicationGuardResultHandoffReadinessProjectionStatusHandoffStateAccepted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffFailureMappingAccepted = false; + bool unloadExecutionBlocked = false; + bool symbolResolutionBlocked = false; + bool productionLoaderDisabled = false; + bool realAdapterExecutionDisabled = false; + bool loadOnlyExecutionDisabled = false; + bool separateExecutionBatchRequired = false; + bool loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffReady = false; + + LiteBridgeRuntimeStatus status = LiteBridgeRuntimeStatus::Unavailable; + std::string platform; + std::string adapterName; + std::string ownerName; + std::string handoffId; + std::string loadCallbackBoundaryName; + std::string callbackBindingId; + std::string callbackName; + std::string guardId; + std::string refusalResultId; + std::string propagationId; + std::string dispatchHandoffId; + std::string statusRecordId; + std::string consumerReadinessId; + std::string consumerName; + std::string dispatchConsumptionGuardId; + std::string dispatchConsumerName; + std::string resultHandoffId; + std::string resultConsumerName; + std::string readinessProjectionId; + std::string readinessConsumerName; + std::string statusHandoffId; + std::string statusConsumerName; + std::string publicationGuardId; + std::string publicationConsumerName; + std::string publicationGuardResultHandoffId; + std::string publicationGuardResultConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionId; + std::string publicationGuardResultHandoffReadinessConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffId; + std::string publicationGuardResultHandoffReadinessProjectionStatusConsumerName; + std::vector issues; + std::string error; + std::string summary; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardInput { + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffResult publicationGuardResultHandoffReadinessProjectionStatusHandoff; + std::string platform; + std::string adapterName; + std::string ownerName; + std::string handoffId; + std::string loadCallbackBoundaryName; + std::string callbackBindingId; + std::string callbackName; + std::string guardId; + std::string refusalResultId; + std::string propagationId; + std::string dispatchHandoffId; + std::string statusRecordId; + std::string consumerReadinessId; + std::string consumerName; + std::string dispatchConsumptionGuardId; + std::string dispatchConsumerName; + std::string resultHandoffId; + std::string resultConsumerName; + std::string readinessProjectionId; + std::string readinessConsumerName; + std::string statusHandoffId; + std::string statusConsumerName; + std::string publicationGuardId; + std::string publicationConsumerName; + std::string publicationGuardResultHandoffId; + std::string publicationGuardResultConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionId; + std::string publicationGuardResultHandoffReadinessConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffId; + std::string publicationGuardResultHandoffReadinessProjectionStatusConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffAccepted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardReviewed = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardRecorded = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardDisabled = true; + bool publicationGuardOwnerMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoff = false; + bool publicationGuardBoundaryMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoff = false; + bool publicationGuardCallbackMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoff = false; + bool publicationGuardPreInvocationGuardMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoff = false; + bool publicationGuardRefusalResultMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoff = false; + bool publicationGuardPropagationMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoff = false; + bool publicationGuardDispatchHandoffMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoff = false; + bool publicationGuardStatusRecordMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoff = false; + bool publicationGuardConsumerReadinessMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoff = false; + bool publicationGuardConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoff = false; + bool publicationGuardDispatchConsumptionGuardMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoff = false; + bool publicationGuardDispatchConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoff = false; + bool publicationGuardResultHandoffMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoff = false; + bool publicationGuardResultConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoff = false; + bool publicationGuardReadinessProjectionMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoff = false; + bool publicationGuardReadinessConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoff = false; + bool publicationGuardStatusHandoffMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoff = false; + bool publicationGuardStatusConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoff = false; + bool publicationGuardPublicationGuardMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoff = false; + bool publicationGuardPublicationConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoff = false; + bool publicationGuardPublicationGuardResultHandoffMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoff = false; + bool publicationGuardPublicationGuardResultConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoff = false; + bool publicationGuardPublicationGuardResultHandoffReadinessProjectionMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoff = false; + bool publicationGuardPublicationGuardResultHandoffReadinessConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoff = false; + bool publicationGuardPublicationGuardResultHandoffReadinessProjectionStatusHandoffMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoff = false; + bool publicationGuardPublicationGuardResultHandoffReadinessProjectionStatusConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoff = false; + bool disabledPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardRegistered = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardAcceptsStatusHandoffEvidence = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardReturnsDisabledPublication = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlocksDispatchConsumption = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlocksDispatchResultExecution = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlocksStatusPublication = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlocksReadinessPublication = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlocksStatusHandoffPublication = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlocksPublicationGuardPublication = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlocksResultHandoffPublication = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlocksReadinessProjectionPublication = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlocksStatusHandoffResultPublication = true; + bool callbackInvocationStillDisabled = true; + bool callbackInvocationRefused = true; + bool callbackInvocationRefusalReviewed = false; + bool publicationGuardStopsBeforeCallbackInvocation = true; + bool publicationGuardStopsBeforeCallbackResultExecution = true; + bool publicationGuardStopsBeforeDispatchConsumption = true; + bool publicationGuardStopsBeforeDispatchResultExecution = true; + bool publicationGuardStopsBeforeDispatchStatusPublication = true; + bool publicationGuardStopsBeforeReadinessPublication = true; + bool publicationGuardStopsBeforeStatusHandoffPublication = true; + bool publicationGuardStopsBeforePublicationGuardPublication = true; + bool publicationGuardStopsBeforePublicationGuardResultHandoffPublication = true; + bool publicationGuardStopsBeforePublicationGuardResultHandoffReadinessProjectionPublication = true; + bool publicationGuardStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication = true; + bool publicationGuardStopsBeforePublication = true; + bool publicationGuardStopsBeforePlatformApi = true; + bool publicationGuardRequiresSeparateExecutionBatch = true; + bool publicationGuardProducesNoDynamicHandle = true; + bool publicationGuardStoresNoDynamicHandle = true; + bool publicationGuardReleasesNoDynamicHandle = true; + bool publicationGuardResolvesNoSymbols = true; + bool publicationGuardStoresNoSymbolTable = true; + bool publicationGuardCreatesNoRuntime = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardFailureMappingReviewed = false; + bool unloadExecutionStillDisabled = true; + bool symbolResolutionStillDisabled = true; + bool productionLoaderExecutionDisabled = true; + bool realAdapterExecutionDisabled = true; + bool loadOnlyExecutionDisabled = true; + bool separateExecutionBatchRequired = true; + bool macosDeferredByOperator = true; + + bool callbackInvocationAttempted = false; + bool callbackResultExecutionAttempted = false; + bool dispatchHandoffExecutionAttempted = false; + bool dispatchStatusPublicationAttempted = false; + bool dispatchConsumerConsumptionAttempted = false; + bool dispatchResultExecutionAttempted = false; + bool resultHandoffStatusPublicationAttempted = false; + bool readinessProjectionStatusPublicationAttempted = false; + bool statusHandoffPublicationAttempted = false; + bool publicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = false; + bool runtimePlatformLoadAttempted = false; + bool runtimePlatformUnloadAttempted = false; + bool runtimePlatformSymbolResolutionAttempted = false; + bool sdxlCallRequested = false; + bool bridgeCallRequested = false; + bool serverConnectivityCheckRequested = false; + bool walletLifecycleRequested = false; + bool syncRequested = false; + bool syncStatusPollingRequested = false; + bool workerQueueRequested = false; + bool walletStateMutationRequested = false; + bool walletPersistenceRequested = false; + bool settingsWriteRequested = false; + bool sendImportExportRequested = false; + bool artifactMutationRequested = false; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResult { + bool ok = false; + bool noCallbackInvocationAttempted = true; + bool noCallbackResultExecutionAttempted = true; + bool noDispatchHandoffExecutionAttempted = true; + bool noDispatchStatusPublicationAttempted = true; + bool noDispatchConsumerConsumptionAttempted = true; + bool noDispatchResultExecutionAttempted = true; + bool noResultHandoffStatusPublicationAttempted = true; + bool noReadinessProjectionStatusPublicationAttempted = true; + bool noStatusHandoffPublicationAttempted = true; + bool noPublicationGuardPublicationAttempted = true; + bool noPublicationGuardResultHandoffPublicationAttempted = true; + bool noPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = true; + bool noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = true; + bool noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = true; + bool noRuntimePlatformDynamicLibraryLoaded = true; + bool noRuntimePlatformDynamicLibraryUnloaded = true; + bool noRuntimePlatformSymbolResolution = true; + bool noSdxlCalls = true; + bool noBridgeCalls = true; + bool noServerConnectivityChecked = true; + bool noWalletLifecycle = true; + bool noSyncStarted = true; + bool noSyncStatusPolled = true; + bool noWorkerQueueEnqueue = true; + bool noWalletStateMutation = true; + bool noWalletPersistence = true; + bool noSettingsPersistence = true; + bool noSendImportExportExecution = true; + bool noArtifactMutation = true; + + bool platformAccepted = false; + bool linuxPlatformAccepted = false; + bool windowsPlatformAccepted = false; + bool macosDeferred = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffAccepted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardRecordAccepted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardMatchAccepted = false; + bool disabledPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardAccepted = false; + bool callbackInvocationRefused = false; + bool dispatchConsumptionStillGuarded = false; + bool dispatchResultExecutionBlocked = false; + bool dispatchStatusPublicationBlocked = false; + bool readinessProjectionPublicationBlocked = false; + bool statusHandoffPublicationBlocked = false; + bool publicationGuardPublicationBlocked = false; + bool publicationGuardResultHandoffPublicationBlocked = false; + bool publicationGuardResultHandoffReadinessProjectionPublicationBlocked = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked = false; + bool platformApiPreInvocationBlocked = false; + bool disabledPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardStateAccepted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardFailureMappingAccepted = false; + bool unloadExecutionBlocked = false; + bool symbolResolutionBlocked = false; + bool productionLoaderDisabled = false; + bool realAdapterExecutionDisabled = false; + bool loadOnlyExecutionDisabled = false; + bool separateExecutionBatchRequired = false; + bool loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardReady = false; + + LiteBridgeRuntimeStatus status = LiteBridgeRuntimeStatus::Unavailable; + std::string platform; + std::string adapterName; + std::string ownerName; + std::string handoffId; + std::string loadCallbackBoundaryName; + std::string callbackBindingId; + std::string callbackName; + std::string guardId; + std::string refusalResultId; + std::string propagationId; + std::string dispatchHandoffId; + std::string statusRecordId; + std::string consumerReadinessId; + std::string consumerName; + std::string dispatchConsumptionGuardId; + std::string dispatchConsumerName; + std::string resultHandoffId; + std::string resultConsumerName; + std::string readinessProjectionId; + std::string readinessConsumerName; + std::string statusHandoffId; + std::string statusConsumerName; + std::string publicationGuardId; + std::string publicationConsumerName; + std::string publicationGuardResultHandoffId; + std::string publicationGuardResultConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionId; + std::string publicationGuardResultHandoffReadinessConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffId; + std::string publicationGuardResultHandoffReadinessProjectionStatusConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName; + std::vector issues; + std::string error; + std::string summary; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffInput { + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResult publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard; + std::string platform; + std::string adapterName; + std::string ownerName; + std::string handoffId; + std::string loadCallbackBoundaryName; + std::string callbackBindingId; + std::string callbackName; + std::string guardId; + std::string refusalResultId; + std::string propagationId; + std::string dispatchHandoffId; + std::string statusRecordId; + std::string consumerReadinessId; + std::string consumerName; + std::string dispatchConsumptionGuardId; + std::string dispatchConsumerName; + std::string resultHandoffId; + std::string resultConsumerName; + std::string readinessProjectionId; + std::string readinessConsumerName; + std::string statusHandoffId; + std::string statusConsumerName; + std::string publicationGuardId; + std::string publicationConsumerName; + std::string publicationGuardResultHandoffId; + std::string publicationGuardResultConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionId; + std::string publicationGuardResultHandoffReadinessConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffId; + std::string publicationGuardResultHandoffReadinessProjectionStatusConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardAccepted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReviewed = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffRecorded = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffDisabled = true; + bool resultHandoffOwnerMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard = false; + bool resultHandoffBoundaryMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard = false; + bool resultHandoffCallbackMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard = false; + bool resultHandoffPreInvocationGuardMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard = false; + bool resultHandoffRefusalResultMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard = false; + bool resultHandoffPropagationMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard = false; + bool resultHandoffDispatchHandoffMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard = false; + bool resultHandoffStatusRecordMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard = false; + bool resultHandoffConsumerReadinessMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard = false; + bool resultHandoffConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard = false; + bool resultHandoffDispatchConsumptionGuardMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard = false; + bool resultHandoffDispatchConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard = false; + bool resultHandoffResultHandoffMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard = false; + bool resultHandoffResultConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard = false; + bool resultHandoffReadinessProjectionMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard = false; + bool resultHandoffReadinessConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard = false; + bool resultHandoffStatusHandoffMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard = false; + bool resultHandoffStatusConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard = false; + bool resultHandoffPublicationGuardMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard = false; + bool resultHandoffPublicationConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard = false; + bool resultHandoffPublicationGuardResultHandoffMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard = false; + bool resultHandoffPublicationGuardResultConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard = false; + bool resultHandoffPublicationGuardResultHandoffReadinessProjectionMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard = false; + bool resultHandoffPublicationGuardResultHandoffReadinessConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard = false; + bool resultHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard = false; + bool resultHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard = false; + bool resultHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard = false; + bool resultHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard = false; + bool disabledPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffRegistered = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffAcceptsPublicationGuardEvidence = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReturnsDisabledResult = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlocksDispatchConsumption = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlocksDispatchResultExecution = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlocksStatusPublication = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlocksReadinessPublication = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlocksStatusHandoffPublication = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlocksPublicationGuardPublication = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlocksPublicationGuardResultHandoffPublication = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlocksReadinessProjectionPublication = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlocksStatusHandoffResultPublication = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffBlocksPublicationGuardResultPublication = true; + bool callbackInvocationStillDisabled = true; + bool callbackInvocationRefused = true; + bool callbackInvocationRefusalReviewed = false; + bool resultHandoffStopsBeforeCallbackInvocation = true; + bool resultHandoffStopsBeforeCallbackResultExecution = true; + bool resultHandoffStopsBeforeDispatchConsumption = true; + bool resultHandoffStopsBeforeDispatchResultExecution = true; + bool resultHandoffStopsBeforeDispatchStatusPublication = true; + bool resultHandoffStopsBeforeReadinessPublication = true; + bool resultHandoffStopsBeforeStatusHandoffPublication = true; + bool resultHandoffStopsBeforePublicationGuardPublication = true; + bool resultHandoffStopsBeforePublicationGuardResultHandoffPublication = true; + bool resultHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionPublication = true; + bool resultHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication = true; + bool resultHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication = true; + bool resultHandoffStopsBeforeResultPublication = true; + bool resultHandoffStopsBeforePlatformApi = true; + bool resultHandoffRequiresSeparateExecutionBatch = true; + bool resultHandoffProducesNoDynamicHandle = true; + bool resultHandoffStoresNoDynamicHandle = true; + bool resultHandoffReleasesNoDynamicHandle = true; + bool resultHandoffResolvesNoSymbols = true; + bool resultHandoffStoresNoSymbolTable = true; + bool resultHandoffCreatesNoRuntime = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffFailureMappingReviewed = false; + bool unloadExecutionStillDisabled = true; + bool symbolResolutionStillDisabled = true; + bool productionLoaderExecutionDisabled = true; + bool realAdapterExecutionDisabled = true; + bool loadOnlyExecutionDisabled = true; + bool separateExecutionBatchRequired = true; + bool macosDeferredByOperator = true; + + bool callbackInvocationAttempted = false; + bool callbackResultExecutionAttempted = false; + bool dispatchHandoffExecutionAttempted = false; + bool dispatchStatusPublicationAttempted = false; + bool dispatchConsumerConsumptionAttempted = false; + bool dispatchResultExecutionAttempted = false; + bool resultHandoffStatusPublicationAttempted = false; + bool readinessProjectionStatusPublicationAttempted = false; + bool statusHandoffPublicationAttempted = false; + bool publicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = false; + bool runtimePlatformLoadAttempted = false; + bool runtimePlatformUnloadAttempted = false; + bool runtimePlatformSymbolResolutionAttempted = false; + bool sdxlCallRequested = false; + bool bridgeCallRequested = false; + bool serverConnectivityCheckRequested = false; + bool walletLifecycleRequested = false; + bool syncRequested = false; + bool syncStatusPollingRequested = false; + bool workerQueueRequested = false; + bool walletStateMutationRequested = false; + bool walletPersistenceRequested = false; + bool settingsWriteRequested = false; + bool sendImportExportRequested = false; + bool artifactMutationRequested = false; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffResult { + bool ok = false; + bool noCallbackInvocationAttempted = true; + bool noCallbackResultExecutionAttempted = true; + bool noDispatchHandoffExecutionAttempted = true; + bool noDispatchStatusPublicationAttempted = true; + bool noDispatchConsumerConsumptionAttempted = true; + bool noDispatchResultExecutionAttempted = true; + bool noResultHandoffStatusPublicationAttempted = true; + bool noReadinessProjectionStatusPublicationAttempted = true; + bool noStatusHandoffPublicationAttempted = true; + bool noPublicationGuardPublicationAttempted = true; + bool noPublicationGuardResultHandoffPublicationAttempted = true; + bool noPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = true; + bool noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = true; + bool noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = true; + bool noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = true; + bool noRuntimePlatformDynamicLibraryLoaded = true; + bool noRuntimePlatformDynamicLibraryUnloaded = true; + bool noRuntimePlatformSymbolResolution = true; + bool noSdxlCalls = true; + bool noBridgeCalls = true; + bool noServerConnectivityChecked = true; + bool noWalletLifecycle = true; + bool noSyncStarted = true; + bool noSyncStatusPolled = true; + bool noWorkerQueueEnqueue = true; + bool noWalletStateMutation = true; + bool noWalletPersistence = true; + bool noSettingsPersistence = true; + bool noSendImportExportExecution = true; + bool noArtifactMutation = true; + + bool platformAccepted = false; + bool linuxPlatformAccepted = false; + bool windowsPlatformAccepted = false; + bool macosDeferred = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardAccepted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffRecordAccepted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffMatchAccepted = false; + bool disabledPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffAccepted = false; + bool callbackInvocationRefused = false; + bool dispatchConsumptionStillGuarded = false; + bool dispatchResultExecutionBlocked = false; + bool dispatchStatusPublicationBlocked = false; + bool readinessProjectionPublicationBlocked = false; + bool statusHandoffPublicationBlocked = false; + bool publicationGuardPublicationBlocked = false; + bool publicationGuardResultHandoffPublicationBlocked = false; + bool publicationGuardResultHandoffReadinessProjectionPublicationBlocked = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationBlocked = false; + bool platformApiPreInvocationBlocked = false; + bool disabledPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffStateAccepted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffFailureMappingAccepted = false; + bool unloadExecutionBlocked = false; + bool symbolResolutionBlocked = false; + bool productionLoaderDisabled = false; + bool realAdapterExecutionDisabled = false; + bool loadOnlyExecutionDisabled = false; + bool separateExecutionBatchRequired = false; + bool loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReady = false; + + LiteBridgeRuntimeStatus status = LiteBridgeRuntimeStatus::Unavailable; + std::string platform; + std::string adapterName; + std::string ownerName; + std::string handoffId; + std::string loadCallbackBoundaryName; + std::string callbackBindingId; + std::string callbackName; + std::string guardId; + std::string refusalResultId; + std::string propagationId; + std::string dispatchHandoffId; + std::string statusRecordId; + std::string consumerReadinessId; + std::string consumerName; + std::string dispatchConsumptionGuardId; + std::string dispatchConsumerName; + std::string resultHandoffId; + std::string resultConsumerName; + std::string readinessProjectionId; + std::string readinessConsumerName; + std::string statusHandoffId; + std::string statusConsumerName; + std::string publicationGuardId; + std::string publicationConsumerName; + std::string publicationGuardResultHandoffId; + std::string publicationGuardResultConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionId; + std::string publicationGuardResultHandoffReadinessConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffId; + std::string publicationGuardResultHandoffReadinessProjectionStatusConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName; + std::vector issues; + std::string error; + std::string summary; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionInput { + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffResult publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff; + std::string platform; + std::string adapterName; + std::string ownerName; + std::string handoffId; + std::string loadCallbackBoundaryName; + std::string callbackBindingId; + std::string callbackName; + std::string guardId; + std::string refusalResultId; + std::string propagationId; + std::string dispatchHandoffId; + std::string statusRecordId; + std::string consumerReadinessId; + std::string consumerName; + std::string dispatchConsumptionGuardId; + std::string dispatchConsumerName; + std::string resultHandoffId; + std::string resultConsumerName; + std::string readinessProjectionId; + std::string readinessConsumerName; + std::string statusHandoffId; + std::string statusConsumerName; + std::string publicationGuardId; + std::string publicationConsumerName; + std::string publicationGuardResultHandoffId; + std::string publicationGuardResultConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionId; + std::string publicationGuardResultHandoffReadinessConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffId; + std::string publicationGuardResultHandoffReadinessProjectionStatusConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffAccepted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionReviewed = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionRecorded = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionDisabled = true; + bool projectionOwnerMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff = false; + bool projectionBoundaryMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff = false; + bool projectionCallbackMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff = false; + bool projectionPreInvocationGuardMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff = false; + bool projectionRefusalResultMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff = false; + bool projectionPropagationMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff = false; + bool projectionDispatchHandoffMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff = false; + bool projectionStatusRecordMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff = false; + bool projectionConsumerReadinessMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff = false; + bool projectionConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff = false; + bool projectionDispatchConsumptionGuardMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff = false; + bool projectionDispatchConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff = false; + bool projectionResultHandoffMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff = false; + bool projectionResultConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff = false; + bool projectionReadinessProjectionMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff = false; + bool projectionReadinessConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff = false; + bool projectionStatusHandoffMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff = false; + bool projectionStatusConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff = false; + bool projectionPublicationGuardMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff = false; + bool projectionPublicationConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff = false; + bool projectionPublicationGuardResultHandoffMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff = false; + bool projectionPublicationGuardResultConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff = false; + bool projectionPublicationGuardResultHandoffReadinessProjectionMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff = false; + bool projectionPublicationGuardResultHandoffReadinessConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff = false; + bool projectionPublicationGuardResultHandoffReadinessProjectionStatusHandoffMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff = false; + bool projectionPublicationGuardResultHandoffReadinessProjectionStatusConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff = false; + bool projectionPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff = false; + bool projectionPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff = false; + bool projectionPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff = false; + bool projectionPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff = false; + bool disabledPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionRegistered = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionAcceptsResultHandoffEvidence = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionReturnsDisabledReadiness = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlocksDispatchConsumption = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlocksDispatchResultExecution = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlocksStatusPublication = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlocksReadinessPublication = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlocksStatusHandoffPublication = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlocksPublicationGuardPublication = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlocksPublicationGuardResultHandoffPublication = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlocksReadinessProjectionPublication = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlocksStatusHandoffResultPublication = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlocksPublicationGuardResultPublication = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionBlocksPublicationGuardResultHandoffResultPublication = true; + bool callbackInvocationStillDisabled = true; + bool callbackInvocationRefused = true; + bool callbackInvocationRefusalReviewed = false; + bool projectionStopsBeforeCallbackInvocation = true; + bool projectionStopsBeforeCallbackResultExecution = true; + bool projectionStopsBeforeDispatchConsumption = true; + bool projectionStopsBeforeDispatchResultExecution = true; + bool projectionStopsBeforeDispatchStatusPublication = true; + bool projectionStopsBeforeReadinessPublication = true; + bool projectionStopsBeforeStatusHandoffPublication = true; + bool projectionStopsBeforePublicationGuardPublication = true; + bool projectionStopsBeforePublicationGuardResultHandoffPublication = true; + bool projectionStopsBeforePublicationGuardResultHandoffReadinessProjectionPublication = true; + bool projectionStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication = true; + bool projectionStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication = true; + bool projectionStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication = true; + bool projectionStopsBeforeReadinessProjectionPublication = true; + bool projectionStopsBeforePlatformApi = true; + bool projectionRequiresSeparateExecutionBatch = true; + bool projectionProducesNoDynamicHandle = true; + bool projectionStoresNoDynamicHandle = true; + bool projectionReleasesNoDynamicHandle = true; + bool projectionResolvesNoSymbols = true; + bool projectionStoresNoSymbolTable = true; + bool projectionCreatesNoRuntime = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionFailureMappingReviewed = false; + bool unloadExecutionStillDisabled = true; + bool symbolResolutionStillDisabled = true; + bool productionLoaderExecutionDisabled = true; + bool realAdapterExecutionDisabled = true; + bool loadOnlyExecutionDisabled = true; + bool separateExecutionBatchRequired = true; + bool macosDeferredByOperator = true; + + bool callbackInvocationAttempted = false; + bool callbackResultExecutionAttempted = false; + bool dispatchHandoffExecutionAttempted = false; + bool dispatchStatusPublicationAttempted = false; + bool dispatchConsumerConsumptionAttempted = false; + bool dispatchResultExecutionAttempted = false; + bool resultHandoffStatusPublicationAttempted = false; + bool readinessProjectionStatusPublicationAttempted = false; + bool statusHandoffPublicationAttempted = false; + bool publicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool runtimePlatformLoadAttempted = false; + bool runtimePlatformUnloadAttempted = false; + bool runtimePlatformSymbolResolutionAttempted = false; + bool sdxlCallRequested = false; + bool bridgeCallRequested = false; + bool serverConnectivityCheckRequested = false; + bool walletLifecycleRequested = false; + bool syncRequested = false; + bool syncStatusPollingRequested = false; + bool workerQueueRequested = false; + bool walletStateMutationRequested = false; + bool walletPersistenceRequested = false; + bool settingsWriteRequested = false; + bool sendImportExportRequested = false; + bool artifactMutationRequested = false; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionResult { + bool ok = false; + bool noCallbackInvocationAttempted = true; + bool noCallbackResultExecutionAttempted = true; + bool noDispatchHandoffExecutionAttempted = true; + bool noDispatchStatusPublicationAttempted = true; + bool noDispatchConsumerConsumptionAttempted = true; + bool noDispatchResultExecutionAttempted = true; + bool noResultHandoffStatusPublicationAttempted = true; + bool noReadinessProjectionStatusPublicationAttempted = true; + bool noStatusHandoffPublicationAttempted = true; + bool noPublicationGuardPublicationAttempted = true; + bool noPublicationGuardResultHandoffPublicationAttempted = true; + bool noPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = true; + bool noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = true; + bool noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = true; + bool noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = true; + bool noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = true; + bool noRuntimePlatformDynamicLibraryLoaded = true; + bool noRuntimePlatformDynamicLibraryUnloaded = true; + bool noRuntimePlatformSymbolResolution = true; + bool noSdxlCalls = true; + bool noBridgeCalls = true; + bool noServerConnectivityChecked = true; + bool noWalletLifecycle = true; + bool noSyncStarted = true; + bool noSyncStatusPolled = true; + bool noWorkerQueueEnqueue = true; + bool noWalletStateMutation = true; + bool noWalletPersistence = true; + bool noSettingsPersistence = true; + bool noSendImportExportExecution = true; + bool noArtifactMutation = true; + + bool platformAccepted = false; + bool linuxPlatformAccepted = false; + bool windowsPlatformAccepted = false; + bool macosDeferred = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffAccepted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionRecordAccepted = false; + bool projectionPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffMatchAccepted = false; + bool disabledPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionAccepted = false; + bool callbackInvocationRefused = false; + bool dispatchConsumptionStillGuarded = false; + bool dispatchResultExecutionBlocked = false; + bool dispatchStatusPublicationBlocked = false; + bool readinessProjectionPublicationBlocked = false; + bool statusHandoffPublicationBlocked = false; + bool publicationGuardPublicationBlocked = false; + bool publicationGuardResultHandoffPublicationBlocked = false; + bool publicationGuardResultHandoffReadinessProjectionPublicationBlocked = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationBlocked = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationBlocked = false; + bool platformApiPreInvocationBlocked = false; + bool disabledPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStateAccepted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionFailureMappingAccepted = false; + bool unloadExecutionBlocked = false; + bool symbolResolutionBlocked = false; + bool productionLoaderDisabled = false; + bool realAdapterExecutionDisabled = false; + bool loadOnlyExecutionDisabled = false; + bool separateExecutionBatchRequired = false; + bool loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionReady = false; + + LiteBridgeRuntimeStatus status = LiteBridgeRuntimeStatus::Unavailable; + std::string platform; + std::string adapterName; + std::string ownerName; + std::string handoffId; + std::string loadCallbackBoundaryName; + std::string callbackBindingId; + std::string callbackName; + std::string guardId; + std::string refusalResultId; + std::string propagationId; + std::string dispatchHandoffId; + std::string statusRecordId; + std::string consumerReadinessId; + std::string consumerName; + std::string dispatchConsumptionGuardId; + std::string dispatchConsumerName; + std::string resultHandoffId; + std::string resultConsumerName; + std::string readinessProjectionId; + std::string readinessConsumerName; + std::string statusHandoffId; + std::string statusConsumerName; + std::string publicationGuardId; + std::string publicationConsumerName; + std::string publicationGuardResultHandoffId; + std::string publicationGuardResultConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionId; + std::string publicationGuardResultHandoffReadinessConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffId; + std::string publicationGuardResultHandoffReadinessProjectionStatusConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName; + std::vector issues; + std::string error; + std::string summary; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffInput { + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionResult publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection; + std::string platform; + std::string adapterName; + std::string ownerName; + std::string handoffId; + std::string loadCallbackBoundaryName; + std::string callbackBindingId; + std::string callbackName; + std::string guardId; + std::string refusalResultId; + std::string propagationId; + std::string dispatchHandoffId; + std::string statusRecordId; + std::string consumerReadinessId; + std::string consumerName; + std::string dispatchConsumptionGuardId; + std::string dispatchConsumerName; + std::string resultHandoffId; + std::string resultConsumerName; + std::string readinessProjectionId; + std::string readinessConsumerName; + std::string statusHandoffId; + std::string statusConsumerName; + std::string publicationGuardId; + std::string publicationConsumerName; + std::string publicationGuardResultHandoffId; + std::string publicationGuardResultConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionId; + std::string publicationGuardResultHandoffReadinessConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffId; + std::string publicationGuardResultHandoffReadinessProjectionStatusConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionAccepted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffReviewed = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffRecorded = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffDisabled = true; + bool statusHandoffOwnerMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection = false; + bool statusHandoffBoundaryMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection = false; + bool statusHandoffCallbackMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection = false; + bool statusHandoffPreInvocationGuardMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection = false; + bool statusHandoffRefusalResultMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection = false; + bool statusHandoffPropagationMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection = false; + bool statusHandoffDispatchHandoffMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection = false; + bool statusHandoffStatusRecordMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection = false; + bool statusHandoffConsumerReadinessMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection = false; + bool statusHandoffConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection = false; + bool statusHandoffDispatchConsumptionGuardMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection = false; + bool statusHandoffDispatchConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection = false; + bool statusHandoffResultHandoffMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection = false; + bool statusHandoffResultConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection = false; + bool statusHandoffReadinessProjectionMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection = false; + bool statusHandoffReadinessConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection = false; + bool statusHandoffStatusHandoffMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection = false; + bool statusHandoffStatusConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection = false; + bool statusHandoffPublicationGuardMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection = false; + bool statusHandoffPublicationConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection = false; + bool statusHandoffPublicationGuardResultHandoffMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection = false; + bool statusHandoffPublicationGuardResultConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection = false; + bool statusHandoffPublicationGuardResultHandoffReadinessProjectionMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection = false; + bool statusHandoffPublicationGuardResultHandoffReadinessConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection = false; + bool statusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection = false; + bool statusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection = false; + bool statusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection = false; + bool statusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection = false; + bool statusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection = false; + bool statusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection = false; + bool statusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection = false; + bool statusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection = false; + bool disabledPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffRegistered = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffAcceptsReadinessProjectionEvidence = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffReturnsDisabledStatus = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlocksDispatchConsumption = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlocksDispatchResultExecution = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlocksStatusPublication = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlocksReadinessPublication = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlocksStatusHandoffPublication = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlocksPublicationGuardPublication = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlocksPublicationGuardResultHandoffPublication = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlocksReadinessProjectionPublication = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlocksStatusHandoffResultPublication = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlocksPublicationGuardResultPublication = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlocksPublicationGuardResultHandoffResultPublication = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffBlocksPublicationGuardResultHandoffReadinessProjectionPublication = true; + bool callbackInvocationStillDisabled = true; + bool callbackInvocationRefused = true; + bool callbackInvocationRefusalReviewed = false; + bool statusHandoffStopsBeforeCallbackInvocation = true; + bool statusHandoffStopsBeforeCallbackResultExecution = true; + bool statusHandoffStopsBeforeDispatchConsumption = true; + bool statusHandoffStopsBeforeDispatchResultExecution = true; + bool statusHandoffStopsBeforeDispatchStatusPublication = true; + bool statusHandoffStopsBeforeReadinessPublication = true; + bool statusHandoffStopsBeforeStatusHandoffPublication = true; + bool statusHandoffStopsBeforePublicationGuardPublication = true; + bool statusHandoffStopsBeforePublicationGuardResultHandoffPublication = true; + bool statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionPublication = true; + bool statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication = true; + bool statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication = true; + bool statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication = true; + bool statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication = true; + bool statusHandoffStopsBeforeStatusPublication = true; + bool statusHandoffStopsBeforePlatformApi = true; + bool statusHandoffRequiresSeparateExecutionBatch = true; + bool statusHandoffProducesNoDynamicHandle = true; + bool statusHandoffStoresNoDynamicHandle = true; + bool statusHandoffReleasesNoDynamicHandle = true; + bool statusHandoffResolvesNoSymbols = true; + bool statusHandoffStoresNoSymbolTable = true; + bool statusHandoffCreatesNoRuntime = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffFailureMappingReviewed = false; + bool unloadExecutionStillDisabled = true; + bool symbolResolutionStillDisabled = true; + bool productionLoaderExecutionDisabled = true; + bool realAdapterExecutionDisabled = true; + bool loadOnlyExecutionDisabled = true; + bool separateExecutionBatchRequired = true; + bool macosDeferredByOperator = true; + + bool callbackInvocationAttempted = false; + bool callbackResultExecutionAttempted = false; + bool dispatchHandoffExecutionAttempted = false; + bool dispatchStatusPublicationAttempted = false; + bool dispatchConsumerConsumptionAttempted = false; + bool dispatchResultExecutionAttempted = false; + bool resultHandoffStatusPublicationAttempted = false; + bool readinessProjectionStatusPublicationAttempted = false; + bool statusHandoffPublicationAttempted = false; + bool publicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool runtimePlatformLoadAttempted = false; + bool runtimePlatformUnloadAttempted = false; + bool runtimePlatformSymbolResolutionAttempted = false; + bool sdxlCallRequested = false; + bool bridgeCallRequested = false; + bool serverConnectivityCheckRequested = false; + bool walletLifecycleRequested = false; + bool syncRequested = false; + bool syncStatusPollingRequested = false; + bool workerQueueRequested = false; + bool walletStateMutationRequested = false; + bool walletPersistenceRequested = false; + bool settingsWriteRequested = false; + bool sendImportExportRequested = false; + bool artifactMutationRequested = false; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffResult { + bool ok = false; + bool noCallbackInvocationAttempted = true; + bool noCallbackResultExecutionAttempted = true; + bool noDispatchHandoffExecutionAttempted = true; + bool noDispatchStatusPublicationAttempted = true; + bool noDispatchConsumerConsumptionAttempted = true; + bool noDispatchResultExecutionAttempted = true; + bool noResultHandoffStatusPublicationAttempted = true; + bool noReadinessProjectionStatusPublicationAttempted = true; + bool noStatusHandoffPublicationAttempted = true; + bool noPublicationGuardPublicationAttempted = true; + bool noPublicationGuardResultHandoffPublicationAttempted = true; + bool noPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = true; + bool noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = true; + bool noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = true; + bool noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = true; + bool noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = true; + bool noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = true; + bool noRuntimePlatformDynamicLibraryLoaded = true; + bool noRuntimePlatformDynamicLibraryUnloaded = true; + bool noRuntimePlatformSymbolResolution = true; + bool noSdxlCalls = true; + bool noBridgeCalls = true; + bool noServerConnectivityChecked = true; + bool noWalletLifecycle = true; + bool noSyncStarted = true; + bool noSyncStatusPolled = true; + bool noWorkerQueueEnqueue = true; + bool noWalletStateMutation = true; + bool noWalletPersistence = true; + bool noSettingsPersistence = true; + bool noSendImportExportExecution = true; + bool noArtifactMutation = true; + + bool platformAccepted = false; + bool linuxPlatformAccepted = false; + bool windowsPlatformAccepted = false; + bool macosDeferred = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionAccepted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffRecordAccepted = false; + bool statusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionMatchAccepted = false; + bool disabledPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffAccepted = false; + bool callbackInvocationRefused = false; + bool dispatchConsumptionStillGuarded = false; + bool dispatchResultExecutionBlocked = false; + bool dispatchStatusPublicationBlocked = false; + bool readinessProjectionPublicationBlocked = false; + bool statusHandoffPublicationBlocked = false; + bool publicationGuardPublicationBlocked = false; + bool publicationGuardResultHandoffPublicationBlocked = false; + bool publicationGuardResultHandoffReadinessProjectionPublicationBlocked = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationBlocked = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationBlocked = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked = false; + bool platformApiPreInvocationBlocked = false; + bool disabledPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffStateAccepted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffFailureMappingAccepted = false; + bool unloadExecutionBlocked = false; + bool symbolResolutionBlocked = false; + bool productionLoaderDisabled = false; + bool realAdapterExecutionDisabled = false; + bool loadOnlyExecutionDisabled = false; + bool separateExecutionBatchRequired = false; + bool loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffReady = false; + + LiteBridgeRuntimeStatus status = LiteBridgeRuntimeStatus::Unavailable; + std::string platform; + std::string adapterName; + std::string ownerName; + std::string handoffId; + std::string loadCallbackBoundaryName; + std::string callbackBindingId; + std::string callbackName; + std::string guardId; + std::string refusalResultId; + std::string propagationId; + std::string dispatchHandoffId; + std::string statusRecordId; + std::string consumerReadinessId; + std::string consumerName; + std::string dispatchConsumptionGuardId; + std::string dispatchConsumerName; + std::string resultHandoffId; + std::string resultConsumerName; + std::string readinessProjectionId; + std::string readinessConsumerName; + std::string statusHandoffId; + std::string statusConsumerName; + std::string publicationGuardId; + std::string publicationConsumerName; + std::string publicationGuardResultHandoffId; + std::string publicationGuardResultConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionId; + std::string publicationGuardResultHandoffReadinessConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffId; + std::string publicationGuardResultHandoffReadinessProjectionStatusConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName; + std::vector issues; + std::string error; + std::string summary; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardInput { + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffResult publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff; + std::string platform; + std::string adapterName; + std::string ownerName; + std::string handoffId; + std::string loadCallbackBoundaryName; + std::string callbackBindingId; + std::string callbackName; + std::string guardId; + std::string refusalResultId; + std::string propagationId; + std::string dispatchHandoffId; + std::string statusRecordId; + std::string consumerReadinessId; + std::string consumerName; + std::string dispatchConsumptionGuardId; + std::string dispatchConsumerName; + std::string resultHandoffId; + std::string resultConsumerName; + std::string readinessProjectionId; + std::string readinessConsumerName; + std::string statusHandoffId; + std::string statusConsumerName; + std::string publicationGuardId; + std::string publicationConsumerName; + std::string publicationGuardResultHandoffId; + std::string publicationGuardResultConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionId; + std::string publicationGuardResultHandoffReadinessConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffId; + std::string publicationGuardResultHandoffReadinessProjectionStatusConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffAccepted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardReviewed = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardRecorded = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardDisabled = true; + bool publicationGuardOwnerMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff = false; + bool publicationGuardBoundaryMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff = false; + bool publicationGuardCallbackMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff = false; + bool publicationGuardPreInvocationGuardMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff = false; + bool publicationGuardRefusalResultMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff = false; + bool publicationGuardPropagationMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff = false; + bool publicationGuardDispatchHandoffMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff = false; + bool publicationGuardStatusRecordMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff = false; + bool publicationGuardConsumerReadinessMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff = false; + bool publicationGuardConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff = false; + bool publicationGuardDispatchConsumptionGuardMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff = false; + bool publicationGuardDispatchConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff = false; + bool publicationGuardResultHandoffMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff = false; + bool publicationGuardResultConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff = false; + bool publicationGuardReadinessProjectionMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff = false; + bool publicationGuardReadinessConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff = false; + bool publicationGuardStatusHandoffMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff = false; + bool publicationGuardStatusConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff = false; + bool publicationGuardPublicationGuardMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff = false; + bool publicationGuardPublicationConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff = false; + bool publicationGuardPublicationGuardResultHandoffMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff = false; + bool publicationGuardPublicationGuardResultConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff = false; + bool publicationGuardPublicationGuardResultHandoffReadinessProjectionMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff = false; + bool publicationGuardPublicationGuardResultHandoffReadinessConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff = false; + bool publicationGuardPublicationGuardResultHandoffReadinessProjectionStatusHandoffMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff = false; + bool publicationGuardPublicationGuardResultHandoffReadinessProjectionStatusConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff = false; + bool publicationGuardPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff = false; + bool publicationGuardPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff = false; + bool publicationGuardPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff = false; + bool publicationGuardPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff = false; + bool publicationGuardPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff = false; + bool publicationGuardPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff = false; + bool publicationGuardPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff = false; + bool publicationGuardPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerNameMatchesPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff = false; + bool disabledPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardRegistered = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardAcceptsStatusHandoffEvidence = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardReturnsDisabledPublication = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlocksDispatchConsumption = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlocksDispatchResultExecution = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlocksStatusPublication = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlocksReadinessPublication = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlocksStatusHandoffPublication = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlocksPublicationGuardPublication = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlocksPublicationGuardResultHandoffPublication = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlocksPublicationGuardResultHandoffReadinessProjectionPublication = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication = true; + bool callbackInvocationStillDisabled = true; + bool callbackInvocationRefused = true; + bool callbackInvocationRefusalReviewed = false; + bool publicationGuardStopsBeforeCallbackInvocation = true; + bool publicationGuardStopsBeforeCallbackResultExecution = true; + bool publicationGuardStopsBeforeDispatchConsumption = true; + bool publicationGuardStopsBeforeDispatchResultExecution = true; + bool publicationGuardStopsBeforeDispatchStatusPublication = true; + bool publicationGuardStopsBeforeReadinessPublication = true; + bool publicationGuardStopsBeforeStatusHandoffPublication = true; + bool publicationGuardStopsBeforePublicationGuardPublication = true; + bool publicationGuardStopsBeforePublicationGuardResultHandoffPublication = true; + bool publicationGuardStopsBeforePublicationGuardResultHandoffReadinessProjectionPublication = true; + bool publicationGuardStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication = true; + bool publicationGuardStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication = true; + bool publicationGuardStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication = true; + bool publicationGuardStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication = true; + bool publicationGuardStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication = true; + bool publicationGuardStopsBeforePublication = true; + bool publicationGuardStopsBeforePlatformApi = true; + bool publicationGuardRequiresSeparateExecutionBatch = true; + bool publicationGuardProducesNoDynamicHandle = true; + bool publicationGuardStoresNoDynamicHandle = true; + bool publicationGuardReleasesNoDynamicHandle = true; + bool publicationGuardResolvesNoSymbols = true; + bool publicationGuardStoresNoSymbolTable = true; + bool publicationGuardCreatesNoRuntime = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardFailureMappingReviewed = false; + bool unloadExecutionStillDisabled = true; + bool symbolResolutionStillDisabled = true; + bool productionLoaderExecutionDisabled = true; + bool realAdapterExecutionDisabled = true; + bool loadOnlyExecutionDisabled = true; + bool separateExecutionBatchRequired = true; + bool macosDeferredByOperator = true; + + bool callbackInvocationAttempted = false; + bool callbackResultExecutionAttempted = false; + bool dispatchHandoffExecutionAttempted = false; + bool dispatchStatusPublicationAttempted = false; + bool dispatchConsumerConsumptionAttempted = false; + bool dispatchResultExecutionAttempted = false; + bool resultHandoffStatusPublicationAttempted = false; + bool readinessProjectionStatusPublicationAttempted = false; + bool statusHandoffPublicationAttempted = false; + bool publicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = false; + bool runtimePlatformLoadAttempted = false; + bool runtimePlatformUnloadAttempted = false; + bool runtimePlatformSymbolResolutionAttempted = false; + bool sdxlCallRequested = false; + bool bridgeCallRequested = false; + bool serverConnectivityCheckRequested = false; + bool walletLifecycleRequested = false; + bool syncRequested = false; + bool syncStatusPollingRequested = false; + bool workerQueueRequested = false; + bool walletStateMutationRequested = false; + bool walletPersistenceRequested = false; + bool settingsWriteRequested = false; + bool sendImportExportRequested = false; + bool artifactMutationRequested = false; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResult { + bool ok = false; + bool noCallbackInvocationAttempted = true; + bool noCallbackResultExecutionAttempted = true; + bool noDispatchHandoffExecutionAttempted = true; + bool noDispatchStatusPublicationAttempted = true; + bool noDispatchConsumerConsumptionAttempted = true; + bool noDispatchResultExecutionAttempted = true; + bool noResultHandoffStatusPublicationAttempted = true; + bool noReadinessProjectionStatusPublicationAttempted = true; + bool noStatusHandoffPublicationAttempted = true; + bool noPublicationGuardPublicationAttempted = true; + bool noPublicationGuardResultHandoffPublicationAttempted = true; + bool noPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = true; + bool noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = true; + bool noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = true; + bool noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = true; + bool noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = true; + bool noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = true; + bool noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = true; + bool noRuntimePlatformDynamicLibraryLoaded = true; + bool noRuntimePlatformDynamicLibraryUnloaded = true; + bool noRuntimePlatformSymbolResolution = true; + bool noSdxlCalls = true; + bool noBridgeCalls = true; + bool noServerConnectivityChecked = true; + bool noWalletLifecycle = true; + bool noSyncStarted = true; + bool noSyncStatusPolled = true; + bool noWorkerQueueEnqueue = true; + bool noWalletStateMutation = true; + bool noWalletPersistence = true; + bool noSettingsPersistence = true; + bool noSendImportExportExecution = true; + bool noArtifactMutation = true; + + bool platformAccepted = false; + bool linuxPlatformAccepted = false; + bool windowsPlatformAccepted = false; + bool macosDeferred = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffAccepted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardRecordAccepted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardMatchAccepted = false; + bool disabledPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardAccepted = false; + bool callbackInvocationRefused = false; + bool dispatchConsumptionStillGuarded = false; + bool dispatchResultExecutionBlocked = false; + bool dispatchStatusPublicationBlocked = false; + bool readinessProjectionPublicationBlocked = false; + bool statusHandoffPublicationBlocked = false; + bool publicationGuardPublicationBlocked = false; + bool publicationGuardResultHandoffPublicationBlocked = false; + bool publicationGuardResultHandoffReadinessProjectionPublicationBlocked = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationBlocked = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationBlocked = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked = false; + bool platformApiPreInvocationBlocked = false; + bool disabledPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardStateAccepted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardFailureMappingAccepted = false; + bool unloadExecutionBlocked = false; + bool symbolResolutionBlocked = false; + bool productionLoaderDisabled = false; + bool realAdapterExecutionDisabled = false; + bool loadOnlyExecutionDisabled = false; + bool separateExecutionBatchRequired = false; + bool loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardReady = false; + + LiteBridgeRuntimeStatus status = LiteBridgeRuntimeStatus::Unavailable; + std::string platform; + std::string adapterName; + std::string ownerName; + std::string handoffId; + std::string loadCallbackBoundaryName; + std::string callbackBindingId; + std::string callbackName; + std::string guardId; + std::string refusalResultId; + std::string propagationId; + std::string dispatchHandoffId; + std::string statusRecordId; + std::string consumerReadinessId; + std::string consumerName; + std::string dispatchConsumptionGuardId; + std::string dispatchConsumerName; + std::string resultHandoffId; + std::string resultConsumerName; + std::string readinessProjectionId; + std::string readinessConsumerName; + std::string statusHandoffId; + std::string statusConsumerName; + std::string publicationGuardId; + std::string publicationConsumerName; + std::string publicationGuardResultHandoffId; + std::string publicationGuardResultConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionId; + std::string publicationGuardResultHandoffReadinessConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffId; + std::string publicationGuardResultHandoffReadinessProjectionStatusConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName; + std::vector issues; + std::string error; + std::string summary; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffInput { + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResult publicationGuard; + std::string platform; + std::string adapterName; + std::string ownerName; + std::string handoffId; + std::string loadCallbackBoundaryName; + std::string callbackBindingId; + std::string callbackName; + std::string guardId; + std::string refusalResultId; + std::string propagationId; + std::string dispatchHandoffId; + std::string statusRecordId; + std::string consumerReadinessId; + std::string consumerName; + std::string dispatchConsumptionGuardId; + std::string dispatchConsumerName; + std::string resultHandoffId; + std::string resultConsumerName; + std::string readinessProjectionId; + std::string readinessConsumerName; + std::string statusHandoffId; + std::string statusConsumerName; + std::string publicationGuardId; + std::string publicationConsumerName; + std::string publicationGuardResultHandoffId; + std::string publicationGuardResultConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionId; + std::string publicationGuardResultHandoffReadinessConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffId; + std::string publicationGuardResultHandoffReadinessProjectionStatusConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName; + bool publicationGuardAccepted = false; + bool resultHandoffReviewed = false; + bool resultHandoffRecorded = false; + bool resultHandoffDisabled = true; + bool resultHandoffMatchesPublicationGuardEvidence = false; + bool disabledResultHandoffRegistered = false; + bool resultHandoffAcceptsPublicationGuardEvidence = false; + bool resultHandoffReturnsDisabledResult = true; + bool resultHandoffBlocksDispatchConsumption = true; + bool resultHandoffBlocksDispatchResultExecution = true; + bool resultHandoffBlocksStatusPublication = true; + bool resultHandoffBlocksReadinessPublication = true; + bool resultHandoffBlocksStatusHandoffPublication = true; + bool resultHandoffBlocksPublicationGuardPublication = true; + bool resultHandoffBlocksPublicationGuardResultHandoffPublication = true; + bool resultHandoffBlocksPublicationGuardResultHandoffReadinessProjectionPublication = true; + bool resultHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication = true; + bool resultHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication = true; + bool resultHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication = true; + bool resultHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication = true; + bool resultHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication = true; + bool resultHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication = true; + bool resultHandoffBlocksResultHandoffPublication = true; + bool callbackInvocationStillDisabled = true; + bool callbackInvocationRefused = true; + bool callbackInvocationRefusalReviewed = false; + bool resultHandoffStopsBeforeCallbackInvocation = true; + bool resultHandoffStopsBeforeCallbackResultExecution = true; + bool resultHandoffStopsBeforeDispatchConsumption = true; + bool resultHandoffStopsBeforeDispatchResultExecution = true; + bool resultHandoffStopsBeforeDispatchStatusPublication = true; + bool resultHandoffStopsBeforeReadinessPublication = true; + bool resultHandoffStopsBeforeStatusHandoffPublication = true; + bool resultHandoffStopsBeforePublicationGuardPublication = true; + bool resultHandoffStopsBeforePublicationGuardResultHandoffPublication = true; + bool resultHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionPublication = true; + bool resultHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication = true; + bool resultHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication = true; + bool resultHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication = true; + bool resultHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication = true; + bool resultHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication = true; + bool resultHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication = true; + bool resultHandoffStopsBeforeResultPublication = true; + bool resultHandoffStopsBeforePlatformApi = true; + bool resultHandoffRequiresSeparateExecutionBatch = true; + bool resultHandoffProducesNoDynamicHandle = true; + bool resultHandoffStoresNoDynamicHandle = true; + bool resultHandoffReleasesNoDynamicHandle = true; + bool resultHandoffResolvesNoSymbols = true; + bool resultHandoffStoresNoSymbolTable = true; + bool resultHandoffCreatesNoRuntime = true; + bool resultHandoffFailureMappingReviewed = false; + bool unloadExecutionStillDisabled = true; + bool symbolResolutionStillDisabled = true; + bool productionLoaderExecutionDisabled = true; + bool realAdapterExecutionDisabled = true; + bool loadOnlyExecutionDisabled = true; + bool separateExecutionBatchRequired = true; + bool macosDeferredByOperator = true; + + bool callbackInvocationAttempted = false; + bool callbackResultExecutionAttempted = false; + bool dispatchHandoffExecutionAttempted = false; + bool dispatchStatusPublicationAttempted = false; + bool dispatchConsumerConsumptionAttempted = false; + bool dispatchResultExecutionAttempted = false; + bool resultHandoffStatusPublicationAttempted = false; + bool readinessProjectionStatusPublicationAttempted = false; + bool statusHandoffPublicationAttempted = false; + bool publicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = false; + bool runtimePlatformLoadAttempted = false; + bool runtimePlatformUnloadAttempted = false; + bool runtimePlatformSymbolResolutionAttempted = false; + bool sdxlCallRequested = false; + bool bridgeCallRequested = false; + bool serverConnectivityCheckRequested = false; + bool walletLifecycleRequested = false; + bool syncRequested = false; + bool syncStatusPollingRequested = false; + bool workerQueueRequested = false; + bool walletStateMutationRequested = false; + bool walletPersistenceRequested = false; + bool settingsWriteRequested = false; + bool sendImportExportRequested = false; + bool artifactMutationRequested = false; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffResult { + bool ok = false; + bool noCallbackInvocationAttempted = true; + bool noCallbackResultExecutionAttempted = true; + bool noDispatchHandoffExecutionAttempted = true; + bool noDispatchStatusPublicationAttempted = true; + bool noDispatchConsumerConsumptionAttempted = true; + bool noDispatchResultExecutionAttempted = true; + bool noResultHandoffStatusPublicationAttempted = true; + bool noReadinessProjectionStatusPublicationAttempted = true; + bool noStatusHandoffPublicationAttempted = true; + bool noPublicationGuardPublicationAttempted = true; + bool noPublicationGuardResultHandoffPublicationAttempted = true; + bool noPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = true; + bool noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = true; + bool noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = true; + bool noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = true; + bool noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = true; + bool noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = true; + bool noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = true; + bool noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = true; + bool noRuntimePlatformDynamicLibraryLoaded = true; + bool noRuntimePlatformDynamicLibraryUnloaded = true; + bool noRuntimePlatformSymbolResolution = true; + bool noSdxlCalls = true; + bool noBridgeCalls = true; + bool noServerConnectivityChecked = true; + bool noWalletLifecycle = true; + bool noSyncStarted = true; + bool noSyncStatusPolled = true; + bool noWorkerQueueEnqueue = true; + bool noWalletStateMutation = true; + bool noWalletPersistence = true; + bool noSettingsPersistence = true; + bool noSendImportExportExecution = true; + bool noArtifactMutation = true; + + bool platformAccepted = false; + bool linuxPlatformAccepted = false; + bool windowsPlatformAccepted = false; + bool macosDeferred = false; + bool publicationGuardAccepted = false; + bool resultHandoffRecordAccepted = false; + bool resultHandoffPublicationGuardMatchAccepted = false; + bool disabledResultHandoffAccepted = false; + bool callbackInvocationRefused = false; + bool dispatchConsumptionStillGuarded = false; + bool dispatchResultExecutionBlocked = false; + bool dispatchStatusPublicationBlocked = false; + bool readinessProjectionPublicationBlocked = false; + bool statusHandoffPublicationBlocked = false; + bool publicationGuardPublicationBlocked = false; + bool publicationGuardResultHandoffPublicationBlocked = false; + bool publicationGuardResultHandoffReadinessProjectionPublicationBlocked = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationBlocked = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationBlocked = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationBlocked = false; + bool platformApiPreInvocationBlocked = false; + bool disabledResultHandoffStateAccepted = false; + bool resultHandoffFailureMappingAccepted = false; + bool unloadExecutionBlocked = false; + bool symbolResolutionBlocked = false; + bool productionLoaderDisabled = false; + bool realAdapterExecutionDisabled = false; + bool loadOnlyExecutionDisabled = false; + bool separateExecutionBatchRequired = false; + bool loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReady = false; + + LiteBridgeRuntimeStatus status = LiteBridgeRuntimeStatus::Unavailable; + std::string platform; + std::string adapterName; + std::string ownerName; + std::string handoffId; + std::string loadCallbackBoundaryName; + std::string callbackBindingId; + std::string callbackName; + std::string guardId; + std::string refusalResultId; + std::string propagationId; + std::string dispatchHandoffId; + std::string statusRecordId; + std::string consumerReadinessId; + std::string consumerName; + std::string dispatchConsumptionGuardId; + std::string dispatchConsumerName; + std::string resultHandoffId; + std::string resultConsumerName; + std::string readinessProjectionId; + std::string readinessConsumerName; + std::string statusHandoffId; + std::string statusConsumerName; + std::string publicationGuardId; + std::string publicationConsumerName; + std::string publicationGuardResultHandoffId; + std::string publicationGuardResultConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionId; + std::string publicationGuardResultHandoffReadinessConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffId; + std::string publicationGuardResultHandoffReadinessProjectionStatusConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName; + std::vector issues; + std::string error; + std::string summary; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionInput { + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffResult publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff; + std::string platform; + std::string adapterName; + std::string ownerName; + std::string handoffId; + std::string loadCallbackBoundaryName; + std::string callbackBindingId; + std::string callbackName; + std::string guardId; + std::string refusalResultId; + std::string propagationId; + std::string dispatchHandoffId; + std::string statusRecordId; + std::string consumerReadinessId; + std::string consumerName; + std::string dispatchConsumptionGuardId; + std::string dispatchConsumerName; + std::string resultHandoffId; + std::string resultConsumerName; + std::string readinessProjectionId; + std::string readinessConsumerName; + std::string statusHandoffId; + std::string statusConsumerName; + std::string publicationGuardId; + std::string publicationConsumerName; + std::string publicationGuardResultHandoffId; + std::string publicationGuardResultConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionId; + std::string publicationGuardResultHandoffReadinessConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffId; + std::string publicationGuardResultHandoffReadinessProjectionStatusConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffAccepted = false; + bool readinessProjectionReviewed = false; + bool readinessProjectionRecorded = false; + bool readinessProjectionDisabled = true; + bool readinessProjectionMatchesResultHandoffEvidence = false; + bool disabledReadinessProjectionRegistered = false; + bool readinessProjectionAcceptsResultHandoffEvidence = false; + bool readinessProjectionReturnsDisabledReadiness = true; + bool readinessProjectionBlocksDispatchConsumption = true; + bool readinessProjectionBlocksDispatchResultExecution = true; + bool readinessProjectionBlocksStatusPublication = true; + bool readinessProjectionBlocksReadinessPublication = true; + bool readinessProjectionBlocksStatusHandoffPublication = true; + bool readinessProjectionBlocksPublicationGuardPublication = true; + bool readinessProjectionBlocksPublicationGuardResultHandoffPublication = true; + bool readinessProjectionBlocksPublicationGuardResultHandoffReadinessProjectionPublication = true; + bool readinessProjectionBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication = true; + bool readinessProjectionBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication = true; + bool readinessProjectionBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication = true; + bool readinessProjectionBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication = true; + bool readinessProjectionBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication = true; + bool readinessProjectionBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication = true; + bool readinessProjectionBlocksResultHandoffPublication = true; + bool readinessProjectionBlocksResultHandoffReadinessProjectionPublication = true; + bool callbackInvocationStillDisabled = true; + bool callbackInvocationRefused = true; + bool callbackInvocationRefusalReviewed = false; + bool projectionStopsBeforeCallbackInvocation = true; + bool projectionStopsBeforeCallbackResultExecution = true; + bool projectionStopsBeforeDispatchConsumption = true; + bool projectionStopsBeforeDispatchResultExecution = true; + bool projectionStopsBeforeDispatchStatusPublication = true; + bool projectionStopsBeforeReadinessPublication = true; + bool projectionStopsBeforeStatusHandoffPublication = true; + bool projectionStopsBeforePublicationGuardPublication = true; + bool projectionStopsBeforePublicationGuardResultHandoffPublication = true; + bool projectionStopsBeforePublicationGuardResultHandoffReadinessProjectionPublication = true; + bool projectionStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication = true; + bool projectionStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication = true; + bool projectionStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication = true; + bool projectionStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication = true; + bool projectionStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication = true; + bool projectionStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication = true; + bool projectionStopsBeforeResultPublication = true; + bool projectionStopsBeforeResultHandoffReadinessProjectionPublication = true; + bool projectionStopsBeforePlatformApi = true; + bool projectionRequiresSeparateExecutionBatch = true; + bool projectionProducesNoDynamicHandle = true; + bool projectionStoresNoDynamicHandle = true; + bool projectionReleasesNoDynamicHandle = true; + bool projectionResolvesNoSymbols = true; + bool projectionStoresNoSymbolTable = true; + bool projectionCreatesNoRuntime = true; + bool readinessProjectionFailureMappingReviewed = false; + bool unloadExecutionStillDisabled = true; + bool symbolResolutionStillDisabled = true; + bool productionLoaderExecutionDisabled = true; + bool realAdapterExecutionDisabled = true; + bool loadOnlyExecutionDisabled = true; + bool separateExecutionBatchRequired = true; + bool macosDeferredByOperator = true; + + bool callbackInvocationAttempted = false; + bool callbackResultExecutionAttempted = false; + bool dispatchHandoffExecutionAttempted = false; + bool dispatchStatusPublicationAttempted = false; + bool dispatchConsumerConsumptionAttempted = false; + bool dispatchResultExecutionAttempted = false; + bool resultHandoffStatusPublicationAttempted = false; + bool readinessProjectionStatusPublicationAttempted = false; + bool statusHandoffPublicationAttempted = false; + bool publicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool runtimePlatformLoadAttempted = false; + bool runtimePlatformUnloadAttempted = false; + bool runtimePlatformSymbolResolutionAttempted = false; + bool sdxlCallRequested = false; + bool bridgeCallRequested = false; + bool serverConnectivityCheckRequested = false; + bool walletLifecycleRequested = false; + bool syncRequested = false; + bool syncStatusPollingRequested = false; + bool workerQueueRequested = false; + bool walletStateMutationRequested = false; + bool walletPersistenceRequested = false; + bool settingsWriteRequested = false; + bool sendImportExportRequested = false; + bool artifactMutationRequested = false; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionResult { + bool ok = false; + bool noCallbackInvocationAttempted = true; + bool noCallbackResultExecutionAttempted = true; + bool noDispatchHandoffExecutionAttempted = true; + bool noDispatchStatusPublicationAttempted = true; + bool noDispatchConsumerConsumptionAttempted = true; + bool noDispatchResultExecutionAttempted = true; + bool noResultHandoffStatusPublicationAttempted = true; + bool noReadinessProjectionStatusPublicationAttempted = true; + bool noStatusHandoffPublicationAttempted = true; + bool noPublicationGuardPublicationAttempted = true; + bool noPublicationGuardResultHandoffPublicationAttempted = true; + bool noPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = true; + bool noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = true; + bool noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = true; + bool noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = true; + bool noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = true; + bool noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = true; + bool noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = true; + bool noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = true; + bool noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = true; + bool noRuntimePlatformDynamicLibraryLoaded = true; + bool noRuntimePlatformDynamicLibraryUnloaded = true; + bool noRuntimePlatformSymbolResolution = true; + bool noSdxlCalls = true; + bool noBridgeCalls = true; + bool noServerConnectivityChecked = true; + bool noWalletLifecycle = true; + bool noSyncStarted = true; + bool noSyncStatusPolled = true; + bool noWorkerQueueEnqueue = true; + bool noWalletStateMutation = true; + bool noWalletPersistence = true; + bool noSettingsPersistence = true; + bool noSendImportExportExecution = true; + bool noArtifactMutation = true; + + bool platformAccepted = false; + bool linuxPlatformAccepted = false; + bool windowsPlatformAccepted = false; + bool macosDeferred = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffAccepted = false; + bool readinessProjectionRecordAccepted = false; + bool readinessProjectionResultHandoffMatchAccepted = false; + bool disabledReadinessProjectionAccepted = false; + bool callbackInvocationRefused = false; + bool dispatchConsumptionStillGuarded = false; + bool dispatchResultExecutionBlocked = false; + bool dispatchStatusPublicationBlocked = false; + bool readinessProjectionPublicationBlocked = false; + bool statusHandoffPublicationBlocked = false; + bool publicationGuardPublicationBlocked = false; + bool publicationGuardResultHandoffPublicationBlocked = false; + bool publicationGuardResultHandoffReadinessProjectionPublicationBlocked = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationBlocked = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationBlocked = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationBlocked = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationBlocked = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationBlocked = false; + bool platformApiPreInvocationBlocked = false; + bool disabledReadinessProjectionStateAccepted = false; + bool readinessProjectionFailureMappingAccepted = false; + bool unloadExecutionBlocked = false; + bool symbolResolutionBlocked = false; + bool productionLoaderDisabled = false; + bool realAdapterExecutionDisabled = false; + bool loadOnlyExecutionDisabled = false; + bool separateExecutionBatchRequired = false; + bool loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionReady = false; + + LiteBridgeRuntimeStatus status = LiteBridgeRuntimeStatus::Unavailable; + std::string platform; + std::string adapterName; + std::string ownerName; + std::string handoffId; + std::string loadCallbackBoundaryName; + std::string callbackBindingId; + std::string callbackName; + std::string guardId; + std::string refusalResultId; + std::string propagationId; + std::string dispatchHandoffId; + std::string statusRecordId; + std::string consumerReadinessId; + std::string consumerName; + std::string dispatchConsumptionGuardId; + std::string dispatchConsumerName; + std::string resultHandoffId; + std::string resultConsumerName; + std::string readinessProjectionId; + std::string readinessConsumerName; + std::string statusHandoffId; + std::string statusConsumerName; + std::string publicationGuardId; + std::string publicationConsumerName; + std::string publicationGuardResultHandoffId; + std::string publicationGuardResultConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionId; + std::string publicationGuardResultHandoffReadinessConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffId; + std::string publicationGuardResultHandoffReadinessProjectionStatusConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName; + std::vector issues; + std::string error; + std::string summary; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffInput { + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionResult publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection; + std::string platform; + std::string adapterName; + std::string ownerName; + std::string handoffId; + std::string loadCallbackBoundaryName; + std::string callbackBindingId; + std::string callbackName; + std::string guardId; + std::string refusalResultId; + std::string propagationId; + std::string dispatchHandoffId; + std::string statusRecordId; + std::string consumerReadinessId; + std::string consumerName; + std::string dispatchConsumptionGuardId; + std::string dispatchConsumerName; + std::string resultHandoffId; + std::string resultConsumerName; + std::string readinessProjectionId; + std::string readinessConsumerName; + std::string statusHandoffId; + std::string statusConsumerName; + std::string publicationGuardId; + std::string publicationConsumerName; + std::string publicationGuardResultHandoffId; + std::string publicationGuardResultConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionId; + std::string publicationGuardResultHandoffReadinessConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffId; + std::string publicationGuardResultHandoffReadinessProjectionStatusConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionAccepted = false; + bool statusHandoffReviewed = false; + bool statusHandoffRecorded = false; + bool statusHandoffDisabled = true; + bool statusHandoffMatchesReadinessProjectionEvidence = false; + bool disabledStatusHandoffRegistered = false; + bool statusHandoffAcceptsReadinessProjectionEvidence = false; + bool statusHandoffReturnsDisabledStatus = true; + bool statusHandoffBlocksDispatchConsumption = true; + bool statusHandoffBlocksDispatchResultExecution = true; + bool statusHandoffBlocksStatusPublication = true; + bool statusHandoffBlocksReadinessPublication = true; + bool statusHandoffBlocksStatusHandoffPublication = true; + bool statusHandoffBlocksPublicationGuardPublication = true; + bool statusHandoffBlocksPublicationGuardResultHandoffPublication = true; + bool statusHandoffBlocksPublicationGuardResultHandoffReadinessProjectionPublication = true; + bool statusHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication = true; + bool statusHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication = true; + bool statusHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication = true; + bool statusHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication = true; + bool statusHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication = true; + bool statusHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication = true; + bool statusHandoffBlocksResultHandoffPublication = true; + bool statusHandoffBlocksResultHandoffReadinessProjectionPublication = true; + bool statusHandoffBlocksResultHandoffReadinessProjectionStatusHandoffPublication = true; + bool callbackInvocationStillDisabled = true; + bool callbackInvocationRefused = true; + bool callbackInvocationRefusalReviewed = false; + bool statusHandoffStopsBeforeCallbackInvocation = true; + bool statusHandoffStopsBeforeCallbackResultExecution = true; + bool statusHandoffStopsBeforeDispatchConsumption = true; + bool statusHandoffStopsBeforeDispatchResultExecution = true; + bool statusHandoffStopsBeforeDispatchStatusPublication = true; + bool statusHandoffStopsBeforeReadinessPublication = true; + bool statusHandoffStopsBeforeStatusHandoffPublication = true; + bool statusHandoffStopsBeforePublicationGuardPublication = true; + bool statusHandoffStopsBeforePublicationGuardResultHandoffPublication = true; + bool statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionPublication = true; + bool statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication = true; + bool statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication = true; + bool statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication = true; + bool statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication = true; + bool statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication = true; + bool statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication = true; + bool statusHandoffStopsBeforeResultPublication = true; + bool statusHandoffStopsBeforeResultHandoffReadinessProjectionPublication = true; + bool statusHandoffStopsBeforeResultHandoffReadinessProjectionStatusHandoffPublication = true; + bool statusHandoffStopsBeforePlatformApi = true; + bool statusHandoffRequiresSeparateExecutionBatch = true; + bool statusHandoffProducesNoDynamicHandle = true; + bool statusHandoffStoresNoDynamicHandle = true; + bool statusHandoffReleasesNoDynamicHandle = true; + bool statusHandoffResolvesNoSymbols = true; + bool statusHandoffStoresNoSymbolTable = true; + bool statusHandoffCreatesNoRuntime = true; + bool statusHandoffFailureMappingReviewed = false; + bool unloadExecutionStillDisabled = true; + bool symbolResolutionStillDisabled = true; + bool productionLoaderExecutionDisabled = true; + bool realAdapterExecutionDisabled = true; + bool loadOnlyExecutionDisabled = true; + bool separateExecutionBatchRequired = true; + bool macosDeferredByOperator = true; + + bool callbackInvocationAttempted = false; + bool callbackResultExecutionAttempted = false; + bool dispatchHandoffExecutionAttempted = false; + bool dispatchStatusPublicationAttempted = false; + bool dispatchConsumerConsumptionAttempted = false; + bool dispatchResultExecutionAttempted = false; + bool resultHandoffStatusPublicationAttempted = false; + bool readinessProjectionStatusPublicationAttempted = false; + bool statusHandoffPublicationAttempted = false; + bool publicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool runtimePlatformLoadAttempted = false; + bool runtimePlatformUnloadAttempted = false; + bool runtimePlatformSymbolResolutionAttempted = false; + bool sdxlCallRequested = false; + bool bridgeCallRequested = false; + bool serverConnectivityCheckRequested = false; + bool walletLifecycleRequested = false; + bool syncRequested = false; + bool syncStatusPollingRequested = false; + bool workerQueueRequested = false; + bool walletStateMutationRequested = false; + bool walletPersistenceRequested = false; + bool settingsWriteRequested = false; + bool sendImportExportRequested = false; + bool artifactMutationRequested = false; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffResult { + bool ok = false; + bool noCallbackInvocationAttempted = true; + bool noCallbackResultExecutionAttempted = true; + bool noDispatchHandoffExecutionAttempted = true; + bool noDispatchStatusPublicationAttempted = true; + bool noDispatchConsumerConsumptionAttempted = true; + bool noDispatchResultExecutionAttempted = true; + bool noResultHandoffStatusPublicationAttempted = true; + bool noReadinessProjectionStatusPublicationAttempted = true; + bool noStatusHandoffPublicationAttempted = true; + bool noPublicationGuardPublicationAttempted = true; + bool noPublicationGuardResultHandoffPublicationAttempted = true; + bool noPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = true; + bool noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = true; + bool noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = true; + bool noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = true; + bool noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = true; + bool noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = true; + bool noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = true; + bool noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = true; + bool noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = true; + bool noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = true; + bool noRuntimePlatformDynamicLibraryLoaded = true; + bool noRuntimePlatformDynamicLibraryUnloaded = true; + bool noRuntimePlatformSymbolResolution = true; + bool noSdxlCalls = true; + bool noBridgeCalls = true; + bool noServerConnectivityChecked = true; + bool noWalletLifecycle = true; + bool noSyncStarted = true; + bool noSyncStatusPolled = true; + bool noWorkerQueueEnqueue = true; + bool noWalletStateMutation = true; + bool noWalletPersistence = true; + bool noSettingsPersistence = true; + bool noSendImportExportExecution = true; + bool noArtifactMutation = true; + + bool platformAccepted = false; + bool linuxPlatformAccepted = false; + bool windowsPlatformAccepted = false; + bool macosDeferred = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionAccepted = false; + bool statusHandoffRecordAccepted = false; + bool statusHandoffReadinessProjectionMatchAccepted = false; + bool disabledStatusHandoffAccepted = false; + bool callbackInvocationRefused = false; + bool dispatchConsumptionStillGuarded = false; + bool dispatchResultExecutionBlocked = false; + bool dispatchStatusPublicationBlocked = false; + bool readinessProjectionPublicationBlocked = false; + bool statusHandoffPublicationBlocked = false; + bool publicationGuardPublicationBlocked = false; + bool publicationGuardResultHandoffPublicationBlocked = false; + bool publicationGuardResultHandoffReadinessProjectionPublicationBlocked = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationBlocked = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationBlocked = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationBlocked = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationBlocked = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked = false; + bool platformApiPreInvocationBlocked = false; + bool disabledStatusHandoffStateAccepted = false; + bool statusHandoffFailureMappingAccepted = false; + bool unloadExecutionBlocked = false; + bool symbolResolutionBlocked = false; + bool productionLoaderDisabled = false; + bool realAdapterExecutionDisabled = false; + bool loadOnlyExecutionDisabled = false; + bool separateExecutionBatchRequired = false; + bool loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffReady = false; + + LiteBridgeRuntimeStatus status = LiteBridgeRuntimeStatus::Unavailable; + std::string platform; + std::string adapterName; + std::string ownerName; + std::string handoffId; + std::string loadCallbackBoundaryName; + std::string callbackBindingId; + std::string callbackName; + std::string guardId; + std::string refusalResultId; + std::string propagationId; + std::string dispatchHandoffId; + std::string statusRecordId; + std::string consumerReadinessId; + std::string consumerName; + std::string dispatchConsumptionGuardId; + std::string dispatchConsumerName; + std::string resultHandoffId; + std::string resultConsumerName; + std::string readinessProjectionId; + std::string readinessConsumerName; + std::string statusHandoffId; + std::string statusConsumerName; + std::string publicationGuardId; + std::string publicationConsumerName; + std::string publicationGuardResultHandoffId; + std::string publicationGuardResultConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionId; + std::string publicationGuardResultHandoffReadinessConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffId; + std::string publicationGuardResultHandoffReadinessProjectionStatusConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName; + std::vector issues; + std::string error; + std::string summary; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardInput { + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffResult publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff; + std::string platform; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffAccepted = false; + bool publicationGuardReviewed = false; + bool publicationGuardRecorded = false; + bool publicationGuardDisabled = true; + bool publicationGuardMatchesStatusHandoffEvidence = false; + bool disabledPublicationGuardRegistered = false; + bool publicationGuardAcceptsStatusHandoffEvidence = false; + bool publicationGuardReturnsDisabledPublication = true; + bool publicationGuardBlocksDispatchConsumption = true; + bool publicationGuardBlocksDispatchResultExecution = true; + bool publicationGuardBlocksStatusPublication = true; + bool publicationGuardBlocksReadinessPublication = true; + bool publicationGuardBlocksStatusHandoffPublication = true; + bool publicationGuardBlocksPublicationGuardPublication = true; + bool publicationGuardBlocksPublicationGuardResultHandoffPublication = true; + bool publicationGuardBlocksPublicationGuardResultHandoffReadinessProjectionPublication = true; + bool publicationGuardBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication = true; + bool publicationGuardBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication = true; + bool publicationGuardBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication = true; + bool publicationGuardBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication = true; + bool publicationGuardBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication = true; + bool publicationGuardBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication = true; + bool publicationGuardBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication = true; + bool publicationGuardBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication = true; + bool publicationGuardBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication = true; + bool publicationGuardBlocksResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication = true; + bool callbackInvocationStillDisabled = true; + bool callbackInvocationRefused = true; + bool callbackInvocationRefusalReviewed = false; + bool publicationGuardStopsBeforeCallbackInvocation = true; + bool publicationGuardStopsBeforeCallbackResultExecution = true; + bool publicationGuardStopsBeforeDispatchConsumption = true; + bool publicationGuardStopsBeforeDispatchResultExecution = true; + bool publicationGuardStopsBeforeDispatchStatusPublication = true; + bool publicationGuardStopsBeforeReadinessPublication = true; + bool publicationGuardStopsBeforeStatusHandoffPublication = true; + bool publicationGuardStopsBeforePublicationGuardPublication = true; + bool publicationGuardStopsBeforePublicationGuardResultHandoffPublication = true; + bool publicationGuardStopsBeforePublicationGuardResultHandoffReadinessProjectionPublication = true; + bool publicationGuardStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication = true; + bool publicationGuardStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication = true; + bool publicationGuardStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication = true; + bool publicationGuardStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication = true; + bool publicationGuardStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication = true; + bool publicationGuardStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication = true; + bool publicationGuardStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication = true; + bool publicationGuardStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication = true; + bool publicationGuardStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication = true; + bool publicationGuardStopsBeforeResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication = true; + bool publicationGuardStopsBeforePlatformApi = true; + bool publicationGuardRequiresSeparateExecutionBatch = true; + bool publicationGuardProducesNoDynamicHandle = true; + bool publicationGuardStoresNoDynamicHandle = true; + bool publicationGuardReleasesNoDynamicHandle = true; + bool publicationGuardResolvesNoSymbols = true; + bool publicationGuardStoresNoSymbolTable = true; + bool publicationGuardCreatesNoRuntime = true; + bool publicationGuardFailureMappingReviewed = false; + bool unloadExecutionStillDisabled = true; + bool symbolResolutionStillDisabled = true; + bool productionLoaderExecutionDisabled = true; + bool realAdapterExecutionDisabled = true; + bool loadOnlyExecutionDisabled = true; + bool separateExecutionBatchRequired = true; + bool macosDeferredByOperator = true; + + bool callbackInvocationAttempted = false; + bool callbackResultExecutionAttempted = false; + bool dispatchHandoffExecutionAttempted = false; + bool dispatchStatusPublicationAttempted = false; + bool dispatchConsumerConsumptionAttempted = false; + bool dispatchResultExecutionAttempted = false; + bool resultHandoffStatusPublicationAttempted = false; + bool readinessProjectionStatusPublicationAttempted = false; + bool statusHandoffPublicationAttempted = false; + bool publicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = false; + bool runtimePlatformLoadAttempted = false; + bool runtimePlatformUnloadAttempted = false; + bool runtimePlatformSymbolResolutionAttempted = false; + bool sdxlCallRequested = false; + bool bridgeCallRequested = false; + bool serverConnectivityCheckRequested = false; + bool walletLifecycleRequested = false; + bool syncRequested = false; + bool syncStatusPollingRequested = false; + bool workerQueueRequested = false; + bool walletStateMutationRequested = false; + bool walletPersistenceRequested = false; + bool settingsWriteRequested = false; + bool sendImportExportRequested = false; + bool artifactMutationRequested = false; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResult + : LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffResult { + bool noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = true; + bool noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = true; + bool noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = true; + bool noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = true; + bool noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = true; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffAccepted = false; + bool publicationGuardRecordAccepted = false; + bool publicationGuardStatusHandoffMatchAccepted = false; + bool disabledPublicationGuardAccepted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked = false; + bool disabledPublicationGuardStateAccepted = false; + bool publicationGuardFailureMappingAccepted = false; + bool loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardReady = false; + + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffInput { + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResult publicationGuard; + std::string platform; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName; + bool publicationGuardAccepted = false; + bool resultHandoffReviewed = false; + bool resultHandoffRecorded = false; + bool resultHandoffDisabled = true; + bool resultHandoffMatchesPublicationGuardEvidence = false; + bool disabledResultHandoffRegistered = false; + bool resultHandoffAcceptsPublicationGuardEvidence = false; + bool resultHandoffReturnsDisabledResult = true; + bool resultHandoffBlocksDispatchConsumption = true; + bool resultHandoffBlocksDispatchResultExecution = true; + bool resultHandoffBlocksStatusPublication = true; + bool resultHandoffBlocksReadinessPublication = true; + bool resultHandoffBlocksStatusHandoffPublication = true; + bool resultHandoffBlocksPublicationGuardPublication = true; + bool resultHandoffBlocksPublicationGuardResultHandoffPublication = true; + bool resultHandoffBlocksPublicationGuardResultHandoffReadinessProjectionPublication = true; + bool resultHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication = true; + bool resultHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication = true; + bool resultHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication = true; + bool resultHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication = true; + bool resultHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication = true; + bool resultHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication = true; + bool resultHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication = true; + bool resultHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication = true; + bool resultHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication = true; + bool resultHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication = true; + bool resultHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication = true; + bool callbackInvocationStillDisabled = true; + bool callbackInvocationRefused = true; + bool callbackInvocationRefusalReviewed = false; + bool resultHandoffStopsBeforeCallbackInvocation = true; + bool resultHandoffStopsBeforeCallbackResultExecution = true; + bool resultHandoffStopsBeforeDispatchConsumption = true; + bool resultHandoffStopsBeforeDispatchResultExecution = true; + bool resultHandoffStopsBeforeDispatchStatusPublication = true; + bool resultHandoffStopsBeforeReadinessPublication = true; + bool resultHandoffStopsBeforeStatusHandoffPublication = true; + bool resultHandoffStopsBeforePublicationGuardPublication = true; + bool resultHandoffStopsBeforePublicationGuardResultHandoffPublication = true; + bool resultHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionPublication = true; + bool resultHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication = true; + bool resultHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication = true; + bool resultHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication = true; + bool resultHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication = true; + bool resultHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication = true; + bool resultHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication = true; + bool resultHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication = true; + bool resultHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication = true; + bool resultHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication = true; + bool resultHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication = true; + bool resultHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication = true; + bool resultHandoffStopsBeforePlatformApi = true; + bool resultHandoffRequiresSeparateExecutionBatch = true; + bool resultHandoffProducesNoDynamicHandle = true; + bool resultHandoffStoresNoDynamicHandle = true; + bool resultHandoffReleasesNoDynamicHandle = true; + bool resultHandoffResolvesNoSymbols = true; + bool resultHandoffStoresNoSymbolTable = true; + bool resultHandoffCreatesNoRuntime = true; + bool resultHandoffFailureMappingReviewed = false; + bool unloadExecutionStillDisabled = true; + bool symbolResolutionStillDisabled = true; + bool productionLoaderExecutionDisabled = true; + bool realAdapterExecutionDisabled = true; + bool loadOnlyExecutionDisabled = true; + bool separateExecutionBatchRequired = true; + bool macosDeferredByOperator = true; + + bool callbackInvocationAttempted = false; + bool callbackResultExecutionAttempted = false; + bool dispatchHandoffExecutionAttempted = false; + bool dispatchStatusPublicationAttempted = false; + bool dispatchConsumerConsumptionAttempted = false; + bool dispatchResultExecutionAttempted = false; + bool resultHandoffStatusPublicationAttempted = false; + bool readinessProjectionStatusPublicationAttempted = false; + bool statusHandoffPublicationAttempted = false; + bool publicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = false; + bool runtimePlatformLoadAttempted = false; + bool runtimePlatformUnloadAttempted = false; + bool runtimePlatformSymbolResolutionAttempted = false; + bool sdxlCallRequested = false; + bool bridgeCallRequested = false; + bool serverConnectivityCheckRequested = false; + bool walletLifecycleRequested = false; + bool syncRequested = false; + bool syncStatusPollingRequested = false; + bool workerQueueRequested = false; + bool walletStateMutationRequested = false; + bool walletPersistenceRequested = false; + bool settingsWriteRequested = false; + bool sendImportExportRequested = false; + bool artifactMutationRequested = false; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffResult + : LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResult { + bool noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = true; + bool publicationGuardAccepted = false; + bool resultHandoffRecordAccepted = false; + bool resultHandoffPublicationGuardMatchAccepted = false; + bool disabledResultHandoffAccepted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationBlocked = false; + bool disabledResultHandoffStateAccepted = false; + bool resultHandoffFailureMappingAccepted = false; + bool loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReady = false; + + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionInput { + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffResult resultHandoff; + std::string platform; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName; + bool resultHandoffAccepted = false; + bool readinessProjectionReviewed = false; + bool readinessProjectionRecorded = false; + bool readinessProjectionDisabled = true; + bool readinessProjectionMatchesResultHandoffEvidence = false; + bool disabledReadinessProjectionRegistered = false; + bool readinessProjectionAcceptsResultHandoffEvidence = false; + bool readinessProjectionReturnsDisabledReadiness = true; + bool readinessProjectionBlocksDispatchConsumption = true; + bool readinessProjectionBlocksDispatchResultExecution = true; + bool readinessProjectionBlocksStatusPublication = true; + bool readinessProjectionBlocksReadinessPublication = true; + bool readinessProjectionBlocksStatusHandoffPublication = true; + bool readinessProjectionBlocksPublicationGuardPublication = true; + bool readinessProjectionBlocksPublicationGuardResultHandoffPublication = true; + bool readinessProjectionBlocksPublicationGuardResultHandoffReadinessProjectionPublication = true; + bool readinessProjectionBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication = true; + bool readinessProjectionBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication = true; + bool readinessProjectionBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication = true; + bool readinessProjectionBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication = true; + bool readinessProjectionBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication = true; + bool readinessProjectionBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication = true; + bool readinessProjectionBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication = true; + bool readinessProjectionBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication = true; + bool readinessProjectionBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication = true; + bool readinessProjectionBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication = true; + bool readinessProjectionBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication = true; + bool readinessProjectionBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication = true; + bool callbackInvocationStillDisabled = true; + bool callbackInvocationRefused = true; + bool callbackInvocationRefusalReviewed = false; + bool readinessProjectionStopsBeforeCallbackInvocation = true; + bool readinessProjectionStopsBeforeCallbackResultExecution = true; + bool readinessProjectionStopsBeforeDispatchConsumption = true; + bool readinessProjectionStopsBeforeDispatchResultExecution = true; + bool readinessProjectionStopsBeforeDispatchStatusPublication = true; + bool readinessProjectionStopsBeforeReadinessPublication = true; + bool readinessProjectionStopsBeforeStatusHandoffPublication = true; + bool readinessProjectionStopsBeforePublicationGuardPublication = true; + bool readinessProjectionStopsBeforePublicationGuardResultHandoffPublication = true; + bool readinessProjectionStopsBeforePublicationGuardResultHandoffReadinessProjectionPublication = true; + bool readinessProjectionStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication = true; + bool readinessProjectionStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication = true; + bool readinessProjectionStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication = true; + bool readinessProjectionStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication = true; + bool readinessProjectionStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication = true; + bool readinessProjectionStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication = true; + bool readinessProjectionStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication = true; + bool readinessProjectionStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication = true; + bool readinessProjectionStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication = true; + bool readinessProjectionStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication = true; + bool readinessProjectionStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication = true; + bool readinessProjectionStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication = true; + bool readinessProjectionStopsBeforePlatformApi = true; + bool readinessProjectionRequiresSeparateExecutionBatch = true; + bool readinessProjectionProducesNoDynamicHandle = true; + bool readinessProjectionStoresNoDynamicHandle = true; + bool readinessProjectionReleasesNoDynamicHandle = true; + bool readinessProjectionResolvesNoSymbols = true; + bool readinessProjectionStoresNoSymbolTable = true; + bool readinessProjectionCreatesNoRuntime = true; + bool readinessProjectionFailureMappingReviewed = false; + bool unloadExecutionStillDisabled = true; + bool symbolResolutionStillDisabled = true; + bool productionLoaderExecutionDisabled = true; + bool realAdapterExecutionDisabled = true; + bool loadOnlyExecutionDisabled = true; + bool separateExecutionBatchRequired = true; + bool macosDeferredByOperator = true; + + bool callbackInvocationAttempted = false; + bool callbackResultExecutionAttempted = false; + bool dispatchHandoffExecutionAttempted = false; + bool dispatchStatusPublicationAttempted = false; + bool dispatchConsumerConsumptionAttempted = false; + bool dispatchResultExecutionAttempted = false; + bool resultHandoffStatusPublicationAttempted = false; + bool readinessProjectionStatusPublicationAttempted = false; + bool statusHandoffPublicationAttempted = false; + bool publicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool runtimePlatformLoadAttempted = false; + bool runtimePlatformUnloadAttempted = false; + bool runtimePlatformSymbolResolutionAttempted = false; + bool sdxlCallRequested = false; + bool bridgeCallRequested = false; + bool serverConnectivityCheckRequested = false; + bool walletLifecycleRequested = false; + bool syncRequested = false; + bool syncStatusPollingRequested = false; + bool workerQueueRequested = false; + bool walletStateMutationRequested = false; + bool walletPersistenceRequested = false; + bool settingsWriteRequested = false; + bool sendImportExportRequested = false; + bool artifactMutationRequested = false; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionResult + : LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffResult { + bool noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = true; + bool resultHandoffAccepted = false; + bool readinessProjectionRecordAccepted = false; + bool readinessProjectionResultHandoffMatchAccepted = false; + bool disabledReadinessProjectionAccepted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationBlocked = false; + bool disabledReadinessProjectionStateAccepted = false; + bool readinessProjectionFailureMappingAccepted = false; + bool loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionReady = false; + + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffInput { + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionResult readinessProjection; + std::string platform; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName; + bool readinessProjectionAccepted = false; + bool statusHandoffReviewed = false; + bool statusHandoffRecorded = false; + bool statusHandoffDisabled = true; + bool statusHandoffMatchesReadinessProjectionEvidence = false; + bool disabledStatusHandoffRegistered = false; + bool statusHandoffAcceptsReadinessProjectionEvidence = false; + bool statusHandoffReturnsDisabledStatus = true; + bool statusHandoffBlocksDispatchConsumption = true; + bool statusHandoffBlocksDispatchResultExecution = true; + bool statusHandoffBlocksStatusPublication = true; + bool statusHandoffBlocksReadinessPublication = true; + bool statusHandoffBlocksStatusHandoffPublication = true; + bool statusHandoffBlocksPublicationGuardPublication = true; + bool statusHandoffBlocksPublicationGuardResultHandoffPublication = true; + bool statusHandoffBlocksPublicationGuardResultHandoffReadinessProjectionPublication = true; + bool statusHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication = true; + bool statusHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication = true; + bool statusHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication = true; + bool statusHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication = true; + bool statusHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication = true; + bool statusHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication = true; + bool statusHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication = true; + bool statusHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication = true; + bool statusHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication = true; + bool statusHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication = true; + bool statusHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication = true; + bool statusHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication = true; + bool statusHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication = true; + bool statusHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication = true; + bool callbackInvocationStillDisabled = true; + bool callbackInvocationRefused = true; + bool callbackInvocationRefusalReviewed = false; + bool statusHandoffStopsBeforeCallbackInvocation = true; + bool statusHandoffStopsBeforeCallbackResultExecution = true; + bool statusHandoffStopsBeforeDispatchConsumption = true; + bool statusHandoffStopsBeforeDispatchResultExecution = true; + bool statusHandoffStopsBeforeDispatchStatusPublication = true; + bool statusHandoffStopsBeforeReadinessPublication = true; + bool statusHandoffStopsBeforeStatusHandoffPublication = true; + bool statusHandoffStopsBeforePublicationGuardPublication = true; + bool statusHandoffStopsBeforePublicationGuardResultHandoffPublication = true; + bool statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionPublication = true; + bool statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication = true; + bool statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication = true; + bool statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication = true; + bool statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication = true; + bool statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication = true; + bool statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication = true; + bool statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication = true; + bool statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication = true; + bool statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication = true; + bool statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication = true; + bool statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication = true; + bool statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication = true; + bool statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication = true; + bool statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication = true; + bool statusHandoffStopsBeforePlatformApi = true; + bool statusHandoffRequiresSeparateExecutionBatch = true; + bool statusHandoffProducesNoDynamicHandle = true; + bool statusHandoffStoresNoDynamicHandle = true; + bool statusHandoffReleasesNoDynamicHandle = true; + bool statusHandoffResolvesNoSymbols = true; + bool statusHandoffStoresNoSymbolTable = true; + bool statusHandoffCreatesNoRuntime = true; + bool statusHandoffFailureMappingReviewed = false; + bool unloadExecutionStillDisabled = true; + bool symbolResolutionStillDisabled = true; + bool productionLoaderExecutionDisabled = true; + bool realAdapterExecutionDisabled = true; + bool loadOnlyExecutionDisabled = true; + bool separateExecutionBatchRequired = true; + bool macosDeferredByOperator = true; + + bool callbackInvocationAttempted = false; + bool callbackResultExecutionAttempted = false; + bool dispatchHandoffExecutionAttempted = false; + bool dispatchStatusPublicationAttempted = false; + bool dispatchConsumerConsumptionAttempted = false; + bool dispatchResultExecutionAttempted = false; + bool resultHandoffStatusPublicationAttempted = false; + bool readinessProjectionStatusPublicationAttempted = false; + bool statusHandoffPublicationAttempted = false; + bool publicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool runtimePlatformLoadAttempted = false; + bool runtimePlatformUnloadAttempted = false; + bool runtimePlatformSymbolResolutionAttempted = false; + bool sdxlCallRequested = false; + bool bridgeCallRequested = false; + bool serverConnectivityCheckRequested = false; + bool walletLifecycleRequested = false; + bool syncRequested = false; + bool syncStatusPollingRequested = false; + bool workerQueueRequested = false; + bool walletStateMutationRequested = false; + bool walletPersistenceRequested = false; + bool settingsWriteRequested = false; + bool sendImportExportRequested = false; + bool artifactMutationRequested = false; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffResult + : LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionResult { + bool noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = true; + bool readinessProjectionAccepted = false; + bool statusHandoffRecordAccepted = false; + bool statusHandoffReadinessProjectionMatchAccepted = false; + bool disabledStatusHandoffAccepted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked = false; + bool disabledStatusHandoffStateAccepted = false; + bool statusHandoffFailureMappingAccepted = false; + bool loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffReady = false; + + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardInput { + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffResult statusHandoff; + std::string platform; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName; + bool statusHandoffAccepted = false; + bool publicationGuardReviewed = false; + bool publicationGuardRecorded = false; + bool publicationGuardDisabled = true; + bool publicationGuardMatchesStatusHandoffEvidence = false; + bool disabledPublicationGuardRegistered = false; + bool publicationGuardAcceptsStatusHandoffEvidence = false; + bool publicationGuardReturnsDisabledPublication = true; + bool publicationGuardBlocksDispatchConsumption = true; + bool publicationGuardBlocksDispatchResultExecution = true; + bool publicationGuardBlocksStatusPublication = true; + bool publicationGuardBlocksReadinessPublication = true; + bool publicationGuardBlocksStatusHandoffPublication = true; + bool publicationGuardBlocksPublicationGuardPublication = true; + bool publicationGuardBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication = true; + bool callbackInvocationStillDisabled = true; + bool callbackInvocationRefused = true; + bool callbackInvocationRefusalReviewed = false; + bool publicationGuardStopsBeforeCallbackInvocation = true; + bool publicationGuardStopsBeforeCallbackResultExecution = true; + bool publicationGuardStopsBeforeDispatchConsumption = true; + bool publicationGuardStopsBeforeDispatchResultExecution = true; + bool publicationGuardStopsBeforeDispatchStatusPublication = true; + bool publicationGuardStopsBeforeReadinessPublication = true; + bool publicationGuardStopsBeforeStatusHandoffPublication = true; + bool publicationGuardStopsBeforePublicationGuardPublication = true; + bool publicationGuardStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication = true; + bool publicationGuardStopsBeforePlatformApi = true; + bool publicationGuardRequiresSeparateExecutionBatch = true; + bool publicationGuardProducesNoDynamicHandle = true; + bool publicationGuardStoresNoDynamicHandle = true; + bool publicationGuardReleasesNoDynamicHandle = true; + bool publicationGuardResolvesNoSymbols = true; + bool publicationGuardStoresNoSymbolTable = true; + bool publicationGuardCreatesNoRuntime = true; + bool publicationGuardFailureMappingReviewed = false; + bool unloadExecutionStillDisabled = true; + bool symbolResolutionStillDisabled = true; + bool productionLoaderExecutionDisabled = true; + bool realAdapterExecutionDisabled = true; + bool loadOnlyExecutionDisabled = true; + bool separateExecutionBatchRequired = true; + bool macosDeferredByOperator = true; + + bool callbackInvocationAttempted = false; + bool callbackResultExecutionAttempted = false; + bool dispatchHandoffExecutionAttempted = false; + bool dispatchStatusPublicationAttempted = false; + bool dispatchConsumerConsumptionAttempted = false; + bool dispatchResultExecutionAttempted = false; + bool resultHandoffStatusPublicationAttempted = false; + bool readinessProjectionStatusPublicationAttempted = false; + bool statusHandoffPublicationAttempted = false; + bool publicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = false; + bool runtimePlatformLoadAttempted = false; + bool runtimePlatformUnloadAttempted = false; + bool runtimePlatformSymbolResolutionAttempted = false; + bool sdxlCallRequested = false; + bool bridgeCallRequested = false; + bool serverConnectivityCheckRequested = false; + bool walletLifecycleRequested = false; + bool syncRequested = false; + bool syncStatusPollingRequested = false; + bool workerQueueRequested = false; + bool walletStateMutationRequested = false; + bool walletPersistenceRequested = false; + bool settingsWriteRequested = false; + bool sendImportExportRequested = false; + bool artifactMutationRequested = false; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResult + : LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffResult { + bool noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = true; + bool statusHandoffAccepted = false; + bool publicationGuardRecordAccepted = false; + bool publicationGuardStatusHandoffMatchAccepted = false; + bool disabledPublicationGuardAccepted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked = false; + bool disabledPublicationGuardStateAccepted = false; + bool publicationGuardFailureMappingAccepted = false; + bool loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardReady = false; + + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffInput { + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResult publicationGuard; + std::string platform; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName; + bool publicationGuardAccepted = false; + bool resultHandoffReviewed = false; + bool resultHandoffRecorded = false; + bool resultHandoffDisabled = true; + bool resultHandoffMatchesPublicationGuardEvidence = false; + bool disabledResultHandoffRegistered = false; + bool resultHandoffAcceptsPublicationGuardEvidence = false; + bool resultHandoffReturnsDisabledResult = true; + bool resultHandoffBlocksDispatchConsumption = true; + bool resultHandoffBlocksDispatchResultExecution = true; + bool resultHandoffBlocksStatusPublication = true; + bool resultHandoffBlocksReadinessPublication = true; + bool resultHandoffBlocksStatusHandoffPublication = true; + bool resultHandoffBlocksPublicationGuardPublication = true; + bool resultHandoffBlocksPublicationGuardResultHandoffPublication = true; + bool resultHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication = true; + bool callbackInvocationStillDisabled = true; + bool callbackInvocationRefused = true; + bool callbackInvocationRefusalReviewed = false; + bool resultHandoffStopsBeforeCallbackInvocation = true; + bool resultHandoffStopsBeforeCallbackResultExecution = true; + bool resultHandoffStopsBeforeDispatchConsumption = true; + bool resultHandoffStopsBeforeDispatchResultExecution = true; + bool resultHandoffStopsBeforeDispatchStatusPublication = true; + bool resultHandoffStopsBeforeReadinessPublication = true; + bool resultHandoffStopsBeforeStatusHandoffPublication = true; + bool resultHandoffStopsBeforePublicationGuardPublication = true; + bool resultHandoffStopsBeforePublicationGuardResultHandoffPublication = true; + bool resultHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication = true; + bool resultHandoffStopsBeforePlatformApi = true; + bool resultHandoffRequiresSeparateExecutionBatch = true; + bool resultHandoffProducesNoDynamicHandle = true; + bool resultHandoffStoresNoDynamicHandle = true; + bool resultHandoffReleasesNoDynamicHandle = true; + bool resultHandoffResolvesNoSymbols = true; + bool resultHandoffStoresNoSymbolTable = true; + bool resultHandoffCreatesNoRuntime = true; + bool resultHandoffFailureMappingReviewed = false; + bool unloadExecutionStillDisabled = true; + bool symbolResolutionStillDisabled = true; + bool productionLoaderExecutionDisabled = true; + bool realAdapterExecutionDisabled = true; + bool loadOnlyExecutionDisabled = true; + bool separateExecutionBatchRequired = true; + bool macosDeferredByOperator = true; + + bool callbackInvocationAttempted = false; + bool callbackResultExecutionAttempted = false; + bool dispatchHandoffExecutionAttempted = false; + bool dispatchStatusPublicationAttempted = false; + bool dispatchConsumerConsumptionAttempted = false; + bool dispatchResultExecutionAttempted = false; + bool resultHandoffStatusPublicationAttempted = false; + bool readinessProjectionStatusPublicationAttempted = false; + bool statusHandoffPublicationAttempted = false; + bool publicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = false; + bool runtimePlatformLoadAttempted = false; + bool runtimePlatformUnloadAttempted = false; + bool runtimePlatformSymbolResolutionAttempted = false; + bool sdxlCallRequested = false; + bool bridgeCallRequested = false; + bool serverConnectivityCheckRequested = false; + bool walletLifecycleRequested = false; + bool syncRequested = false; + bool syncStatusPollingRequested = false; + bool workerQueueRequested = false; + bool walletStateMutationRequested = false; + bool walletPersistenceRequested = false; + bool settingsWriteRequested = false; + bool sendImportExportRequested = false; + bool artifactMutationRequested = false; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffResult + : LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResult { + bool noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = true; + bool publicationGuardAccepted = false; + bool resultHandoffRecordAccepted = false; + bool resultHandoffPublicationGuardMatchAccepted = false; + bool disabledResultHandoffAccepted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationBlocked = false; + bool disabledResultHandoffStateAccepted = false; + bool resultHandoffFailureMappingAccepted = false; + bool loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReady = false; + + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionInput { + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffResult resultHandoff; + std::string platform; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName; + bool resultHandoffAccepted = false; + bool readinessProjectionReviewed = false; + bool readinessProjectionRecorded = false; + bool readinessProjectionDisabled = true; + bool readinessProjectionMatchesResultHandoffEvidence = false; + bool disabledReadinessProjectionRegistered = false; + bool readinessProjectionAcceptsResultHandoffEvidence = false; + bool readinessProjectionReturnsDisabledReadiness = true; + bool readinessProjectionBlocksDispatchConsumption = true; + bool readinessProjectionBlocksDispatchResultExecution = true; + bool readinessProjectionBlocksStatusPublication = true; + bool readinessProjectionBlocksReadinessPublication = true; + bool readinessProjectionBlocksStatusHandoffPublication = true; + bool readinessProjectionBlocksPublicationGuardPublication = true; + bool readinessProjectionBlocksPublicationGuardResultHandoffPublication = true; + bool readinessProjectionBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication = true; + bool readinessProjectionBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication = true; + bool callbackInvocationStillDisabled = true; + bool callbackInvocationRefused = true; + bool callbackInvocationRefusalReviewed = false; + bool readinessProjectionStopsBeforeCallbackInvocation = true; + bool readinessProjectionStopsBeforeCallbackResultExecution = true; + bool readinessProjectionStopsBeforeDispatchConsumption = true; + bool readinessProjectionStopsBeforeDispatchResultExecution = true; + bool readinessProjectionStopsBeforeDispatchStatusPublication = true; + bool readinessProjectionStopsBeforeReadinessPublication = true; + bool readinessProjectionStopsBeforeStatusHandoffPublication = true; + bool readinessProjectionStopsBeforePublicationGuardPublication = true; + bool readinessProjectionStopsBeforePublicationGuardResultHandoffPublication = true; + bool readinessProjectionStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication = true; + bool readinessProjectionStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication = true; + bool readinessProjectionStopsBeforePlatformApi = true; + bool readinessProjectionRequiresSeparateExecutionBatch = true; + bool readinessProjectionProducesNoDynamicHandle = true; + bool readinessProjectionStoresNoDynamicHandle = true; + bool readinessProjectionReleasesNoDynamicHandle = true; + bool readinessProjectionResolvesNoSymbols = true; + bool readinessProjectionStoresNoSymbolTable = true; + bool readinessProjectionCreatesNoRuntime = true; + bool readinessProjectionFailureMappingReviewed = false; + bool unloadExecutionStillDisabled = true; + bool symbolResolutionStillDisabled = true; + bool productionLoaderExecutionDisabled = true; + bool realAdapterExecutionDisabled = true; + bool loadOnlyExecutionDisabled = true; + bool separateExecutionBatchRequired = true; + bool macosDeferredByOperator = true; + + bool callbackInvocationAttempted = false; + bool callbackResultExecutionAttempted = false; + bool dispatchHandoffExecutionAttempted = false; + bool dispatchStatusPublicationAttempted = false; + bool dispatchConsumerConsumptionAttempted = false; + bool dispatchResultExecutionAttempted = false; + bool resultHandoffStatusPublicationAttempted = false; + bool readinessProjectionStatusPublicationAttempted = false; + bool statusHandoffPublicationAttempted = false; + bool publicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool runtimePlatformLoadAttempted = false; + bool runtimePlatformUnloadAttempted = false; + bool runtimePlatformSymbolResolutionAttempted = false; + bool sdxlCallRequested = false; + bool bridgeCallRequested = false; + bool serverConnectivityCheckRequested = false; + bool walletLifecycleRequested = false; + bool syncRequested = false; + bool syncStatusPollingRequested = false; + bool workerQueueRequested = false; + bool walletStateMutationRequested = false; + bool walletPersistenceRequested = false; + bool settingsWriteRequested = false; + bool sendImportExportRequested = false; + bool artifactMutationRequested = false; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionResult + : LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffResult { + bool noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = true; + bool resultHandoffAccepted = false; + bool readinessProjectionRecordAccepted = false; + bool readinessProjectionResultHandoffMatchAccepted = false; + bool disabledReadinessProjectionAccepted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationBlocked = false; + bool disabledReadinessProjectionStateAccepted = false; + bool readinessProjectionFailureMappingAccepted = false; + bool loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionReady = false; + + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffInput { + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionResult readinessProjection; + std::string platform; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName; + bool readinessProjectionAccepted = false; + bool statusHandoffReviewed = false; + bool statusHandoffRecorded = false; + bool statusHandoffDisabled = true; + bool statusHandoffMatchesReadinessProjectionEvidence = false; + bool disabledStatusHandoffRegistered = false; + bool statusHandoffAcceptsReadinessProjectionEvidence = false; + bool statusHandoffReturnsDisabledStatus = true; + bool statusHandoffBlocksDispatchConsumption = true; + bool statusHandoffBlocksDispatchResultExecution = true; + bool statusHandoffBlocksStatusPublication = true; + bool statusHandoffBlocksReadinessPublication = true; + bool statusHandoffBlocksStatusHandoffPublication = true; + bool statusHandoffBlocksPublicationGuardPublication = true; + bool statusHandoffBlocksPublicationGuardResultHandoffPublication = true; + bool statusHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication = true; + bool statusHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication = true; + bool statusHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication = true; + bool callbackInvocationStillDisabled = true; + bool callbackInvocationRefused = true; + bool callbackInvocationRefusalReviewed = false; + bool statusHandoffStopsBeforeCallbackInvocation = true; + bool statusHandoffStopsBeforeCallbackResultExecution = true; + bool statusHandoffStopsBeforeDispatchConsumption = true; + bool statusHandoffStopsBeforeDispatchResultExecution = true; + bool statusHandoffStopsBeforeDispatchStatusPublication = true; + bool statusHandoffStopsBeforeReadinessPublication = true; + bool statusHandoffStopsBeforeStatusHandoffPublication = true; + bool statusHandoffStopsBeforePublicationGuardPublication = true; + bool statusHandoffStopsBeforePublicationGuardResultHandoffPublication = true; + bool statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication = true; + bool statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication = true; + bool statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication = true; + bool statusHandoffStopsBeforePlatformApi = true; + bool statusHandoffRequiresSeparateExecutionBatch = true; + bool statusHandoffProducesNoDynamicHandle = true; + bool statusHandoffStoresNoDynamicHandle = true; + bool statusHandoffReleasesNoDynamicHandle = true; + bool statusHandoffResolvesNoSymbols = true; + bool statusHandoffStoresNoSymbolTable = true; + bool statusHandoffCreatesNoRuntime = true; + bool statusHandoffFailureMappingReviewed = false; + bool unloadExecutionStillDisabled = true; + bool symbolResolutionStillDisabled = true; + bool productionLoaderExecutionDisabled = true; + bool realAdapterExecutionDisabled = true; + bool loadOnlyExecutionDisabled = true; + bool separateExecutionBatchRequired = true; + bool macosDeferredByOperator = true; + + bool callbackInvocationAttempted = false; + bool callbackResultExecutionAttempted = false; + bool dispatchHandoffExecutionAttempted = false; + bool dispatchStatusPublicationAttempted = false; + bool dispatchConsumerConsumptionAttempted = false; + bool dispatchResultExecutionAttempted = false; + bool resultHandoffStatusPublicationAttempted = false; + bool readinessProjectionStatusPublicationAttempted = false; + bool statusHandoffPublicationAttempted = false; + bool publicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool runtimePlatformLoadAttempted = false; + bool runtimePlatformUnloadAttempted = false; + bool runtimePlatformSymbolResolutionAttempted = false; + bool sdxlCallRequested = false; + bool bridgeCallRequested = false; + bool serverConnectivityCheckRequested = false; + bool walletLifecycleRequested = false; + bool syncRequested = false; + bool syncStatusPollingRequested = false; + bool workerQueueRequested = false; + bool walletStateMutationRequested = false; + bool walletPersistenceRequested = false; + bool settingsWriteRequested = false; + bool sendImportExportRequested = false; + bool artifactMutationRequested = false; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffResult + : LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionResult { + bool noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = true; + bool readinessProjectionAccepted = false; + bool statusHandoffRecordAccepted = false; + bool statusHandoffReadinessProjectionMatchAccepted = false; + bool disabledStatusHandoffAccepted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked = false; + bool disabledStatusHandoffStateAccepted = false; + bool statusHandoffFailureMappingAccepted = false; + bool loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffReady = false; + + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardInput { + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffResult statusHandoff; + std::string platform; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName; + bool statusHandoffAccepted = false; + bool publicationGuardReviewed = false; + bool publicationGuardRecorded = false; + bool publicationGuardDisabled = true; + bool publicationGuardMatchesStatusHandoffEvidence = false; + bool disabledPublicationGuardRegistered = false; + bool publicationGuardAcceptsStatusHandoffEvidence = false; + bool publicationGuardReturnsDisabledPublication = true; + bool publicationGuardBlocksDispatchConsumption = true; + bool publicationGuardBlocksDispatchResultExecution = true; + bool publicationGuardBlocksStatusPublication = true; + bool publicationGuardBlocksReadinessPublication = true; + bool publicationGuardBlocksStatusHandoffPublication = true; + bool publicationGuardBlocksPublicationGuardPublication = true; + bool publicationGuardBlocksPublicationGuardResultHandoffPublication = true; + bool publicationGuardBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication = true; + bool publicationGuardBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication = true; + bool publicationGuardBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication = true; + bool publicationGuardBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication = true; + bool callbackInvocationStillDisabled = true; + bool callbackInvocationRefused = true; + bool callbackInvocationRefusalReviewed = false; + bool publicationGuardStopsBeforeCallbackInvocation = true; + bool publicationGuardStopsBeforeCallbackResultExecution = true; + bool publicationGuardStopsBeforeDispatchConsumption = true; + bool publicationGuardStopsBeforeDispatchResultExecution = true; + bool publicationGuardStopsBeforeDispatchStatusPublication = true; + bool publicationGuardStopsBeforeReadinessPublication = true; + bool publicationGuardStopsBeforeStatusHandoffPublication = true; + bool publicationGuardStopsBeforePublicationGuardPublication = true; + bool publicationGuardStopsBeforePublicationGuardResultHandoffPublication = true; + bool publicationGuardStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication = true; + bool publicationGuardStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication = true; + bool publicationGuardStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication = true; + bool publicationGuardStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication = true; + bool publicationGuardStopsBeforePlatformApi = true; + bool publicationGuardRequiresSeparateExecutionBatch = true; + bool publicationGuardProducesNoDynamicHandle = true; + bool publicationGuardStoresNoDynamicHandle = true; + bool publicationGuardReleasesNoDynamicHandle = true; + bool publicationGuardResolvesNoSymbols = true; + bool publicationGuardStoresNoSymbolTable = true; + bool publicationGuardCreatesNoRuntime = true; + bool publicationGuardFailureMappingReviewed = false; + bool unloadExecutionStillDisabled = true; + bool symbolResolutionStillDisabled = true; + bool productionLoaderExecutionDisabled = true; + bool realAdapterExecutionDisabled = true; + bool loadOnlyExecutionDisabled = true; + bool separateExecutionBatchRequired = true; + bool macosDeferredByOperator = true; + + bool callbackInvocationAttempted = false; + bool callbackResultExecutionAttempted = false; + bool dispatchHandoffExecutionAttempted = false; + bool dispatchStatusPublicationAttempted = false; + bool dispatchConsumerConsumptionAttempted = false; + bool dispatchResultExecutionAttempted = false; + bool resultHandoffStatusPublicationAttempted = false; + bool readinessProjectionStatusPublicationAttempted = false; + bool statusHandoffPublicationAttempted = false; + bool publicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = false; + bool runtimePlatformLoadAttempted = false; + bool runtimePlatformUnloadAttempted = false; + bool runtimePlatformSymbolResolutionAttempted = false; + bool sdxlCallRequested = false; + bool bridgeCallRequested = false; + bool serverConnectivityCheckRequested = false; + bool walletLifecycleRequested = false; + bool syncRequested = false; + bool syncStatusPollingRequested = false; + bool workerQueueRequested = false; + bool walletStateMutationRequested = false; + bool walletPersistenceRequested = false; + bool settingsWriteRequested = false; + bool sendImportExportRequested = false; + bool artifactMutationRequested = false; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResult + : LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffResult { + bool noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = true; + bool statusHandoffAccepted = false; + bool publicationGuardRecordAccepted = false; + bool publicationGuardStatusHandoffMatchAccepted = false; + bool disabledPublicationGuardAccepted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked = false; + bool disabledPublicationGuardStateAccepted = false; + bool publicationGuardFailureMappingAccepted = false; + bool loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardReady = false; + + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffInput { + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResult publicationGuard; + std::string platform; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName; + bool publicationGuardAccepted = false; + bool resultHandoffReviewed = false; + bool resultHandoffRecorded = false; + bool resultHandoffDisabled = true; + bool resultHandoffMatchesPublicationGuardEvidence = false; + bool disabledResultHandoffRegistered = false; + bool resultHandoffAcceptsPublicationGuardEvidence = false; + bool resultHandoffReturnsDisabledResult = true; + bool resultHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication = true; + bool callbackInvocationStillDisabled = true; + bool callbackInvocationRefused = true; + bool callbackInvocationRefusalReviewed = false; + bool resultHandoffStopsBeforeCallbackInvocation = true; + bool resultHandoffStopsBeforeCallbackResultExecution = true; + bool resultHandoffStopsBeforeDispatchConsumption = true; + bool resultHandoffStopsBeforeDispatchResultExecution = true; + bool resultHandoffStopsBeforeDispatchStatusPublication = true; + bool resultHandoffStopsBeforeReadinessPublication = true; + bool resultHandoffStopsBeforeStatusHandoffPublication = true; + bool resultHandoffStopsBeforePublicationGuardPublication = true; + bool resultHandoffStopsBeforePublicationGuardResultHandoffPublication = true; + bool resultHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication = true; + bool resultHandoffStopsBeforePlatformApi = true; + bool resultHandoffRequiresSeparateExecutionBatch = true; + bool resultHandoffProducesNoDynamicHandle = true; + bool resultHandoffStoresNoDynamicHandle = true; + bool resultHandoffReleasesNoDynamicHandle = true; + bool resultHandoffResolvesNoSymbols = true; + bool resultHandoffStoresNoSymbolTable = true; + bool resultHandoffCreatesNoRuntime = true; + bool resultHandoffFailureMappingReviewed = false; + bool unloadExecutionStillDisabled = true; + bool symbolResolutionStillDisabled = true; + bool productionLoaderExecutionDisabled = true; + bool realAdapterExecutionDisabled = true; + bool loadOnlyExecutionDisabled = true; + bool separateExecutionBatchRequired = true; + bool macosDeferredByOperator = true; + + bool callbackInvocationAttempted = false; + bool callbackResultExecutionAttempted = false; + bool dispatchHandoffExecutionAttempted = false; + bool dispatchStatusPublicationAttempted = false; + bool dispatchConsumerConsumptionAttempted = false; + bool dispatchResultExecutionAttempted = false; + bool resultHandoffStatusPublicationAttempted = false; + bool readinessProjectionStatusPublicationAttempted = false; + bool statusHandoffPublicationAttempted = false; + bool publicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = false; + bool runtimePlatformLoadAttempted = false; + bool runtimePlatformUnloadAttempted = false; + bool runtimePlatformSymbolResolutionAttempted = false; + bool sdxlCallRequested = false; + bool bridgeCallRequested = false; + bool serverConnectivityCheckRequested = false; + bool walletLifecycleRequested = false; + bool syncRequested = false; + bool syncStatusPollingRequested = false; + bool workerQueueRequested = false; + bool walletStateMutationRequested = false; + bool walletPersistenceRequested = false; + bool settingsWriteRequested = false; + bool sendImportExportRequested = false; + bool artifactMutationRequested = false; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffResult + : LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResult { + bool noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = true; + bool publicationGuardAccepted = false; + bool resultHandoffRecordAccepted = false; + bool resultHandoffPublicationGuardMatchAccepted = false; + bool disabledResultHandoffAccepted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationBlocked = false; + bool disabledResultHandoffStateAccepted = false; + bool resultHandoffFailureMappingAccepted = false; + bool loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReady = false; + + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultConsumerName; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionInput { + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffResult resultHandoff; + std::string platform; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName; + bool resultHandoffAccepted = false; + bool readinessProjectionReviewed = false; + bool readinessProjectionRecorded = false; + bool readinessProjectionDisabled = true; + bool readinessProjectionMatchesResultHandoffEvidence = false; + bool disabledReadinessProjectionRegistered = false; + bool readinessProjectionAcceptsResultHandoffEvidence = false; + bool readinessProjectionReturnsDisabledReadiness = true; + bool readinessProjectionBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication = true; + bool readinessProjectionBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication = true; + bool callbackInvocationStillDisabled = true; + bool callbackInvocationRefused = true; + bool callbackInvocationRefusalReviewed = false; + bool readinessProjectionStopsBeforeCallbackInvocation = true; + bool readinessProjectionStopsBeforeCallbackResultExecution = true; + bool readinessProjectionStopsBeforeDispatchConsumption = true; + bool readinessProjectionStopsBeforeDispatchResultExecution = true; + bool readinessProjectionStopsBeforeDispatchStatusPublication = true; + bool readinessProjectionStopsBeforeReadinessPublication = true; + bool readinessProjectionStopsBeforeStatusHandoffPublication = true; + bool readinessProjectionStopsBeforePublicationGuardPublication = true; + bool readinessProjectionStopsBeforePublicationGuardResultHandoffPublication = true; + bool readinessProjectionStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublication = true; + bool readinessProjectionStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublication = true; + bool readinessProjectionStopsBeforePlatformApi = true; + bool readinessProjectionRequiresSeparateExecutionBatch = true; + bool readinessProjectionProducesNoDynamicHandle = true; + bool readinessProjectionStoresNoDynamicHandle = true; + bool readinessProjectionReleasesNoDynamicHandle = true; + bool readinessProjectionResolvesNoSymbols = true; + bool readinessProjectionStoresNoSymbolTable = true; + bool readinessProjectionCreatesNoRuntime = true; + bool readinessProjectionFailureMappingReviewed = false; + bool unloadExecutionStillDisabled = true; + bool symbolResolutionStillDisabled = true; + bool productionLoaderExecutionDisabled = true; + bool realAdapterExecutionDisabled = true; + bool loadOnlyExecutionDisabled = true; + bool separateExecutionBatchRequired = true; + bool macosDeferredByOperator = true; + + bool callbackInvocationAttempted = false; + bool callbackResultExecutionAttempted = false; + bool dispatchHandoffExecutionAttempted = false; + bool dispatchStatusPublicationAttempted = false; + bool dispatchConsumerConsumptionAttempted = false; + bool dispatchResultExecutionAttempted = false; + bool resultHandoffStatusPublicationAttempted = false; + bool readinessProjectionStatusPublicationAttempted = false; + bool statusHandoffPublicationAttempted = false; + bool publicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffPublicationAttempted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = false; + bool runtimePlatformLoadAttempted = false; + bool runtimePlatformUnloadAttempted = false; + bool runtimePlatformSymbolResolutionAttempted = false; + bool sdxlCallRequested = false; + bool bridgeCallRequested = false; + bool serverConnectivityCheckRequested = false; + bool walletLifecycleRequested = false; + bool syncRequested = false; + bool syncStatusPollingRequested = false; + bool workerQueueRequested = false; + bool walletStateMutationRequested = false; + bool walletPersistenceRequested = false; + bool settingsWriteRequested = false; + bool sendImportExportRequested = false; + bool artifactMutationRequested = false; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionResult + : LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffResult { + bool noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationAttempted = true; + bool resultHandoffAccepted = false; + bool readinessProjectionRecordAccepted = false; + bool readinessProjectionResultHandoffMatchAccepted = false; + bool disabledReadinessProjectionAccepted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionPublicationBlocked = false; + bool disabledReadinessProjectionStateAccepted = false; + bool readinessProjectionFailureMappingAccepted = false; + bool loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionReady = false; + + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessConsumerName; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffInput + : LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionInput { + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionResult readinessProjection; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName; + bool readinessProjectionAccepted = false; + bool statusHandoffReviewed = false; + bool statusHandoffRecorded = false; + bool statusHandoffDisabled = true; + bool statusHandoffMatchesReadinessProjectionEvidence = false; + bool disabledStatusHandoffRegistered = false; + bool statusHandoffAcceptsReadinessProjectionEvidence = false; + bool statusHandoffReturnsDisabledStatus = true; + bool statusHandoffBlocksDispatchConsumption = true; + bool statusHandoffBlocksDispatchResultExecution = true; + bool statusHandoffBlocksStatusPublication = true; + bool statusHandoffBlocksReadinessPublication = true; + bool statusHandoffBlocksStatusHandoffPublication = true; + bool statusHandoffBlocksPublicationGuardPublication = true; + bool statusHandoffBlocksPublicationGuardResultHandoffPublication = true; + bool statusHandoffBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication = true; + bool statusHandoffStopsBeforeCallbackInvocation = true; + bool statusHandoffStopsBeforeCallbackResultExecution = true; + bool statusHandoffStopsBeforeDispatchConsumption = true; + bool statusHandoffStopsBeforeDispatchResultExecution = true; + bool statusHandoffStopsBeforeDispatchStatusPublication = true; + bool statusHandoffStopsBeforeReadinessPublication = true; + bool statusHandoffStopsBeforeStatusHandoffPublication = true; + bool statusHandoffStopsBeforePublicationGuardPublication = true; + bool statusHandoffStopsBeforePublicationGuardResultHandoffPublication = true; + bool statusHandoffStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication = true; + bool statusHandoffStopsBeforePlatformApi = true; + bool statusHandoffRequiresSeparateExecutionBatch = true; + bool statusHandoffProducesNoDynamicHandle = true; + bool statusHandoffStoresNoDynamicHandle = true; + bool statusHandoffReleasesNoDynamicHandle = true; + bool statusHandoffResolvesNoSymbols = true; + bool statusHandoffStoresNoSymbolTable = true; + bool statusHandoffCreatesNoRuntime = true; + bool statusHandoffFailureMappingReviewed = false; + + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = false; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffResult + : LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionResult { + bool noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationAttempted = true; + bool readinessProjectionAccepted = false; + bool statusHandoffRecordAccepted = false; + bool statusHandoffReadinessProjectionMatchAccepted = false; + bool disabledStatusHandoffAccepted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationBlocked = false; + bool disabledStatusHandoffStateAccepted = false; + bool statusHandoffFailureMappingAccepted = false; + bool loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffReady = false; + + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusConsumerName; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardInput + : LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffInput { + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffResult statusHandoff; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName; + bool statusHandoffAccepted = false; + bool publicationGuardReviewed = false; + bool publicationGuardRecorded = false; + bool publicationGuardDisabled = true; + bool publicationGuardMatchesStatusHandoffEvidence = false; + bool disabledPublicationGuardRegistered = false; + bool publicationGuardAcceptsStatusHandoffEvidence = false; + bool publicationGuardReturnsDisabledPublication = true; + bool publicationGuardBlocksDispatchConsumption = true; + bool publicationGuardBlocksDispatchResultExecution = true; + bool publicationGuardBlocksStatusPublication = true; + bool publicationGuardBlocksReadinessPublication = true; + bool publicationGuardBlocksStatusHandoffPublication = true; + bool publicationGuardBlocksPublicationGuardPublication = true; + bool publicationGuardBlocksPublicationGuardResultHandoffPublication = true; + bool publicationGuardBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication = true; + bool publicationGuardBlocksPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication = true; + bool publicationGuardStopsBeforeCallbackInvocation = true; + bool publicationGuardStopsBeforeCallbackResultExecution = true; + bool publicationGuardStopsBeforeDispatchConsumption = true; + bool publicationGuardStopsBeforeDispatchResultExecution = true; + bool publicationGuardStopsBeforeDispatchStatusPublication = true; + bool publicationGuardStopsBeforeReadinessPublication = true; + bool publicationGuardStopsBeforeStatusHandoffPublication = true; + bool publicationGuardStopsBeforePublicationGuardPublication = true; + bool publicationGuardStopsBeforePublicationGuardResultHandoffPublication = true; + bool publicationGuardStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublication = true; + bool publicationGuardStopsBeforePublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublication = true; + bool publicationGuardStopsBeforePlatformApi = true; + bool publicationGuardRequiresSeparateExecutionBatch = true; + bool publicationGuardProducesNoDynamicHandle = true; + bool publicationGuardStoresNoDynamicHandle = true; + bool publicationGuardReleasesNoDynamicHandle = true; + bool publicationGuardResolvesNoSymbols = true; + bool publicationGuardStoresNoSymbolTable = true; + bool publicationGuardCreatesNoRuntime = true; + bool publicationGuardFailureMappingReviewed = false; + + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = false; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResult + : LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffResult { + bool noPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationAttempted = true; + bool statusHandoffAccepted = false; + bool publicationGuardRecordAccepted = false; + bool publicationGuardStatusHandoffMatchAccepted = false; + bool disabledPublicationGuardAccepted = false; + bool publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardPublicationBlocked = false; + bool disabledPublicationGuardStateAccepted = false; + bool publicationGuardFailureMappingAccepted = false; + bool loadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardReady = false; + + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardId; + std::string publicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationConsumerName; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffInput + : LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffInput { + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResult publicationGuard; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffResult + : LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResult { + bool batch54ResultHandoffSurfaceReady = false; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionInput + : LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionInput { + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffResult resultHandoff; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionResult + : LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffResult { + bool batch55ReadinessProjectionSurfaceReady = false; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffInput + : LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffInput { + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionResult readinessProjection; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffResult + : LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionResult { + bool batch56StatusHandoffSurfaceReady = false; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardInput + : LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardInput { + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffResult statusHandoff; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResult + : LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffResult { + bool batch57PublicationGuardSurfaceReady = false; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffInput + : LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffInput { + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResult publicationGuard; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffResult + : LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResult { + bool batch58ResultHandoffSurfaceReady = false; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionInput + : LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionInput { + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffResult resultHandoff; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionResult + : LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffResult { + bool batch59ReadinessProjectionSurfaceReady = false; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffInput + : LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffInput { + LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionResult readinessProjection; +}; + +struct LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffResult + : LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionResult { + bool batch60StatusHandoffSurfaceReady = false; +}; + +struct LiteBridgeRuntimeDryDispatchResult { + bool ok = false; + bool fakeOnlyDispatch = true; + bool fakeCallAttempted = false; + bool noRealBridgeCalls = true; + bool noSdxlCalls = true; + bool noNetwork = true; + bool noWalletLifecycle = true; + bool noSyncStarted = true; + bool noSyncStatusPolled = true; + bool noWorkerQueueEnqueue = true; + bool noWalletStateMutation = true; + bool noWalletPersistence = true; + bool noSettingsPersistence = true; + bool noSendImportExportExecution = true; + bool noArtifactMutation = true; + bool boolValue = false; + LiteBridgeStringResult stringResult; + LiteBridgeRuntimeStatus status = LiteBridgeRuntimeStatus::Unavailable; + LiteBridgeRuntimeDryDispatchOperation operation = LiteBridgeRuntimeDryDispatchOperation::Execute; + std::string error; + std::string summary; +}; + +class LiteBridgeOwnedString { +public: + using FreeStringFn = LiteClientBridgeApi::FreeStringFn; + + LiteBridgeOwnedString() = default; + LiteBridgeOwnedString(char* rawValue, FreeStringFn freeString); + LiteBridgeOwnedString(const LiteBridgeOwnedString&) = delete; + LiteBridgeOwnedString& operator=(const LiteBridgeOwnedString&) = delete; + LiteBridgeOwnedString(LiteBridgeOwnedString&& other) noexcept; + LiteBridgeOwnedString& operator=(LiteBridgeOwnedString&& other) noexcept; + ~LiteBridgeOwnedString(); + + LiteBridgeStringResult intoResult(); + bool rawPointerReceived() const { return rawPointerReceived_; } + bool copiedBeforeFree() const { return copiedBeforeFree_; } + bool freed() const { return freed_; } + bool rawPointerEscaped() const { return false; } + +private: + friend class LiteBridgeRuntime; + + LiteBridgeOwnedString(char* rawValue, + FreeStringFn freeString, + std::shared_ptr teardownState); + + void copyValueBeforeFree(); + void releaseRawValue(); + void releaseRuntimeOwnership(); + void moveFrom(LiteBridgeOwnedString&& other) noexcept; + + char* rawValue_ = nullptr; + FreeStringFn freeString_ = nullptr; + std::shared_ptr teardownState_; + bool rawPointerReceived_ = false; + bool copiedBeforeFree_ = false; + bool freed_ = false; + bool resultTaken_ = false; + bool runtimeOwnershipReleased_ = false; + std::string copiedValue_; +}; + +class LiteBridgeRuntime { +public: + static LiteBridgeRuntime unavailable(std::string reason); + static LiteBridgeRuntime fromBindingResult(const LiteBridgeRuntimeBindingResult& result); + static LiteBridgeRuntime fromFakeDynamicLoaderResult( + const LiteBridgeRuntimeFakeDynamicLoaderResult& result); + + LiteBridgeRuntime() = default; + LiteBridgeRuntime(const LiteBridgeRuntime&) = delete; + LiteBridgeRuntime& operator=(const LiteBridgeRuntime&) = delete; + LiteBridgeRuntime(LiteBridgeRuntime&& other) noexcept; + LiteBridgeRuntime& operator=(LiteBridgeRuntime&& other) noexcept; + ~LiteBridgeRuntime(); + + bool available() const; + LiteBridgeRuntimeStatus status() const; + const std::string& unavailableReason() const { return unavailableReason_; } + bool shutdownCalled() const; + bool shutdownPending() const; + bool dynamicLibraryUnloadDeferred() const; + bool dynamicLibraryHandlePresent() const; + bool dynamicLibraryUnloadCalled() const; + bool fakeDispatchAllowed() const { return fakeDispatchAllowed_; } + std::size_t outstandingOwnedStringCount() const; + + LiteBridgeOwnedString takeOwnedString(char* rawValue); + LiteBridgeRuntimeDryDispatchResult dryDispatchWalletExists(const std::string& chainName); + LiteBridgeRuntimeDryDispatchResult dryDispatchCheckServerOnline(const std::string& server); + LiteBridgeRuntimeDryDispatchResult dryDispatchExecute(const std::string& command, + const std::string& args); + LiteBridgeRuntimeDryDispatchResult dryDispatchInitializeNew(bool dangerous, + const std::string& server); + LiteBridgeRuntimeDryDispatchResult dryDispatchInitializeExisting(bool dangerous, + const std::string& server); + LiteBridgeRuntimeDryDispatchResult dryDispatchInitializeNewFromPhrase(bool dangerous, + const std::string& server, + const std::string& seed, + unsigned long long birthday, + unsigned long long account, + bool overwrite); + LiteBridgeRuntimeDryDispatchResult dryDispatchShutdown(); + void shutdown(); + +private: + LiteBridgeRuntime(LiteClientBridgeApi api, + std::string unavailableReason, + LiteBridgeRuntimeStatus status); + LiteBridgeRuntime(LiteClientBridgeApi api, + std::string unavailableReason, + LiteBridgeRuntimeStatus status, + LiteBridgeRuntimeDynamicLibraryHandle dynamicLibraryHandle); + + LiteBridgeRuntimeDryDispatchResult makeDryDispatchResult( + LiteBridgeRuntimeDryDispatchOperation operation) const; + bool prepareDryDispatch(LiteBridgeRuntimeDryDispatchResult& result, + bool symbolAvailable) const; + LiteBridgeRuntimeDryDispatchResult dryDispatchOwnedString( + LiteBridgeRuntimeDryDispatchOperation operation, + char* rawValue); + + LiteClientBridgeApi api_; + std::shared_ptr teardownState_; + std::string unavailableReason_; + std::string symbolSource_; + LiteBridgeRuntimeStatus fallbackStatus_ = LiteBridgeRuntimeStatus::Unavailable; + bool fakeDispatchAllowed_ = false; +}; + +const char* liteBridgeRuntimeLinkModeName(LiteBridgeRuntimeLinkMode linkMode); +const char* liteBridgeRuntimeStatusName(LiteBridgeRuntimeStatus status); +const char* liteBridgeRuntimeIssueName(LiteBridgeRuntimeIssue issue); +const char* liteBridgeRuntimeDryDispatchOperationName(LiteBridgeRuntimeDryDispatchOperation operation); + +std::vector liteBridgeRuntimeRequiredSymbolLogicalNames(); +LiteBridgeRuntimeConfig liteBridgeRuntimeConfigFromContractResult( + const LiteBackendArtifactContractResult& result, + bool activationRequested); +LiteBridgeRuntimeSymbolTable liteBridgeRuntimeSymbolTableFromApi( + LiteClientBridgeApi api, + const std::string& source); +LiteBridgeRuntimeSymbolTable liteBridgeRuntimeImportedLinkedSymbolTable(); +LiteBridgeRuntimeFakeDynamicLoaderResult evaluateLiteBridgeRuntimeFakeDynamicLoader( + const LiteBridgeRuntimeFakeDynamicLoaderInput& input); +LiteBridgeRuntimePlatformLoaderReviewResult evaluateLiteBridgeRuntimePlatformLoaderReview( + const LiteBridgeRuntimePlatformLoaderReviewInput& input); +LiteBridgeRuntimeDynamicLoaderSmokeGateResult evaluateLiteBridgeRuntimeDynamicLoaderSmokeGate( + const LiteBridgeRuntimeDynamicLoaderSmokeGateInput& input); +LiteBridgeRuntimeSharedArtifactSmokeEvidenceAcquisitionResult +evaluateLiteBridgeRuntimeSharedArtifactSmokeEvidenceAcquisition( + const LiteBridgeRuntimeSharedArtifactSmokeEvidenceAcquisitionInput& input); +LiteBridgeRuntimePlatformDynamicLoaderAdapterContractResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderAdapterContract( + const LiteBridgeRuntimePlatformDynamicLoaderAdapterContractInput& input); +LiteBridgeRuntimePlatformDynamicLoaderAdapter liteBridgeRuntimeNoOpPlatformDynamicLoaderAdapter( + const std::string& platform); +LiteBridgeRuntimePlatformDynamicLoaderAdapter liteBridgeRuntimeDisabledPlatformDynamicLoaderRealAdapter( + const std::string& platform); +LiteBridgeRuntimePlatformDynamicLoaderNoOpAdapterSeamResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderNoOpAdapterSeam( + const LiteBridgeRuntimePlatformDynamicLoaderNoOpAdapterSeamInput& input); +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterImplementationReviewResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterImplementationReview( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterImplementationReviewInput& input); +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterDisabledScaffoldResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterDisabledScaffold( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterDisabledScaffoldInput& input); +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionPreflightResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionPreflight( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionPreflightInput& input); +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionApprovalGateResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionApprovalGate( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionApprovalGateInput& input); +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledOwnerHandoffResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledOwnerHandoff( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledOwnerHandoffInput& input); +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackBindingResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackBinding( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackBindingInput& input); +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackPreInvocationGuardResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackPreInvocationGuard( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackPreInvocationGuardInput& input); +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResult( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultInput& input); +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultPropagationResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultPropagation( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalResultPropagationInput& input); +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadiness( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessInput& input); +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuard( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardInput& input); +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoff( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffInput& input); +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjection( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionInput& input); +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoff( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffInput& input); +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardInput& input); +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffInput& input); +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionInput& input); +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffInput& input); +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardInput& input); +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffInput& input); +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionInput& input); +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffInput& input); +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardInput& input); +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffInput& input); +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionInput& input); +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffInput& input); +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardInput& input); +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffInput& input); +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionInput& input); +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffInput& input); +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardInput& input); +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffInput& input); +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionInput& input); +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffInput& input); +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardInput& input); +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffInput& input); +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionInput& input); +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffInput& input); +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardInput& input); +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffInput& input); +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionInput& input); +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffInput& input); +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuard( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardInput& input); +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoff( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffInput& input); +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjection( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionInput& input); +LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffResult +evaluateLiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoff( + const LiteBridgeRuntimePlatformDynamicLoaderRealAdapterLoadOnlyExecutionDisabledCallbackRefusalPropagationConsumerReadinessDispatchConsumptionGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffPublicationGuardResultHandoffReadinessProjectionStatusHandoffInput& input); +LiteBridgeStringResult liteBridgeRuntimeTakeOwnedString( + char* rawValue, + LiteClientBridgeApi::FreeStringFn freeString); +LiteBridgeRuntimeBindingResult evaluateLiteBridgeRuntimeBinding( + const LiteBridgeRuntimeBindingInput& input, + LiteBridgeRuntimeBindingOptions options = {}); + +} // namespace dragonx::wallet \ No newline at end of file diff --git a/src/wallet/lite_client_bridge.cpp b/src/wallet/lite_client_bridge.cpp new file mode 100644 index 0000000..869483c --- /dev/null +++ b/src/wallet/lite_client_bridge.cpp @@ -0,0 +1,186 @@ +// DragonX Wallet - ImGui Edition +// Copyright 2024-2026 The Hush Developers +// Released under the GPLv3 + +#include "lite_client_bridge.h" +#include "lite_bridge_runtime.h" + +#ifndef DRAGONX_ENABLE_LITE_BACKEND +#define DRAGONX_ENABLE_LITE_BACKEND 0 +#endif + +#if DRAGONX_ENABLE_LITE_BACKEND +extern "C" { +bool litelib_wallet_exists(const char* chain_name); +char* litelib_initialize_new(bool dangerous, const char* server); +char* litelib_initialize_new_from_phrase(bool dangerous, + const char* server, + const char* seed, + unsigned long long birthday, + unsigned long long number, + bool overwrite); +char* litelib_initialize_existing(bool dangerous, const char* server); +char* litelib_execute(const char* command, const char* args); +void litelib_rust_free_string(char* value); +bool litelib_check_server_online(const char* server); +void litelib_shutdown(); +} +#endif + +#include + +namespace dragonx { +namespace wallet { + +namespace { + +bool hasRequiredApi(const LiteClientBridgeApi& api) +{ + return api.walletExists && + api.initializeNew && + api.initializeNewFromPhrase && + api.initializeExisting && + api.execute && + api.freeString && + api.checkServerOnline && + api.shutdown; +} + +#if DRAGONX_ENABLE_LITE_BACKEND +LiteClientBridgeApi linkedSdxlApi() +{ + return LiteClientBridgeApi{ + &litelib_wallet_exists, + &litelib_initialize_new, + &litelib_initialize_new_from_phrase, + &litelib_initialize_existing, + &litelib_execute, + &litelib_rust_free_string, + &litelib_check_server_online, + &litelib_shutdown + }; +} +#endif + +} // namespace + +LiteClientBridge::LiteClientBridge(LiteClientBridgeApi api, std::string unavailableReason) + : api_(api), unavailableReason_(std::move(unavailableReason)) +{ +} + +LiteClientBridge LiteClientBridge::unavailable(std::string reason) +{ + return LiteClientBridge({}, std::move(reason)); +} + +LiteClientBridge LiteClientBridge::fromApi(LiteClientBridgeApi api) +{ + if (!hasRequiredApi(api)) { + return unavailable("lite client bridge API is incomplete"); + } + return LiteClientBridge(api, {}); +} + +LiteClientBridge LiteClientBridge::linkedSdxl() +{ +#if DRAGONX_ENABLE_LITE_BACKEND + return fromApi(linkedSdxlApi()); +#else + return unavailable("lite backend is not linked"); +#endif +} + +LiteClientBridge::LiteClientBridge(LiteClientBridge&& other) noexcept + : api_(other.api_), + unavailableReason_(std::move(other.unavailableReason_)), + shutdownCalled_(other.shutdownCalled_) +{ + other.api_ = {}; + other.shutdownCalled_ = true; +} + +LiteClientBridge& LiteClientBridge::operator=(LiteClientBridge&& other) noexcept +{ + if (this == &other) return *this; + shutdown(); + api_ = other.api_; + unavailableReason_ = std::move(other.unavailableReason_); + shutdownCalled_ = other.shutdownCalled_; + other.api_ = {}; + other.shutdownCalled_ = true; + return *this; +} + +LiteClientBridge::~LiteClientBridge() +{ + shutdown(); +} + +bool LiteClientBridge::available() const +{ + return hasRequiredApi(api_); +} + +bool LiteClientBridge::walletExists(const std::string& chainName) const +{ + if (!available()) return false; + return api_.walletExists(chainName.c_str()); +} + +bool LiteClientBridge::checkServerOnline(const std::string& server) const +{ + if (!available()) return false; + return api_.checkServerOnline(server.c_str()); +} + +LiteBridgeStringResult LiteClientBridge::initializeNew(bool dangerous, const std::string& server) +{ + if (!available()) return unavailableResult(); + return takeOwnedString(api_.initializeNew(dangerous, server.c_str())); +} + +LiteBridgeStringResult LiteClientBridge::initializeNewFromPhrase(bool dangerous, + const std::string& server, + const std::string& seed, + unsigned long long birthday, + unsigned long long account, + bool overwrite) +{ + if (!available()) return unavailableResult(); + return takeOwnedString(api_.initializeNewFromPhrase( + dangerous, server.c_str(), seed.c_str(), birthday, account, overwrite)); +} + +LiteBridgeStringResult LiteClientBridge::initializeExisting(bool dangerous, const std::string& server) +{ + if (!available()) return unavailableResult(); + return takeOwnedString(api_.initializeExisting(dangerous, server.c_str())); +} + +LiteBridgeStringResult LiteClientBridge::execute(const std::string& command, const std::string& args) +{ + if (!available()) return unavailableResult(); + if (command.empty()) return {false, {}, "lite command is empty"}; + return takeOwnedString(api_.execute(command.c_str(), args.c_str())); +} + +void LiteClientBridge::shutdown() +{ + if (shutdownCalled_) return; + shutdownCalled_ = true; + if (available()) api_.shutdown(); +} + +LiteBridgeStringResult LiteClientBridge::unavailableResult() const +{ + return {false, {}, unavailableReason_.empty() ? "lite backend is unavailable" : unavailableReason_}; +} + +LiteBridgeStringResult LiteClientBridge::takeOwnedString(char* rawValue) const +{ + return liteBridgeRuntimeTakeOwnedString(rawValue, api_.freeString); +} + +} // namespace wallet +} // namespace dragonx \ No newline at end of file diff --git a/src/wallet/lite_client_bridge.h b/src/wallet/lite_client_bridge.h new file mode 100644 index 0000000..d7cf292 --- /dev/null +++ b/src/wallet/lite_client_bridge.h @@ -0,0 +1,84 @@ +// DragonX Wallet - ImGui Edition +// Copyright 2024-2026 The Hush Developers +// Released under the GPLv3 + +#pragma once + +#include + +namespace dragonx { +namespace wallet { + +struct LiteBridgeStringResult { + bool ok = false; + std::string value; + std::string error; +}; + +struct LiteClientBridgeApi { + using WalletExistsFn = bool (*)(const char* chainName); + using InitializeNewFn = char* (*)(bool dangerous, const char* server); + using InitializeNewFromPhraseFn = char* (*)(bool dangerous, + const char* server, + const char* seed, + unsigned long long birthday, + unsigned long long account, + bool overwrite); + using InitializeExistingFn = char* (*)(bool dangerous, const char* server); + using ExecuteFn = char* (*)(const char* command, const char* args); + using FreeStringFn = void (*)(char* value); + using CheckServerOnlineFn = bool (*)(const char* server); + using ShutdownFn = void (*)(); + + WalletExistsFn walletExists = nullptr; + InitializeNewFn initializeNew = nullptr; + InitializeNewFromPhraseFn initializeNewFromPhrase = nullptr; + InitializeExistingFn initializeExisting = nullptr; + ExecuteFn execute = nullptr; + FreeStringFn freeString = nullptr; + CheckServerOnlineFn checkServerOnline = nullptr; + ShutdownFn shutdown = nullptr; +}; + +class LiteClientBridge { +public: + static LiteClientBridge unavailable(std::string reason); + static LiteClientBridge fromApi(LiteClientBridgeApi api); + static LiteClientBridge linkedSdxl(); + + LiteClientBridge(const LiteClientBridge&) = delete; + LiteClientBridge& operator=(const LiteClientBridge&) = delete; + LiteClientBridge(LiteClientBridge&& other) noexcept; + LiteClientBridge& operator=(LiteClientBridge&& other) noexcept; + ~LiteClientBridge(); + + bool available() const; + const std::string& unavailableReason() const { return unavailableReason_; } + + bool walletExists(const std::string& chainName) const; + bool checkServerOnline(const std::string& server) const; + + LiteBridgeStringResult initializeNew(bool dangerous, const std::string& server); + LiteBridgeStringResult initializeNewFromPhrase(bool dangerous, + const std::string& server, + const std::string& seed, + unsigned long long birthday, + unsigned long long account, + bool overwrite); + LiteBridgeStringResult initializeExisting(bool dangerous, const std::string& server); + LiteBridgeStringResult execute(const std::string& command, const std::string& args); + void shutdown(); + +private: + LiteClientBridge(LiteClientBridgeApi api, std::string unavailableReason); + + LiteBridgeStringResult unavailableResult() const; + LiteBridgeStringResult takeOwnedString(char* rawValue) const; + + LiteClientBridgeApi api_; + std::string unavailableReason_; + bool shutdownCalled_ = false; +}; + +} // namespace wallet +} // namespace dragonx \ No newline at end of file diff --git a/src/wallet/lite_connection_service.cpp b/src/wallet/lite_connection_service.cpp new file mode 100644 index 0000000..1389442 --- /dev/null +++ b/src/wallet/lite_connection_service.cpp @@ -0,0 +1,309 @@ +// DragonX Wallet - ImGui Edition +// Copyright 2024-2026 The Hush Developers +// Released under the GPLv3 + +#include "lite_connection_service.h" + +#include +#include +#include + +namespace dragonx { +namespace wallet { + +namespace { + +std::string trimCopy(const std::string& value) +{ + auto begin = value.begin(); + while (begin != value.end() && std::isspace(static_cast(*begin))) ++begin; + + auto end = value.end(); + while (end != begin && std::isspace(static_cast(*(end - 1)))) --end; + + return std::string(begin, end); +} + +bool startsWith(const std::string& value, const char* prefix) +{ + const std::string prefixValue(prefix); + return value.size() >= prefixValue.size() && + value.compare(0, prefixValue.size(), prefixValue) == 0; +} + +LiteServerEndpoint trimmedEndpoint(const LiteServerEndpoint& endpoint) +{ + LiteServerEndpoint normalized = endpoint; + normalized.url = trimCopy(normalized.url); + return normalized; +} + +std::vector> usableConfiguredServers( + const LiteConnectionSettings& settings) +{ + std::vector> servers; + for (std::size_t index = 0; index < settings.servers.size(); ++index) { + auto endpoint = trimmedEndpoint(settings.servers[index]); + if (!endpoint.enabled || !isLiteServerUrlUsable(endpoint.url)) continue; + servers.push_back({index, std::move(endpoint)}); + } + return servers; +} + +std::string normalizedChainName(const std::string& chainName) +{ + const std::string normalized = trimCopy(chainName); + return normalized.empty() ? kDragonXLiteChainName : normalized; +} + +} // namespace + +std::vector defaultDragonXLiteServers() +{ + return { + {"https://lite.dragonx.is", "DragonX Lite", true}, + {"https://lite1.dragonx.is", "DragonX Lite 1", true}, + {"https://lite2.dragonx.is", "DragonX Lite 2", true}, + {"https://lite3.dragonx.is", "DragonX Lite 3", true}, + {"https://lite4.dragonx.is", "DragonX Lite 4", true}, + {"https://lite5.dragonx.is", "DragonX Lite 5", true} + }; +} + +LiteConnectionSettings defaultLiteConnectionSettings() +{ + LiteConnectionSettings settings; + settings.servers = defaultDragonXLiteServers(); + settings.selectionMode = LiteServerSelectionMode::Sticky; + settings.stickyServerUrl = kDefaultDragonXLiteServer; + settings.chainName = kDragonXLiteChainName; + settings.randomSelectionSeed = 0; + return settings; +} + +bool isLiteServerUrlUsable(const std::string& serverUrl) +{ + const std::string normalized = trimCopy(serverUrl); + return startsWith(normalized, "https://") || startsWith(normalized, "http://"); +} + +const char* liteServerSelectionModeName(LiteServerSelectionMode mode) +{ + switch (mode) { + case LiteServerSelectionMode::Sticky: + return "Sticky"; + case LiteServerSelectionMode::Random: + return "Random"; + } + return "Unknown"; +} + +const char* liteConnectionAvailabilityName(LiteConnectionAvailability availability) +{ + switch (availability) { + case LiteConnectionAvailability::Ready: + return "Ready"; + case LiteConnectionAvailability::UnsupportedBuild: + return "UnsupportedBuild"; + case LiteConnectionAvailability::BackendUnavailable: + return "BackendUnavailable"; + case LiteConnectionAvailability::BridgeUnavailable: + return "BridgeUnavailable"; + case LiteConnectionAvailability::NoUsableServer: + return "NoUsableServer"; + } + return "Unknown"; +} + +LiteServerSelectionResult selectLiteServer(const LiteConnectionSettings& settings) +{ + auto usableServers = usableConfiguredServers(settings); + const std::string stickyServerUrl = trimCopy(settings.stickyServerUrl); + + if (settings.selectionMode == LiteServerSelectionMode::Sticky && + isLiteServerUrlUsable(stickyServerUrl)) { + auto match = std::find_if(usableServers.begin(), usableServers.end(), [&](const auto& candidate) { + return candidate.second.url == stickyServerUrl; + }); + if (match != usableServers.end()) { + return LiteServerSelectionResult{true, match->second, match->first, false, {}}; + } + return LiteServerSelectionResult{ + true, + LiteServerEndpoint{stickyServerUrl, "Custom", true}, + 0, + true, + {} + }; + } + + if (usableServers.empty()) { + return LiteServerSelectionResult{false, {}, 0, false, "no usable lite servers are configured"}; + } + + if (settings.selectionMode == LiteServerSelectionMode::Random) { + const std::size_t selectedIndex = settings.randomSelectionSeed % usableServers.size(); + return LiteServerSelectionResult{ + true, + usableServers[selectedIndex].second, + usableServers[selectedIndex].first, + false, + {} + }; + } + + return LiteServerSelectionResult{true, usableServers.front().second, usableServers.front().first, false, {}}; +} + +LiteConnectionService::LiteConnectionService(WalletCapabilities capabilities, + LiteConnectionSettings settings, + LiteClientBridge bridge) + : capabilities_(capabilities), settings_(std::move(settings)), bridge_(std::move(bridge)) +{ +} + +LiteConnectionAvailability LiteConnectionService::availability() const +{ + if (!isLiteBuild(capabilities_)) return LiteConnectionAvailability::UnsupportedBuild; + if (!supportsLiteBackend(capabilities_)) return LiteConnectionAvailability::BackendUnavailable; + if (!bridge_.available()) return LiteConnectionAvailability::BridgeUnavailable; + if (!selectedServer().ok) return LiteConnectionAvailability::NoUsableServer; + return LiteConnectionAvailability::Ready; +} + +WalletBackendStatus LiteConnectionService::status() const +{ + const auto currentAvailability = availability(); + if (currentAvailability == LiteConnectionAvailability::NoUsableServer) { + return statusFor(currentAvailability, selectedServer().error); + } + return statusFor(currentAvailability); +} + +LiteServerSelectionResult LiteConnectionService::selectedServer() const +{ + return selectLiteServer(settings_); +} + +LiteWalletExistsRequest LiteConnectionService::walletExistsRequest() const +{ + return LiteWalletExistsRequest{normalizedChainName(settings_.chainName)}; +} + +LiteServerHealthRequest LiteConnectionService::serverHealthRequest() const +{ + auto selection = selectedServer(); + if (!selection.ok) return {}; + return LiteServerHealthRequest{selection.server, selection.serverIndex, selection.customServer}; +} + +LiteWalletExistsCheckResult LiteConnectionService::checkWalletExists() +{ + LiteWalletExistsCheckResult result; + result.request = walletExistsRequest(); + + const auto readiness = bridgeReadinessStatus(); + if (readiness.state != WalletBackendState::Disconnected) { + result.status = readiness; + result.error = readiness.message; + return result; + } + if (result.request.chainName.empty()) { + result.status = statusFor(LiteConnectionAvailability::BackendUnavailable, "lite chain name is empty"); + result.error = result.status.message; + return result; + } + + result.attempted = true; + result.walletExists = bridge_.walletExists(result.request.chainName); + result.ok = true; + result.status = readiness; + return result; +} + +LiteServerHealthCheckResult LiteConnectionService::checkSelectedServerHealth() +{ + LiteServerHealthCheckResult result; + result.request = serverHealthRequest(); + + const auto readiness = bridgeReadinessStatus(); + if (readiness.state != WalletBackendState::Disconnected) { + result.status = readiness; + result.error = readiness.message; + return result; + } + + auto selection = selectedServer(); + if (!selection.ok) { + result.status = statusFor(LiteConnectionAvailability::NoUsableServer, selection.error); + result.error = result.status.message; + return result; + } + + result.request = LiteServerHealthRequest{selection.server, selection.serverIndex, selection.customServer}; + result.attempted = true; + result.serverOnline = bridge_.checkServerOnline(result.request.server.url); + result.ok = true; + result.status = readiness; + return result; +} + +WalletBackendStatus LiteConnectionService::statusFor(LiteConnectionAvailability availability, + const std::string& detail) const +{ + switch (availability) { + case LiteConnectionAvailability::Ready: + return WalletBackendStatus{ + WalletBackendState::Disconnected, + detail.empty() ? "lite connection scaffold ready; wallet lifecycle is not implemented" : detail, + {}, + {}, + 0.0 + }; + case LiteConnectionAvailability::UnsupportedBuild: + return WalletBackendStatus{ + WalletBackendState::Unavailable, + "lite connection service is unsupported in full-node builds", + {}, + {}, + 0.0 + }; + case LiteConnectionAvailability::BackendUnavailable: + return WalletBackendStatus{ + WalletBackendState::Unavailable, + detail.empty() ? "lite backend is not linked" : detail, + {}, + {}, + 0.0 + }; + case LiteConnectionAvailability::BridgeUnavailable: + return WalletBackendStatus{ + WalletBackendState::Unavailable, + detail.empty() ? bridge_.unavailableReason() : detail, + {}, + {}, + 0.0 + }; + case LiteConnectionAvailability::NoUsableServer: + return WalletBackendStatus{ + WalletBackendState::Error, + detail.empty() ? "no usable lite servers are configured" : detail, + {}, + {}, + 0.0 + }; + } + + return WalletBackendStatus{WalletBackendState::Unavailable, "unknown lite connection state", {}, {}, 0.0}; +} + +WalletBackendStatus LiteConnectionService::bridgeReadinessStatus() const +{ + if (!isLiteBuild(capabilities_)) return statusFor(LiteConnectionAvailability::UnsupportedBuild); + if (!supportsLiteBackend(capabilities_)) return statusFor(LiteConnectionAvailability::BackendUnavailable); + if (!bridge_.available()) return statusFor(LiteConnectionAvailability::BridgeUnavailable); + return statusFor(LiteConnectionAvailability::Ready); +} + +} // namespace wallet +} // namespace dragonx \ No newline at end of file diff --git a/src/wallet/lite_connection_service.h b/src/wallet/lite_connection_service.h new file mode 100644 index 0000000..ead24e8 --- /dev/null +++ b/src/wallet/lite_connection_service.h @@ -0,0 +1,123 @@ +// DragonX Wallet - ImGui Edition +// Copyright 2024-2026 The Hush Developers +// Released under the GPLv3 + +#pragma once + +#include "lite_client_bridge.h" +#include "wallet_backend.h" +#include "wallet_capabilities.h" + +#include +#include +#include + +namespace dragonx { +namespace wallet { + +// The SDXL litelib backend identifies the production chain as "main" (its mainnet +// module carries DragonX's coin params). It hard-panics on any other chain name, so +// this MUST be one of {"main","test","regtest"} — not the coin ticker. +constexpr const char* kDragonXLiteChainName = "main"; +constexpr const char* kDefaultDragonXLiteServer = "https://lite.dragonx.is"; + +enum class LiteServerSelectionMode { + Sticky, + Random +}; + +enum class LiteConnectionAvailability { + Ready, + UnsupportedBuild, + BackendUnavailable, + BridgeUnavailable, + NoUsableServer +}; + +struct LiteServerEndpoint { + std::string url; + std::string label; + bool enabled = true; +}; + +struct LiteConnectionSettings { + std::vector servers; + LiteServerSelectionMode selectionMode = LiteServerSelectionMode::Sticky; + std::string stickyServerUrl = kDefaultDragonXLiteServer; + std::string chainName = kDragonXLiteChainName; + std::size_t randomSelectionSeed = 0; +}; + +struct LiteServerSelectionResult { + bool ok = false; + LiteServerEndpoint server; + std::size_t serverIndex = 0; + bool customServer = false; + std::string error; +}; + +struct LiteWalletExistsRequest { + std::string chainName = kDragonXLiteChainName; +}; + +struct LiteServerHealthRequest { + LiteServerEndpoint server; + std::size_t serverIndex = 0; + bool customServer = false; +}; + +struct LiteWalletExistsCheckResult { + bool ok = false; + bool attempted = false; + bool walletExists = false; + LiteWalletExistsRequest request; + WalletBackendStatus status; + std::string error; +}; + +struct LiteServerHealthCheckResult { + bool ok = false; + bool attempted = false; + bool serverOnline = false; + LiteServerHealthRequest request; + WalletBackendStatus status; + std::string error; +}; + +std::vector defaultDragonXLiteServers(); +LiteConnectionSettings defaultLiteConnectionSettings(); +bool isLiteServerUrlUsable(const std::string& serverUrl); +const char* liteServerSelectionModeName(LiteServerSelectionMode mode); +const char* liteConnectionAvailabilityName(LiteConnectionAvailability availability); +LiteServerSelectionResult selectLiteServer(const LiteConnectionSettings& settings); + +class LiteConnectionService { +public: + LiteConnectionService(WalletCapabilities capabilities, + LiteConnectionSettings settings, + LiteClientBridge bridge); + + const LiteConnectionSettings& settings() const { return settings_; } + const WalletCapabilities& capabilities() const { return capabilities_; } + + LiteConnectionAvailability availability() const; + WalletBackendStatus status() const; + LiteServerSelectionResult selectedServer() const; + LiteWalletExistsRequest walletExistsRequest() const; + LiteServerHealthRequest serverHealthRequest() const; + + LiteWalletExistsCheckResult checkWalletExists(); + LiteServerHealthCheckResult checkSelectedServerHealth(); + +private: + WalletBackendStatus statusFor(LiteConnectionAvailability availability, + const std::string& detail = {}) const; + WalletBackendStatus bridgeReadinessStatus() const; + + WalletCapabilities capabilities_; + LiteConnectionSettings settings_; + LiteClientBridge bridge_; +}; + +} // namespace wallet +} // namespace dragonx \ No newline at end of file diff --git a/src/wallet/lite_result_parsers.cpp b/src/wallet/lite_result_parsers.cpp new file mode 100644 index 0000000..6959dea --- /dev/null +++ b/src/wallet/lite_result_parsers.cpp @@ -0,0 +1,570 @@ +#include "wallet/lite_result_parsers.h" + +#include +#include +#include + +namespace dragonx::wallet { +namespace { + +using json = nlohmann::json; + +std::string fieldPath(const std::string& key) +{ + return "$.'" + key + "'"; +} + +std::string indexPath(const std::string& parentPath, std::size_t index) +{ + return parentPath + "[" + std::to_string(index) + "]"; +} + +template +Result makeResult(LiteResultCommand command) +{ + Result result; + result.command = command; + return result; +} + +template +bool fail(Result& result, + LiteResultParserError error, + const std::string& path, + const std::string& message) +{ + result.ok = false; + result.error = error; + result.errorPath = path; + result.errorMessage = message; + result.issues.push_back({path, message}); + return false; +} + +template +void succeed(Result& result) +{ + result.ok = true; + result.error = LiteResultParserError::None; + result.errorPath.clear(); + result.errorMessage.clear(); +} + +template +bool parseJsonText(const std::string& jsonText, Result& result, json& parsed) +{ + parsed = json::parse(jsonText, nullptr, false); + if (parsed.is_discarded()) { + return fail(result, LiteResultParserError::InvalidJson, "$", "response is not valid JSON"); + } + return true; +} + +template +bool requireObject(const json& value, const std::string& path, Result& result) +{ + if (!value.is_object()) { + return fail(result, LiteResultParserError::ExpectedObject, path, "expected a JSON object"); + } + return true; +} + +template +bool requireArray(const json& value, const std::string& path, Result& result) +{ + if (!value.is_array()) { + return fail(result, LiteResultParserError::ExpectedArray, path, "expected a JSON array"); + } + return true; +} + +bool jsonToUnsigned(const json& value, std::uint64_t& output) +{ + try { + if (value.is_number_unsigned()) { + output = value.get(); + return true; + } + if (value.is_number_integer()) { + const auto signedValue = value.get(); + if (signedValue < 0) return false; + output = static_cast(signedValue); + return true; + } + if (value.is_string()) { + const auto text = value.get(); + if (text.empty()) return false; + std::size_t parsedSize = 0; + const auto parsed = std::stoull(text, &parsedSize, 10); + if (parsedSize != text.size()) return false; + output = static_cast(parsed); + return true; + } + } catch (const std::exception&) { + return false; + } + return false; +} + +bool jsonToSigned(const json& value, std::int64_t& output) +{ + try { + if (value.is_number_integer()) { + output = value.get(); + return true; + } + if (value.is_number_unsigned()) { + const auto unsignedValue = value.get(); + if (unsignedValue > static_cast(std::numeric_limits::max())) { + return false; + } + output = static_cast(unsignedValue); + return true; + } + if (value.is_string()) { + const auto text = value.get(); + if (text.empty()) return false; + std::size_t parsedSize = 0; + const auto parsed = std::stoll(text, &parsedSize, 10); + if (parsedSize != text.size()) return false; + output = static_cast(parsed); + return true; + } + } catch (const std::exception&) { + return false; + } + return false; +} + +template +bool readRequiredStringField(const json& object, + const std::string& key, + std::string& output, + Result& result) +{ + if (!object.contains(key) || object.at(key).is_null()) { + return fail(result, LiteResultParserError::MissingField, fieldPath(key), "missing required string field"); + } + if (!object.at(key).is_string()) { + return fail(result, LiteResultParserError::InvalidFieldType, fieldPath(key), "expected a string"); + } + output = object.at(key).get(); + return true; +} + +template +bool readOptionalStringField(const json& object, + const std::string& key, + std::optional& output, + Result& result) +{ + if (!object.contains(key) || object.at(key).is_null()) return true; + if (!object.at(key).is_string()) { + return fail(result, LiteResultParserError::InvalidFieldType, fieldPath(key), "expected a string"); + } + output = object.at(key).get(); + return true; +} + +template +bool readOptionalStringField(const json& object, + const std::string& key, + std::string& output, + Result& result) +{ + if (!object.contains(key) || object.at(key).is_null()) return true; + if (!object.at(key).is_string()) { + return fail(result, LiteResultParserError::InvalidFieldType, fieldPath(key), "expected a string"); + } + output = object.at(key).get(); + return true; +} + +template +bool readRequiredSignedField(const json& object, + const std::string& key, + std::int64_t& output, + Result& result) +{ + if (!object.contains(key) || object.at(key).is_null()) { + return fail(result, LiteResultParserError::MissingField, fieldPath(key), "missing required integer field"); + } + if (!jsonToSigned(object.at(key), output)) { + return fail(result, LiteResultParserError::InvalidFieldValue, fieldPath(key), "expected a signed integer-compatible value"); + } + return true; +} + +template +bool readRequiredUnsignedField(const json& object, + const std::string& key, + std::uint64_t& output, + Result& result) +{ + if (!object.contains(key) || object.at(key).is_null()) { + return fail(result, LiteResultParserError::MissingField, fieldPath(key), "missing required unsigned integer field"); + } + if (!jsonToUnsigned(object.at(key), output)) { + return fail(result, LiteResultParserError::InvalidFieldValue, fieldPath(key), "expected an unsigned integer-compatible value"); + } + return true; +} + +template +bool readOptionalSignedField(const json& object, + const std::string& key, + std::optional& output, + Result& result) +{ + if (!object.contains(key) || object.at(key).is_null()) return true; + std::int64_t parsed = 0; + if (!jsonToSigned(object.at(key), parsed)) { + return fail(result, LiteResultParserError::InvalidFieldValue, fieldPath(key), "expected a signed integer-compatible value"); + } + output = parsed; + return true; +} + +template +bool readOptionalBoolField(const json& object, + const std::string& key, + bool& output, + Result& result) +{ + if (!object.contains(key) || object.at(key).is_null()) return true; + if (!object.at(key).is_boolean()) { + return fail(result, LiteResultParserError::InvalidFieldType, fieldPath(key), "expected a boolean"); + } + output = object.at(key).get(); + return true; +} + +template +bool readStringArrayField(const json& object, + const std::string& key, + std::vector& output, + Result& result) +{ + if (!object.contains(key) || object.at(key).is_null()) { + return fail(result, LiteResultParserError::MissingField, fieldPath(key), "missing required array field"); + } + const auto& values = object.at(key); + if (!requireArray(values, fieldPath(key), result)) return false; + + output.clear(); + for (std::size_t index = 0; index < values.size(); ++index) { + if (!values[index].is_string()) { + return fail(result, LiteResultParserError::InvalidFieldType, indexPath(fieldPath(key), index), "expected a string array item"); + } + output.push_back(values[index].get()); + } + return true; +} + +template +bool parseSpendableOutput(const json& value, + LiteSpendableOutputKind kind, + const std::string& path, + LiteSpendableOutput& output, + Result& result) +{ + if (!requireObject(value, path, result)) return false; + + output.kind = kind; + output.pending = kind == LiteSpendableOutputKind::PendingNote || kind == LiteSpendableOutputKind::PendingUtxo; + if (!readRequiredStringField(value, "address", output.address, result)) return false; + if (!readRequiredStringField(value, "created_in_txid", output.createdInTxid, result)) return false; + if (!readOptionalSignedField(value, "created_in_block", output.createdInBlock, result)) return false; + if (!readRequiredUnsignedField(value, "value", output.value, result)) return false; + if (!readOptionalBoolField(value, "spent", output.spent, result)) return false; + if (!readOptionalBoolField(value, "unconfirmed_spent", output.unconfirmedSpent, result)) return false; + output.spendable = !output.pending && !output.spent && !output.unconfirmedSpent; + return true; +} + +template +bool parseSpendableOutputArray(const json& object, + const std::string& key, + LiteSpendableOutputKind kind, + std::vector& output, + Result& result) +{ + if (!object.contains(key) || object.at(key).is_null()) { + return fail(result, LiteResultParserError::MissingField, fieldPath(key), "missing required spendable output array"); + } + const auto& values = object.at(key); + if (!requireArray(values, fieldPath(key), result)) return false; + + output.clear(); + for (std::size_t index = 0; index < values.size(); ++index) { + LiteSpendableOutput parsed; + if (!parseSpendableOutput(values[index], kind, indexPath(fieldPath(key), index), parsed, result)) return false; + output.push_back(std::move(parsed)); + } + return true; +} + +template +bool parseTransactionOutput(const json& value, + const std::string& path, + LiteTransactionOutput& output, + Result& result) +{ + if (!requireObject(value, path, result)) return false; + if (!readRequiredStringField(value, "address", output.address, result)) return false; + if (!readRequiredSignedField(value, "value", output.value, result)) return false; + if (!readOptionalStringField(value, "memo", output.memo, result)) return false; + return true; +} + +template +bool parseTransactionRecord(const json& value, + const std::string& path, + LiteTransactionRecord& output, + Result& result) +{ + if (!requireObject(value, path, result)) return false; + if (!readRequiredStringField(value, "txid", output.txid, result)) return false; + if (!readRequiredSignedField(value, "datetime", output.datetime, result)) return false; + if (!readOptionalSignedField(value, "block_height", output.blockHeight, result)) return false; + if (!readOptionalBoolField(value, "unconfirmed", output.unconfirmed, result)) return false; + + if (value.contains("outgoing_metadata") && !value.at("outgoing_metadata").is_null()) { + const auto& metadata = value.at("outgoing_metadata"); + if (!requireArray(metadata, path + ".outgoing_metadata", result)) return false; + output.direction = LiteTransactionDirection::Send; + for (std::size_t index = 0; index < metadata.size(); ++index) { + LiteTransactionOutput parsedOutput; + if (!parseTransactionOutput(metadata[index], path + ".outgoing_metadata[" + std::to_string(index) + "]", parsedOutput, result)) return false; + output.amount += parsedOutput.value; + output.outgoingMetadata.push_back(std::move(parsedOutput)); + } + return true; + } + + output.direction = LiteTransactionDirection::Receive; + if (!readRequiredStringField(value, "address", output.address, result)) return false; + if (!readRequiredSignedField(value, "amount", output.amount, result)) return false; + if (!readOptionalStringField(value, "memo", output.memo, result)) return false; + if (!readOptionalSignedField(value, "position", output.position, result)) return false; + return true; +} + +} // namespace + +const char* liteResultCommandName(LiteResultCommand command) +{ + switch (command) { + case LiteResultCommand::Info: return "info"; + case LiteResultCommand::Height: return "height"; + case LiteResultCommand::Balance: return "balance"; + case LiteResultCommand::Addresses: return "addresses"; + case LiteResultCommand::List: return "list"; + case LiteResultCommand::Notes: return "notes"; + case LiteResultCommand::SyncStatus: return "syncstatus"; + } + return "unknown"; +} + +const char* liteResultParserErrorName(LiteResultParserError error) +{ + switch (error) { + case LiteResultParserError::None: return "none"; + case LiteResultParserError::InvalidJson: return "invalid_json"; + case LiteResultParserError::ExpectedObject: return "expected_object"; + case LiteResultParserError::ExpectedArray: return "expected_array"; + case LiteResultParserError::MissingField: return "missing_field"; + case LiteResultParserError::InvalidFieldType: return "invalid_field_type"; + case LiteResultParserError::InvalidFieldValue: return "invalid_field_value"; + } + return "unknown"; +} + +const char* liteSpendableOutputKindName(LiteSpendableOutputKind kind) +{ + switch (kind) { + case LiteSpendableOutputKind::UnspentNote: return "unspent_note"; + case LiteSpendableOutputKind::Utxo: return "utxo"; + case LiteSpendableOutputKind::PendingNote: return "pending_note"; + case LiteSpendableOutputKind::PendingUtxo: return "pending_utxo"; + } + return "unknown"; +} + +const char* liteTransactionDirectionName(LiteTransactionDirection direction) +{ + switch (direction) { + case LiteTransactionDirection::Unknown: return "unknown"; + case LiteTransactionDirection::Send: return "send"; + case LiteTransactionDirection::Receive: return "receive"; + } + return "unknown"; +} + +LiteInfoParseResult parseLiteInfoResponse(const std::string& jsonText) +{ + auto result = makeResult(LiteResultCommand::Info); + json parsed; + if (!parseJsonText(jsonText, result, parsed)) return result; + return parseLiteInfoResponse(parsed); +} + +LiteInfoParseResult parseLiteInfoResponse(const json& value) +{ + auto result = makeResult(LiteResultCommand::Info); + if (!requireObject(value, "$", result)) return result; + + if (!readOptionalStringField(value, "chain_name", result.info.chainName, result)) return result; + if (!readOptionalStringField(value, "version", result.info.version, result)) return result; + if (!readOptionalStringField(value, "vendor", result.info.vendor, result)) return result; + if (!readOptionalSignedField(value, "latest_block_height", result.info.latestBlockHeight, result)) return result; + if (!readOptionalSignedField(value, "difficulty", result.info.difficulty, result)) return result; + if (!readOptionalSignedField(value, "longestchain", result.info.longestChain, result)) return result; + if (!readOptionalSignedField(value, "notarized", result.info.notarized, result)) return result; + if (!result.info.latestBlockHeight.has_value()) { + fail(result, LiteResultParserError::MissingField, fieldPath("latest_block_height"), "info response is missing latest_block_height"); + return result; + } + + succeed(result); + return result; +} + +LiteHeightParseResult parseLiteHeightResponse(const std::string& jsonText) +{ + auto result = makeResult(LiteResultCommand::Height); + json parsed; + if (!parseJsonText(jsonText, result, parsed)) return result; + return parseLiteHeightResponse(parsed); +} + +LiteHeightParseResult parseLiteHeightResponse(const json& value) +{ + auto result = makeResult(LiteResultCommand::Height); + std::int64_t parsedHeight = 0; + if (jsonToSigned(value, parsedHeight)) { + result.height.height = parsedHeight; + succeed(result); + return result; + } + + if (!requireObject(value, "$", result)) return result; + for (const std::string key : {"height", "latest_block_height", "block_height"}) { + if (!value.contains(key) || value.at(key).is_null()) continue; + if (!jsonToSigned(value.at(key), parsedHeight)) { + fail(result, LiteResultParserError::InvalidFieldValue, fieldPath(key), "height field is not an integer-compatible value"); + return result; + } + result.height.height = parsedHeight; + succeed(result); + return result; + } + + fail(result, LiteResultParserError::MissingField, "$", "height response has no recognized height field"); + return result; +} + +LiteBalanceParseResult parseLiteBalanceResponse(const std::string& jsonText) +{ + auto result = makeResult(LiteResultCommand::Balance); + json parsed; + if (!parseJsonText(jsonText, result, parsed)) return result; + return parseLiteBalanceResponse(parsed); +} + +LiteBalanceParseResult parseLiteBalanceResponse(const json& value) +{ + auto result = makeResult(LiteResultCommand::Balance); + if (!requireObject(value, "$", result)) return result; + if (!readRequiredUnsignedField(value, "tbalance", result.balance.transparentBalance, result)) return result; + if (!readRequiredUnsignedField(value, "zbalance", result.balance.shieldedBalance, result)) return result; + if (!readRequiredUnsignedField(value, "unconfirmed", result.balance.unconfirmedBalance, result)) return result; + if (!readRequiredUnsignedField(value, "verified_zbalance", result.balance.verifiedShieldedBalance, result)) return result; + if (!readRequiredUnsignedField(value, "spendable_zbalance", result.balance.spendableShieldedBalance, result)) return result; + succeed(result); + return result; +} + +LiteAddressesParseResult parseLiteAddressesResponse(const std::string& jsonText) +{ + auto result = makeResult(LiteResultCommand::Addresses); + json parsed; + if (!parseJsonText(jsonText, result, parsed)) return result; + return parseLiteAddressesResponse(parsed); +} + +LiteAddressesParseResult parseLiteAddressesResponse(const json& value) +{ + auto result = makeResult(LiteResultCommand::Addresses); + if (!requireObject(value, "$", result)) return result; + if (!readStringArrayField(value, "z_addresses", result.addresses.zAddresses, result)) return result; + if (!readStringArrayField(value, "t_addresses", result.addresses.tAddresses, result)) return result; + succeed(result); + return result; +} + +LiteNotesParseResult parseLiteNotesResponse(const std::string& jsonText) +{ + auto result = makeResult(LiteResultCommand::Notes); + json parsed; + if (!parseJsonText(jsonText, result, parsed)) return result; + return parseLiteNotesResponse(parsed); +} + +LiteNotesParseResult parseLiteNotesResponse(const json& value) +{ + auto result = makeResult(LiteResultCommand::Notes); + if (!requireObject(value, "$", result)) return result; + if (!parseSpendableOutputArray(value, "unspent_notes", LiteSpendableOutputKind::UnspentNote, result.notes.unspentNotes, result)) return result; + if (!parseSpendableOutputArray(value, "utxos", LiteSpendableOutputKind::Utxo, result.notes.utxos, result)) return result; + if (!parseSpendableOutputArray(value, "pending_notes", LiteSpendableOutputKind::PendingNote, result.notes.pendingNotes, result)) return result; + if (!parseSpendableOutputArray(value, "pending_utxos", LiteSpendableOutputKind::PendingUtxo, result.notes.pendingUtxos, result)) return result; + succeed(result); + return result; +} + +LiteTransactionsParseResult parseLiteTransactionsResponse(const std::string& jsonText) +{ + auto result = makeResult(LiteResultCommand::List); + json parsed; + if (!parseJsonText(jsonText, result, parsed)) return result; + return parseLiteTransactionsResponse(parsed); +} + +LiteTransactionsParseResult parseLiteTransactionsResponse(const json& value) +{ + auto result = makeResult(LiteResultCommand::List); + if (!requireArray(value, "$", result)) return result; + result.transactions.transactions.clear(); + for (std::size_t index = 0; index < value.size(); ++index) { + LiteTransactionRecord record; + if (!parseTransactionRecord(value[index], "$[" + std::to_string(index) + "]", record, result)) return result; + result.transactions.transactions.push_back(std::move(record)); + } + succeed(result); + return result; +} + +LiteSyncStatusParseResult parseLiteSyncStatusResponse(const std::string& jsonText) +{ + auto result = makeResult(LiteResultCommand::SyncStatus); + json parsed; + if (!parseJsonText(jsonText, result, parsed)) return result; + return parseLiteSyncStatusResponse(parsed); +} + +LiteSyncStatusParseResult parseLiteSyncStatusResponse(const json& value) +{ + auto result = makeResult(LiteResultCommand::SyncStatus); + if (!requireObject(value, "$", result)) return result; + if (!readRequiredUnsignedField(value, "synced_blocks", result.syncStatus.syncedBlocks, result)) return result; + if (!readRequiredUnsignedField(value, "total_blocks", result.syncStatus.totalBlocks, result)) return result; + if (result.syncStatus.totalBlocks > 0) { + result.syncStatus.progress = std::min(1.0, static_cast(result.syncStatus.syncedBlocks) / static_cast(result.syncStatus.totalBlocks)); + result.syncStatus.complete = result.syncStatus.syncedBlocks >= result.syncStatus.totalBlocks; + } + succeed(result); + return result; +} + +} // namespace dragonx::wallet \ No newline at end of file diff --git a/src/wallet/lite_result_parsers.h b/src/wallet/lite_result_parsers.h new file mode 100644 index 0000000..77f02ed --- /dev/null +++ b/src/wallet/lite_result_parsers.h @@ -0,0 +1,169 @@ +#pragma once + +#include +#include +#include +#include + +#include + +namespace dragonx::wallet { + +enum class LiteResultCommand { + Info, + Height, + Balance, + Addresses, + List, + Notes, + SyncStatus, +}; + +enum class LiteResultParserError { + None, + InvalidJson, + ExpectedObject, + ExpectedArray, + MissingField, + InvalidFieldType, + InvalidFieldValue, +}; + +enum class LiteSpendableOutputKind { + UnspentNote, + Utxo, + PendingNote, + PendingUtxo, +}; + +enum class LiteTransactionDirection { + Unknown, + Send, + Receive, +}; + +struct LiteResultParserIssue { + std::string path; + std::string message; +}; + +struct LiteParseResultBase { + bool ok = false; + LiteResultCommand command = LiteResultCommand::Info; + LiteResultParserError error = LiteResultParserError::None; + std::string errorPath; + std::string errorMessage; + std::vector issues; +}; + +struct LiteInfoResponse { + std::optional chainName; + std::optional version; + std::optional vendor; + std::optional latestBlockHeight; + std::optional difficulty; + std::optional longestChain; + std::optional notarized; +}; + +struct LiteHeightResponse { + std::int64_t height = 0; +}; + +struct LiteBalanceResponse { + std::uint64_t transparentBalance = 0; + std::uint64_t shieldedBalance = 0; + std::uint64_t unconfirmedBalance = 0; + std::uint64_t verifiedShieldedBalance = 0; + std::uint64_t spendableShieldedBalance = 0; +}; + +struct LiteAddressesResponse { + std::vector zAddresses; + std::vector tAddresses; +}; + +struct LiteSpendableOutput { + LiteSpendableOutputKind kind = LiteSpendableOutputKind::UnspentNote; + std::string address; + std::string createdInTxid; + std::optional createdInBlock; + std::uint64_t value = 0; + bool spent = false; + bool unconfirmedSpent = false; + bool pending = false; + bool spendable = false; +}; + +struct LiteNotesResponse { + std::vector unspentNotes; + std::vector utxos; + std::vector pendingNotes; + std::vector pendingUtxos; +}; + +struct LiteTransactionOutput { + std::string address; + std::int64_t value = 0; + std::string memo; +}; + +struct LiteTransactionRecord { + std::string txid; + std::int64_t datetime = 0; + std::optional blockHeight; + bool unconfirmed = false; + LiteTransactionDirection direction = LiteTransactionDirection::Unknown; + std::string address; + std::int64_t amount = 0; + std::string memo; + std::optional position; + std::vector outgoingMetadata; +}; + +struct LiteTransactionsResponse { + std::vector transactions; +}; + +struct LiteSyncStatusResponse { + std::uint64_t syncedBlocks = 0; + std::uint64_t totalBlocks = 0; + double progress = 0.0; + bool complete = false; +}; + +struct LiteInfoParseResult : LiteParseResultBase { LiteInfoResponse info; }; +struct LiteHeightParseResult : LiteParseResultBase { LiteHeightResponse height; }; +struct LiteBalanceParseResult : LiteParseResultBase { LiteBalanceResponse balance; }; +struct LiteAddressesParseResult : LiteParseResultBase { LiteAddressesResponse addresses; }; +struct LiteNotesParseResult : LiteParseResultBase { LiteNotesResponse notes; }; +struct LiteTransactionsParseResult : LiteParseResultBase { LiteTransactionsResponse transactions; }; +struct LiteSyncStatusParseResult : LiteParseResultBase { LiteSyncStatusResponse syncStatus; }; + +const char* liteResultCommandName(LiteResultCommand command); +const char* liteResultParserErrorName(LiteResultParserError error); +const char* liteSpendableOutputKindName(LiteSpendableOutputKind kind); +const char* liteTransactionDirectionName(LiteTransactionDirection direction); + +LiteInfoParseResult parseLiteInfoResponse(const std::string& jsonText); +LiteInfoParseResult parseLiteInfoResponse(const nlohmann::json& value); + +LiteHeightParseResult parseLiteHeightResponse(const std::string& jsonText); +LiteHeightParseResult parseLiteHeightResponse(const nlohmann::json& value); + +LiteBalanceParseResult parseLiteBalanceResponse(const std::string& jsonText); +LiteBalanceParseResult parseLiteBalanceResponse(const nlohmann::json& value); + +LiteAddressesParseResult parseLiteAddressesResponse(const std::string& jsonText); +LiteAddressesParseResult parseLiteAddressesResponse(const nlohmann::json& value); + +LiteNotesParseResult parseLiteNotesResponse(const std::string& jsonText); +LiteNotesParseResult parseLiteNotesResponse(const nlohmann::json& value); + +LiteTransactionsParseResult parseLiteTransactionsResponse(const std::string& jsonText); +LiteTransactionsParseResult parseLiteTransactionsResponse(const nlohmann::json& value); + +LiteSyncStatusParseResult parseLiteSyncStatusResponse(const std::string& jsonText); +LiteSyncStatusParseResult parseLiteSyncStatusResponse(const nlohmann::json& value); + +} // namespace dragonx::wallet \ No newline at end of file diff --git a/src/wallet/lite_sync_service.cpp b/src/wallet/lite_sync_service.cpp new file mode 100644 index 0000000..4448cd3 --- /dev/null +++ b/src/wallet/lite_sync_service.cpp @@ -0,0 +1,371 @@ +#include "wallet/lite_sync_service.h" + +#include +#include +#include +#include + +namespace dragonx::wallet { +namespace { + +std::string trimSyncCopy(const std::string& value) +{ + auto begin = value.begin(); + while (begin != value.end() && std::isspace(static_cast(*begin))) ++begin; + + auto end = value.end(); + while (end != begin && std::isspace(static_cast(*(end - 1)))) --end; + + return std::string(begin, end); +} + +std::uint64_t effectiveStagnantThreshold(std::uint64_t threshold) +{ + return threshold == 0 ? 1 : threshold; +} + +WalletBackendStatus makeSyncScaffoldStatus(WalletBackendState state, + std::string message, + const LiteSyncStatusResponse* syncStatus = nullptr) +{ + WalletBackendStatus status; + status.state = state; + status.message = std::move(message); + if (syncStatus) { + status.walletHeight = static_cast(std::min(syncStatus->syncedBlocks, static_cast(std::numeric_limits::max()))); + status.chainHeight = static_cast(std::min(syncStatus->totalBlocks, static_cast(std::numeric_limits::max()))); + status.syncProgress = syncStatus->progress; + } + return status; +} + +} // namespace + +const char* liteSyncOperationName(LiteSyncOperation operation) +{ + switch (operation) { + case LiteSyncOperation::StartSync: return "StartSync"; + case LiteSyncOperation::PollSyncStatus: return "PollSyncStatus"; + } + return "Unknown"; +} + +const char* liteSyncStartModeName(LiteSyncStartMode mode) +{ + switch (mode) { + case LiteSyncStartMode::Startup: return "Startup"; + case LiteSyncStartMode::Restore: return "Restore"; + case LiteSyncStartMode::Rescan: return "Rescan"; + case LiteSyncStartMode::Recovery: return "Recovery"; + } + return "Unknown"; +} + +const char* liteSyncAvailabilityName(LiteSyncAvailability availability) +{ + switch (availability) { + case LiteSyncAvailability::Ready: return "Ready"; + case LiteSyncAvailability::UnsupportedBuild: return "UnsupportedBuild"; + case LiteSyncAvailability::BackendUnavailable: return "BackendUnavailable"; + case LiteSyncAvailability::BridgeUnavailable: return "BridgeUnavailable"; + case LiteSyncAvailability::BridgeCallsDisabled: return "BridgeCallsDisabled"; + case LiteSyncAvailability::NoUsableServer: return "NoUsableServer"; + } + return "Unknown"; +} + +const char* liteSyncRecoveryDecisionKindName(LiteSyncRecoveryDecisionKind kind) +{ + switch (kind) { + case LiteSyncRecoveryDecisionKind::KeepPolling: return "KeepPolling"; + case LiteSyncRecoveryDecisionKind::SyncComplete: return "SyncComplete"; + case LiteSyncRecoveryDecisionKind::Stuck: return "Stuck"; + case LiteSyncRecoveryDecisionKind::ReorgDetected: return "ReorgDetected"; + case LiteSyncRecoveryDecisionKind::InvalidStatus: return "InvalidStatus"; + } + return "Unknown"; +} + +WalletBackendStatus walletStatusFromLiteSyncStatus(const LiteSyncStatusResponse& syncStatus) +{ + if (syncStatus.complete) { + return makeSyncScaffoldStatus( + WalletBackendState::Ready, + "lite syncstatus reports sync complete", + &syncStatus); + } + return makeSyncScaffoldStatus( + WalletBackendState::Syncing, + "lite syncstatus reports sync in progress", + &syncStatus); +} + +LiteSyncRecoveryDecision evaluateLiteSyncRecovery(const LiteSyncRecoveryInput& input) +{ + if (input.totalBlocks > 0 && input.syncedBlocks > input.totalBlocks) { + return LiteSyncRecoveryDecision{ + LiteSyncRecoveryDecisionKind::InvalidStatus, + false, + false, + false, + false, + true, + "synced block count is greater than total block count" + }; + } + + if (input.havePreviousSyncedBlocks && input.syncedBlocks < input.previousSyncedBlocks) { + return LiteSyncRecoveryDecision{ + LiteSyncRecoveryDecisionKind::ReorgDetected, + false, + true, + true, + true, + false, + "synced block count moved backwards; model clear/rescan recovery" + }; + } + + if (input.totalBlocks > 0 && input.syncedBlocks >= input.totalBlocks) { + return LiteSyncRecoveryDecision{ + LiteSyncRecoveryDecisionKind::SyncComplete, + false, + false, + false, + false, + false, + "syncstatus reports all blocks synced" + }; + } + + const auto threshold = effectiveStagnantThreshold(input.stagnantPollThreshold); + if (input.havePreviousSyncedBlocks && + input.syncedBlocks == input.previousSyncedBlocks && + input.stagnantPollCount >= threshold) { + return LiteSyncRecoveryDecision{ + LiteSyncRecoveryDecisionKind::Stuck, + false, + false, + false, + true, + false, + "synced block count has not advanced past the configured threshold" + }; + } + + return LiteSyncRecoveryDecision{ + LiteSyncRecoveryDecisionKind::KeepPolling, + true, + false, + false, + false, + false, + "syncstatus is usable; keep polling" + }; +} + +LiteSyncService::LiteSyncService(WalletCapabilities capabilities, + LiteConnectionSettings connectionSettings, + LiteClientBridge bridge, + LiteSyncServiceOptions options) + : capabilities_(capabilities), + connectionSettings_(std::move(connectionSettings)), + bridge_(std::move(bridge)), + options_(options) +{ +} + +LiteSyncAvailability LiteSyncService::availability() const +{ + if (!isLiteBuild(capabilities_)) return LiteSyncAvailability::UnsupportedBuild; + if (!supportsLiteBackend(capabilities_)) return LiteSyncAvailability::BackendUnavailable; + if (!bridge_.available()) return LiteSyncAvailability::BridgeUnavailable; + if (!selectLiteServer(connectionSettings_).ok) return LiteSyncAvailability::NoUsableServer; + if (!options_.allowSyncStatusBridgeCalls) return LiteSyncAvailability::BridgeCallsDisabled; + return LiteSyncAvailability::Ready; +} + +WalletBackendStatus LiteSyncService::status() const +{ + const auto currentAvailability = availability(); + if (currentAvailability == LiteSyncAvailability::NoUsableServer) { + return statusFor(currentAvailability, selectLiteServer(connectionSettings_).error); + } + return statusFor(currentAvailability); +} + +LiteSyncPlan LiteSyncService::planStartSync(const LiteSyncStartRequest& request) const +{ + return makePlan( + LiteSyncOperation::StartSync, + request.serverUrl, + false, + request.mode, + request.forceRescan, + request.afterRestore); +} + +LiteSyncPlan LiteSyncService::planSyncStatus(const LiteSyncStatusRequest& request) const +{ + return makePlan( + LiteSyncOperation::PollSyncStatus, + request.serverUrl, + options_.allowSyncStatusBridgeCalls, + LiteSyncStartMode::Startup, + false, + false); +} + +LiteSyncStartResult LiteSyncService::startSync(const LiteSyncStartRequest& request) +{ + const auto plan = planStartSync(request); + if (!plan.ok) return blockedStartResult(plan, makeSyncScaffoldStatus(WalletBackendState::Error, plan.error)); + + const auto currentAvailability = availability(); + if (currentAvailability == LiteSyncAvailability::UnsupportedBuild || + currentAvailability == LiteSyncAvailability::BackendUnavailable || + currentAvailability == LiteSyncAvailability::BridgeUnavailable || + currentAvailability == LiteSyncAvailability::NoUsableServer) { + return blockedStartResult(plan, status()); + } + + return blockedStartResult( + plan, + makeSyncScaffoldStatus(WalletBackendState::Unavailable, "lite sync start execution is not implemented")); +} + +LiteSyncStatusResult LiteSyncService::pollSyncStatus(const LiteSyncStatusRequest& request) +{ + const auto plan = planSyncStatus(request); + if (!plan.ok) return blockedStatusResult(plan, makeSyncScaffoldStatus(WalletBackendState::Error, plan.error)); + + if (availability() != LiteSyncAvailability::Ready) return blockedStatusResult(plan, status()); + + LiteSyncStatusResult result; + result.plan = plan; + result.attempted = true; + + const auto bridgeCall = bridge_.execute(plan.command, plan.args); + result.bridgeResponseRedacted = bridgeCall.ok || !bridgeCall.error.empty() ? "" : ""; + if (!bridgeCall.ok) { + result.status = makeSyncScaffoldStatus(WalletBackendState::Error, "lite syncstatus bridge call failed"); + result.error = result.status.message; + return result; + } + + result.bridgeAccepted = true; + const auto parsed = parseLiteSyncStatusResponse(bridgeCall.value); + if (!parsed.ok) { + result.parserError = parsed.error; + result.status = makeSyncScaffoldStatus(WalletBackendState::Error, "lite syncstatus response could not be parsed"); + result.error = result.status.message; + return result; + } + + result.ok = true; + result.parserError = LiteResultParserError::None; + result.syncStatus = parsed.syncStatus; + result.status = walletStatusFromLiteSyncStatus(result.syncStatus); + return result; +} + +LiteServerSelectionResult LiteSyncService::selectServerForRequest(const std::string& serverUrl) const +{ + const auto overrideUrl = trimSyncCopy(serverUrl); + if (!overrideUrl.empty()) { + if (!isLiteServerUrlUsable(overrideUrl)) { + return LiteServerSelectionResult{false, {}, 0, false, "lite sync server URL is not usable"}; + } + return LiteServerSelectionResult{ + true, + LiteServerEndpoint{overrideUrl, "Request", true}, + 0, + true, + {} + }; + } + return selectLiteServer(connectionSettings_); +} + +LiteSyncPlan LiteSyncService::makePlan(LiteSyncOperation operation, + const std::string& serverUrl, + bool bridgeExecutionAllowed, + LiteSyncStartMode startMode, + bool forceRescan, + bool afterRestore) const +{ + LiteSyncPlan plan; + plan.operation = operation; + plan.startMode = startMode; + plan.bridgeExecutionAllowed = bridgeExecutionAllowed; + plan.forceRescan = forceRescan; + plan.afterRestore = afterRestore; + plan.command = operation == LiteSyncOperation::StartSync ? "sync" : "syncstatus"; + + auto selection = selectServerForRequest(serverUrl); + if (!selection.ok) { + plan.error = selection.error; + return plan; + } + + plan.ok = true; + plan.server = selection.server; + plan.serverIndex = selection.serverIndex; + plan.customServer = selection.customServer; + return plan; +} + +WalletBackendStatus LiteSyncService::statusFor(LiteSyncAvailability availability, + const std::string& detail) const +{ + switch (availability) { + case LiteSyncAvailability::Ready: + return makeSyncScaffoldStatus( + WalletBackendState::Disconnected, + detail.empty() ? "lite sync scaffold ready; sync is not started" : detail); + case LiteSyncAvailability::UnsupportedBuild: + return makeSyncScaffoldStatus( + WalletBackendState::Unavailable, + "lite sync service is unsupported in full-node builds"); + case LiteSyncAvailability::BackendUnavailable: + return makeSyncScaffoldStatus( + WalletBackendState::Unavailable, + "lite backend is not linked"); + case LiteSyncAvailability::BridgeUnavailable: + return makeSyncScaffoldStatus( + WalletBackendState::Unavailable, + detail.empty() ? bridge_.unavailableReason() : detail); + case LiteSyncAvailability::BridgeCallsDisabled: + return makeSyncScaffoldStatus( + WalletBackendState::Unavailable, + "lite syncstatus bridge calls are disabled"); + case LiteSyncAvailability::NoUsableServer: + return makeSyncScaffoldStatus( + WalletBackendState::Error, + detail.empty() ? "no usable lite servers are configured" : detail); + } + + return makeSyncScaffoldStatus(WalletBackendState::Unavailable, "unknown lite sync state"); +} + +LiteSyncStartResult LiteSyncService::blockedStartResult(const LiteSyncPlan& plan, + const WalletBackendStatus& blockedStatus) const +{ + LiteSyncStartResult result; + result.plan = plan; + result.status = blockedStatus; + result.error = blockedStatus.message; + return result; +} + +LiteSyncStatusResult LiteSyncService::blockedStatusResult(const LiteSyncPlan& plan, + const WalletBackendStatus& blockedStatus) const +{ + LiteSyncStatusResult result; + result.plan = plan; + result.status = blockedStatus; + result.error = blockedStatus.message; + return result; +} + +} // namespace dragonx::wallet \ No newline at end of file diff --git a/src/wallet/lite_sync_service.h b/src/wallet/lite_sync_service.h new file mode 100644 index 0000000..0438b68 --- /dev/null +++ b/src/wallet/lite_sync_service.h @@ -0,0 +1,162 @@ +#pragma once + +#include "lite_client_bridge.h" +#include "lite_connection_service.h" +#include "lite_result_parsers.h" +#include "wallet_backend.h" +#include "wallet_capabilities.h" + +#include +#include +#include + +namespace dragonx::wallet { + +enum class LiteSyncOperation { + StartSync, + PollSyncStatus, +}; + +enum class LiteSyncStartMode { + Startup, + Restore, + Rescan, + Recovery, +}; + +enum class LiteSyncAvailability { + Ready, + UnsupportedBuild, + BackendUnavailable, + BridgeUnavailable, + BridgeCallsDisabled, + NoUsableServer, +}; + +enum class LiteSyncRecoveryDecisionKind { + KeepPolling, + SyncComplete, + Stuck, + ReorgDetected, + InvalidStatus, +}; + +struct LiteSyncStartRequest { + LiteSyncStartMode mode = LiteSyncStartMode::Startup; + std::string serverUrl; + bool forceRescan = false; + bool afterRestore = false; +}; + +struct LiteSyncStatusRequest { + std::string serverUrl; +}; + +struct LiteSyncPlan { + bool ok = false; + LiteSyncOperation operation = LiteSyncOperation::StartSync; + LiteSyncStartMode startMode = LiteSyncStartMode::Startup; + LiteServerEndpoint server; + std::size_t serverIndex = 0; + bool customServer = false; + bool bridgeExecutionAllowed = false; + std::string command; + std::string args; + bool forceRescan = false; + bool afterRestore = false; + std::string error; +}; + +struct LiteSyncStartResult { + bool ok = false; + bool attempted = false; + bool syncStarted = false; + LiteSyncPlan plan; + WalletBackendStatus status; + std::string error; +}; + +struct LiteSyncStatusResult { + bool ok = false; + bool attempted = false; + bool bridgeAccepted = false; + LiteSyncPlan plan; + LiteSyncStatusResponse syncStatus; + LiteResultParserError parserError = LiteResultParserError::None; + WalletBackendStatus status; + std::string bridgeResponseRedacted = ""; + std::string error; +}; + +struct LiteSyncRecoveryInput { + bool havePreviousSyncedBlocks = false; + std::uint64_t previousSyncedBlocks = 0; + std::uint64_t syncedBlocks = 0; + std::uint64_t totalBlocks = 0; + std::uint64_t stagnantPollCount = 0; + std::uint64_t stagnantPollThreshold = 10; +}; + +struct LiteSyncRecoveryDecision { + LiteSyncRecoveryDecisionKind kind = LiteSyncRecoveryDecisionKind::KeepPolling; + bool shouldPollAgain = true; + bool shouldClear = false; + bool shouldRescan = false; + bool shouldRestartSync = false; + bool requiresUserAttention = false; + std::string reason; +}; + +struct LiteSyncServiceOptions { + bool allowSyncStatusBridgeCalls = false; +}; + +const char* liteSyncOperationName(LiteSyncOperation operation); +const char* liteSyncStartModeName(LiteSyncStartMode mode); +const char* liteSyncAvailabilityName(LiteSyncAvailability availability); +const char* liteSyncRecoveryDecisionKindName(LiteSyncRecoveryDecisionKind kind); + +WalletBackendStatus walletStatusFromLiteSyncStatus(const LiteSyncStatusResponse& syncStatus); +LiteSyncRecoveryDecision evaluateLiteSyncRecovery(const LiteSyncRecoveryInput& input); + +class LiteSyncService { +public: + LiteSyncService(WalletCapabilities capabilities, + LiteConnectionSettings connectionSettings, + LiteClientBridge bridge, + LiteSyncServiceOptions options = {}); + + const WalletCapabilities& capabilities() const { return capabilities_; } + const LiteConnectionSettings& connectionSettings() const { return connectionSettings_; } + const LiteSyncServiceOptions& options() const { return options_; } + + LiteSyncAvailability availability() const; + WalletBackendStatus status() const; + + LiteSyncPlan planStartSync(const LiteSyncStartRequest& request) const; + LiteSyncPlan planSyncStatus(const LiteSyncStatusRequest& request) const; + LiteSyncStartResult startSync(const LiteSyncStartRequest& request); + LiteSyncStatusResult pollSyncStatus(const LiteSyncStatusRequest& request); + +private: + LiteServerSelectionResult selectServerForRequest(const std::string& serverUrl) const; + LiteSyncPlan makePlan(LiteSyncOperation operation, + const std::string& serverUrl, + bool bridgeExecutionAllowed, + LiteSyncStartMode startMode, + bool forceRescan, + bool afterRestore) const; + WalletBackendStatus statusFor(LiteSyncAvailability availability, + const std::string& detail = {}) const; + LiteSyncStartResult blockedStartResult(const LiteSyncPlan& plan, + const WalletBackendStatus& blockedStatus) const; + LiteSyncStatusResult blockedStatusResult(const LiteSyncPlan& plan, + const WalletBackendStatus& blockedStatus) const; + + WalletCapabilities capabilities_; + LiteConnectionSettings connectionSettings_; + LiteClientBridge bridge_; + LiteSyncServiceOptions options_; +}; + +} // namespace dragonx::wallet \ No newline at end of file diff --git a/src/wallet/lite_wallet_app_refresh_coordinator.cpp b/src/wallet/lite_wallet_app_refresh_coordinator.cpp new file mode 100644 index 0000000..d9731c8 --- /dev/null +++ b/src/wallet/lite_wallet_app_refresh_coordinator.cpp @@ -0,0 +1,172 @@ +#include "wallet/lite_wallet_app_refresh_coordinator.h" + +#include + +namespace dragonx::wallet { +namespace { + +void addIssue(LiteWalletAppRefreshCoordinationResult& result, + LiteWalletAppRefreshCoordinationIssue issue, + std::string message) +{ + result.issues.push_back(LiteWalletAppRefreshCoordinationIssueInfo{issue, std::move(message)}); +} + +std::string refreshFailureMessage(const LiteWalletRefreshServiceResult& refreshResult) +{ + if (!refreshResult.error.empty()) return refreshResult.error; + if (!refreshResult.status.message.empty()) return refreshResult.status.message; + return "lite wallet refresh service result is not successful"; +} + +void copyExecutionSummary(LiteWalletAppRefreshCoordinationResult& result) +{ + result.stateMutationRequested = result.executionResult.stateMutationRequested; + result.stateMutationAllowed = result.applyPlan.stateMutationAllowed || + result.executionResult.stateMutationAllowed; + result.stateMutated = result.executionResult.stateMutated; + result.walletStateWritten = result.stateMutated; + result.dryRunOnly = result.applyPlan.dryRunOnly && result.executionResult.dryRunOnly; + result.noNetwork = result.executionResult.noNetwork; + result.fieldPlanCount = result.executionResult.fieldPlanCount; + result.collectionPlanCount = result.executionResult.collectionPlanCount; + result.plannedChangeCount = result.executionResult.plannedChangeCount; + result.planIssueCount = result.executionResult.planIssueCount; + result.executionIssueCount = result.executionResult.issues.size(); +} + +} // namespace + +const char* liteWalletAppRefreshCoordinationStatusName( + LiteWalletAppRefreshCoordinationStatus status) +{ + switch (status) { + case LiteWalletAppRefreshCoordinationStatus::DryRunReported: return "DryRunReported"; + case LiteWalletAppRefreshCoordinationStatus::Rejected: return "Rejected"; + case LiteWalletAppRefreshCoordinationStatus::ApplyUnavailable: return "ApplyUnavailable"; + } + return "Unknown"; +} + +const char* liteWalletAppRefreshCoordinationIssueName( + LiteWalletAppRefreshCoordinationIssue issue) +{ + switch (issue) { + case LiteWalletAppRefreshCoordinationIssue::RefreshResultFailed: return "RefreshResultFailed"; + case LiteWalletAppRefreshCoordinationIssue::FullNodeRefreshDelegated: return "FullNodeRefreshDelegated"; + case LiteWalletAppRefreshCoordinationIssue::MappingFailed: return "MappingFailed"; + case LiteWalletAppRefreshCoordinationIssue::ApplyPlanFailed: return "ApplyPlanFailed"; + case LiteWalletAppRefreshCoordinationIssue::ApplyExecutionRejected: return "ApplyExecutionRejected"; + case LiteWalletAppRefreshCoordinationIssue::StateMutationDisabled: return "StateMutationDisabled"; + case LiteWalletAppRefreshCoordinationIssue::StateMutationImplementationMissing: return "StateMutationImplementationMissing"; + } + return "Unknown"; +} + +LiteWalletAppRefreshCoordinationResult coordinateLiteWalletAppRefresh( + const LiteWalletRefreshServiceResult& refreshResult, + const dragonx::WalletState& walletState, + LiteWalletAppRefreshCoordinatorOptions options) +{ + LiteWalletAppRefreshCoordinationResult result; + result.route = refreshResult.plan.route; + result.refreshStatus = refreshResult.status; + result.refreshAttempted = refreshResult.attempted; + result.fullNodeRefreshDelegated = refreshResult.fullNodeRefreshDelegated; + result.liteGatewayCalled = refreshResult.liteGatewayCalled; + result.stateMutationRequested = options.executorOptions.requestStateMutation; + + if (refreshResult.fullNodeRefreshDelegated) { + addIssue(result, + LiteWalletAppRefreshCoordinationIssue::FullNodeRefreshDelegated, + "full-node refresh remains delegated; lite app refresh coordinator did not run"); + result.error = result.issues.back().message; + return result; + } + + if (!refreshResult.ok) { + addIssue(result, + LiteWalletAppRefreshCoordinationIssue::RefreshResultFailed, + refreshFailureMessage(refreshResult)); + result.error = result.issues.back().message; + return result; + } + + result.refreshAccepted = true; + result.mapResult = mapLiteWalletRefreshServiceResult(refreshResult); + result.mapIssueCount = result.mapResult.issues.size(); + if (!result.mapResult.ok) { + addIssue(result, + LiteWalletAppRefreshCoordinationIssue::MappingFailed, + result.mapResult.error.empty() + ? "lite wallet refresh service result could not be mapped" + : result.mapResult.error); + result.error = result.issues.back().message; + return result; + } + + result.mapped = true; + result.successfulCommandCount = result.mapResult.model.successfulCommandCount; + result.applyPlan = planLiteWalletStateApply(result.mapResult.model, walletState); + if (!result.applyPlan.ok) { + result.fieldPlanCount = result.applyPlan.fieldPlans.size(); + result.collectionPlanCount = result.applyPlan.collectionPlans.size(); + result.planIssueCount = result.applyPlan.issues.size(); + addIssue(result, + LiteWalletAppRefreshCoordinationIssue::ApplyPlanFailed, + result.applyPlan.error.empty() + ? "lite WalletState apply plan could not be built" + : result.applyPlan.error); + result.error = result.issues.back().message; + return result; + } + + result.planned = true; + LiteWalletStateApplyExecutor executor(options.executorOptions); + result.executionResult = executor.execute(result.applyPlan); + result.executionReported = true; + copyExecutionSummary(result); + + if (!result.executionResult.ok) { + result.error = result.executionResult.error; + if (result.executionResult.status == LiteWalletStateApplyExecutionStatus::ImplementationMissing) { + result.status = LiteWalletAppRefreshCoordinationStatus::ApplyUnavailable; + addIssue(result, + LiteWalletAppRefreshCoordinationIssue::StateMutationImplementationMissing, + result.executionResult.error.empty() + ? "real lite WalletState application requires a future explicit implementation" + : result.executionResult.error); + } else { + result.status = LiteWalletAppRefreshCoordinationStatus::Rejected; + addIssue(result, + LiteWalletAppRefreshCoordinationIssue::ApplyExecutionRejected, + result.executionResult.error.empty() + ? "lite WalletState apply execution report was rejected" + : result.executionResult.error); + } + if (result.error.empty()) result.error = result.issues.back().message; + return result; + } + + result.ok = true; + result.status = LiteWalletAppRefreshCoordinationStatus::DryRunReported; + addIssue(result, + LiteWalletAppRefreshCoordinationIssue::StateMutationDisabled, + "lite app refresh coordinator produced a dry-run report only; WalletState was not written"); + return result; +} + +LiteWalletAppRefreshCoordinator::LiteWalletAppRefreshCoordinator( + LiteWalletAppRefreshCoordinatorOptions options) + : options_(options) +{ +} + +LiteWalletAppRefreshCoordinationResult LiteWalletAppRefreshCoordinator::coordinate( + const LiteWalletRefreshServiceResult& refreshResult, + const dragonx::WalletState& walletState) const +{ + return coordinateLiteWalletAppRefresh(refreshResult, walletState, options_); +} + +} // namespace dragonx::wallet \ No newline at end of file diff --git a/src/wallet/lite_wallet_app_refresh_coordinator.h b/src/wallet/lite_wallet_app_refresh_coordinator.h new file mode 100644 index 0000000..fd536c9 --- /dev/null +++ b/src/wallet/lite_wallet_app_refresh_coordinator.h @@ -0,0 +1,96 @@ +#pragma once + +#include "data/wallet_state.h" +#include "lite_wallet_refresh_service.h" +#include "lite_wallet_state_apply_executor.h" +#include "lite_wallet_state_mapper.h" + +#include +#include +#include + +namespace dragonx::wallet { + +enum class LiteWalletAppRefreshCoordinationStatus { + DryRunReported, + Rejected, + ApplyUnavailable, +}; + +enum class LiteWalletAppRefreshCoordinationIssue { + RefreshResultFailed, + FullNodeRefreshDelegated, + MappingFailed, + ApplyPlanFailed, + ApplyExecutionRejected, + StateMutationDisabled, + StateMutationImplementationMissing, +}; + +struct LiteWalletAppRefreshCoordinatorOptions { + LiteWalletStateApplyExecutorOptions executorOptions; +}; + +struct LiteWalletAppRefreshCoordinationIssueInfo { + LiteWalletAppRefreshCoordinationIssue issue = LiteWalletAppRefreshCoordinationIssue::StateMutationDisabled; + std::string message; +}; + +struct LiteWalletAppRefreshCoordinationResult { + bool ok = false; + bool refreshAccepted = false; + bool refreshAttempted = false; + bool fullNodeRefreshDelegated = false; + bool liteGatewayCalled = false; + bool mapped = false; + bool planned = false; + bool executionReported = false; + bool dryRunOnly = true; + bool noNetwork = true; + bool stateMutationRequested = false; + bool stateMutationAllowed = false; + bool stateMutated = false; + bool walletStateWritten = false; + + LiteWalletAppRefreshCoordinationStatus status = LiteWalletAppRefreshCoordinationStatus::Rejected; + LiteWalletRefreshRouteKind route = LiteWalletRefreshRouteKind::Unavailable; + WalletBackendStatus refreshStatus; + + std::size_t successfulCommandCount = 0; + std::size_t mapIssueCount = 0; + std::size_t fieldPlanCount = 0; + std::size_t collectionPlanCount = 0; + std::size_t plannedChangeCount = 0; + std::size_t planIssueCount = 0; + std::size_t executionIssueCount = 0; + + LiteWalletStateMapResult mapResult; + LiteWalletStateApplyPlan applyPlan; + LiteWalletStateApplyExecutionResult executionResult; + std::vector issues; + std::string error; +}; + +const char* liteWalletAppRefreshCoordinationStatusName( + LiteWalletAppRefreshCoordinationStatus status); +const char* liteWalletAppRefreshCoordinationIssueName( + LiteWalletAppRefreshCoordinationIssue issue); + +LiteWalletAppRefreshCoordinationResult coordinateLiteWalletAppRefresh( + const LiteWalletRefreshServiceResult& refreshResult, + const dragonx::WalletState& walletState, + LiteWalletAppRefreshCoordinatorOptions options = {}); + +class LiteWalletAppRefreshCoordinator { +public: + explicit LiteWalletAppRefreshCoordinator(LiteWalletAppRefreshCoordinatorOptions options = {}); + + LiteWalletAppRefreshCoordinationResult coordinate( + const LiteWalletRefreshServiceResult& refreshResult, + const dragonx::WalletState& walletState) const; + +private: + LiteWalletAppRefreshCoordinatorOptions options_; +}; + +} // namespace dragonx::wallet \ No newline at end of file diff --git a/src/wallet/lite_wallet_app_refresh_orchestrator.cpp b/src/wallet/lite_wallet_app_refresh_orchestrator.cpp new file mode 100644 index 0000000..e064b5a --- /dev/null +++ b/src/wallet/lite_wallet_app_refresh_orchestrator.cpp @@ -0,0 +1,197 @@ +#include "wallet/lite_wallet_app_refresh_orchestrator.h" + +#include + +namespace dragonx::wallet { +namespace { + +void addIssue(LiteWalletAppRefreshOrchestrationResult& result, + LiteWalletAppRefreshOrchestrationIssue issue, + std::string message) +{ + result.issues.push_back(LiteWalletAppRefreshOrchestrationIssueInfo{issue, std::move(message)}); +} + +bool readinessReportIsUnsafe(const LiteWalletRefreshReadinessResult& readiness) +{ + return !readiness.dryRunOnly || + !readiness.noNetwork || + readiness.stateMutationRequested || + readiness.stateMutationAllowed || + readiness.stateMutated || + readiness.walletStateWritten; +} + +std::string readinessErrorOrDefault(const LiteWalletRefreshReadinessResult& readiness) +{ + return readiness.error.empty() + ? "lite refresh readiness report is not eligible" + : readiness.error; +} + +LiteWalletAppRefreshOrchestrationResult blockedResult( + LiteWalletAppRefreshOrchestrationResult result, + LiteWalletAppRefreshOrchestrationIssue issue, + std::string message) +{ + result.status = LiteWalletAppRefreshOrchestrationStatus::Blocked; + result.blocked = true; + addIssue(result, issue, std::move(message)); + result.error = result.issues.back().message; + return result; +} + +LiteWalletAppRefreshOrchestrationResult skippedResult( + LiteWalletAppRefreshOrchestrationResult result, + LiteWalletAppRefreshOrchestrationIssue issue, + std::string message) +{ + result.ok = true; + result.status = LiteWalletAppRefreshOrchestrationStatus::Skipped; + result.skipped = true; + addIssue(result, issue, std::move(message)); + return result; +} + +std::size_t effectiveMaxQueueDepth(const LiteWalletAppRefreshScheduleInput& schedule, + const LiteWalletAppRefreshOrchestratorOptions& options) +{ + return schedule.maxQueueDepth > 0 ? schedule.maxQueueDepth : options.maxQueueDepth; +} + +} // namespace + +const char* liteWalletAppRefreshOrchestrationStatusName( + LiteWalletAppRefreshOrchestrationStatus status) +{ + switch (status) { + case LiteWalletAppRefreshOrchestrationStatus::Queued: return "Queued"; + case LiteWalletAppRefreshOrchestrationStatus::Skipped: return "Skipped"; + case LiteWalletAppRefreshOrchestrationStatus::Blocked: return "Blocked"; + } + return "Unknown"; +} + +const char* liteWalletAppRefreshScheduleTriggerName( + LiteWalletAppRefreshScheduleTrigger trigger) +{ + switch (trigger) { + case LiteWalletAppRefreshScheduleTrigger::Periodic: return "Periodic"; + case LiteWalletAppRefreshScheduleTrigger::Manual: return "Manual"; + case LiteWalletAppRefreshScheduleTrigger::Startup: return "Startup"; + case LiteWalletAppRefreshScheduleTrigger::WalletOpened: return "WalletOpened"; + } + return "Unknown"; +} + +const char* liteWalletAppRefreshOrchestrationIssueName( + LiteWalletAppRefreshOrchestrationIssue issue) +{ + switch (issue) { + case LiteWalletAppRefreshOrchestrationIssue::ReadinessRejected: return "ReadinessRejected"; + case LiteWalletAppRefreshOrchestrationIssue::UnsafeReadinessReport: return "UnsafeReadinessReport"; + case LiteWalletAppRefreshOrchestrationIssue::SchedulerDisabled: return "SchedulerDisabled"; + case LiteWalletAppRefreshOrchestrationIssue::RefreshNotDue: return "RefreshNotDue"; + case LiteWalletAppRefreshOrchestrationIssue::RefreshAlreadyQueued: return "RefreshAlreadyQueued"; + case LiteWalletAppRefreshOrchestrationIssue::RefreshInProgress: return "RefreshInProgress"; + case LiteWalletAppRefreshOrchestrationIssue::QueuePressure: return "QueuePressure"; + } + return "Unknown"; +} + +LiteWalletAppRefreshOrchestrationResult orchestrateLiteWalletAppRefresh( + const LiteWalletRefreshReadinessResult& readiness, + const LiteWalletAppRefreshScheduleInput& schedule, + LiteWalletAppRefreshOrchestratorOptions options) +{ + LiteWalletAppRefreshOrchestrationResult result; + result.readinessResult = readiness; + result.route = readiness.route; + result.dryRunOnly = readiness.dryRunOnly; + result.noNetwork = readiness.noNetwork; + result.stateMutationRequested = readiness.stateMutationRequested; + result.stateMutationAllowed = readiness.stateMutationAllowed; + result.stateMutated = readiness.stateMutated; + result.walletStateWritten = readiness.walletStateWritten; + result.trigger = schedule.trigger; + result.schedulerEnabled = schedule.schedulerEnabled; + result.refreshDue = schedule.refreshDue; + result.forceRefresh = schedule.forceRefresh; + result.refreshAlreadyQueued = schedule.refreshAlreadyQueued; + result.refreshInProgress = schedule.refreshInProgress; + result.queueDepth = schedule.queueDepth; + result.maxQueueDepth = effectiveMaxQueueDepth(schedule, options); + + if (options.requireEligibleReadiness && (!readiness.ok || !readiness.eligibleForFutureUiRefresh)) { + return blockedResult( + std::move(result), + LiteWalletAppRefreshOrchestrationIssue::ReadinessRejected, + readinessErrorOrDefault(readiness)); + } + + if (readinessReportIsUnsafe(readiness)) { + return blockedResult( + std::move(result), + LiteWalletAppRefreshOrchestrationIssue::UnsafeReadinessReport, + "lite refresh readiness report is not a no-network dry-run report"); + } + + result.readinessAccepted = true; + + if (!schedule.schedulerEnabled) { + return blockedResult( + std::move(result), + LiteWalletAppRefreshOrchestrationIssue::SchedulerDisabled, + "lite app refresh scheduler is disabled"); + } + + result.schedulerAccepted = true; + + if (result.maxQueueDepth > 0 && schedule.queueDepth >= result.maxQueueDepth) { + return blockedResult( + std::move(result), + LiteWalletAppRefreshOrchestrationIssue::QueuePressure, + "lite app refresh queue is at capacity"); + } + + if (schedule.refreshAlreadyQueued) { + return skippedResult( + std::move(result), + LiteWalletAppRefreshOrchestrationIssue::RefreshAlreadyQueued, + "lite app refresh is already queued"); + } + + if (schedule.refreshInProgress) { + return skippedResult( + std::move(result), + LiteWalletAppRefreshOrchestrationIssue::RefreshInProgress, + "lite app refresh is already in progress"); + } + + if (!schedule.refreshDue && !schedule.forceRefresh) { + return skippedResult( + std::move(result), + LiteWalletAppRefreshOrchestrationIssue::RefreshNotDue, + "lite app refresh is not due"); + } + + result.ok = true; + result.status = LiteWalletAppRefreshOrchestrationStatus::Queued; + result.wouldQueueRefresh = true; + return result; +} + +LiteWalletAppRefreshOrchestrator::LiteWalletAppRefreshOrchestrator( + LiteWalletAppRefreshOrchestratorOptions options) + : options_(options) +{ +} + +LiteWalletAppRefreshOrchestrationResult LiteWalletAppRefreshOrchestrator::evaluate( + const LiteWalletRefreshReadinessResult& readiness, + const LiteWalletAppRefreshScheduleInput& schedule) const +{ + return orchestrateLiteWalletAppRefresh(readiness, schedule, options_); +} + +} // namespace dragonx::wallet \ No newline at end of file diff --git a/src/wallet/lite_wallet_app_refresh_orchestrator.h b/src/wallet/lite_wallet_app_refresh_orchestrator.h new file mode 100644 index 0000000..ce4c657 --- /dev/null +++ b/src/wallet/lite_wallet_app_refresh_orchestrator.h @@ -0,0 +1,109 @@ +#pragma once + +#include "lite_wallet_refresh_readiness_policy.h" + +#include +#include +#include + +namespace dragonx::wallet { + +enum class LiteWalletAppRefreshOrchestrationStatus { + Queued, + Skipped, + Blocked, +}; + +enum class LiteWalletAppRefreshScheduleTrigger { + Periodic, + Manual, + Startup, + WalletOpened, +}; + +enum class LiteWalletAppRefreshOrchestrationIssue { + ReadinessRejected, + UnsafeReadinessReport, + SchedulerDisabled, + RefreshNotDue, + RefreshAlreadyQueued, + RefreshInProgress, + QueuePressure, +}; + +struct LiteWalletAppRefreshScheduleInput { + LiteWalletAppRefreshScheduleTrigger trigger = LiteWalletAppRefreshScheduleTrigger::Periodic; + bool schedulerEnabled = true; + bool refreshDue = false; + bool forceRefresh = false; + bool refreshAlreadyQueued = false; + bool refreshInProgress = false; + std::size_t queueDepth = 0; + std::size_t maxQueueDepth = 0; +}; + +struct LiteWalletAppRefreshOrchestratorOptions { + bool requireEligibleReadiness = true; + std::size_t maxQueueDepth = 0; +}; + +struct LiteWalletAppRefreshOrchestrationIssueInfo { + LiteWalletAppRefreshOrchestrationIssue issue = LiteWalletAppRefreshOrchestrationIssue::ReadinessRejected; + std::string message; +}; + +struct LiteWalletAppRefreshOrchestrationResult { + bool ok = false; + bool wouldQueueRefresh = false; + bool skipped = false; + bool blocked = false; + bool readinessAccepted = false; + bool schedulerAccepted = false; + bool dryRunOnly = true; + bool noNetwork = true; + bool stateMutationRequested = false; + bool stateMutationAllowed = false; + bool stateMutated = false; + bool walletStateWritten = false; + + bool schedulerEnabled = true; + bool refreshDue = false; + bool forceRefresh = false; + bool refreshAlreadyQueued = false; + bool refreshInProgress = false; + std::size_t queueDepth = 0; + std::size_t maxQueueDepth = 0; + + LiteWalletAppRefreshOrchestrationStatus status = LiteWalletAppRefreshOrchestrationStatus::Blocked; + LiteWalletAppRefreshScheduleTrigger trigger = LiteWalletAppRefreshScheduleTrigger::Periodic; + LiteWalletRefreshRouteKind route = LiteWalletRefreshRouteKind::Unavailable; + LiteWalletRefreshReadinessResult readinessResult; + std::vector issues; + std::string error; +}; + +const char* liteWalletAppRefreshOrchestrationStatusName( + LiteWalletAppRefreshOrchestrationStatus status); +const char* liteWalletAppRefreshScheduleTriggerName( + LiteWalletAppRefreshScheduleTrigger trigger); +const char* liteWalletAppRefreshOrchestrationIssueName( + LiteWalletAppRefreshOrchestrationIssue issue); + +LiteWalletAppRefreshOrchestrationResult orchestrateLiteWalletAppRefresh( + const LiteWalletRefreshReadinessResult& readiness, + const LiteWalletAppRefreshScheduleInput& schedule, + LiteWalletAppRefreshOrchestratorOptions options = {}); + +class LiteWalletAppRefreshOrchestrator { +public: + explicit LiteWalletAppRefreshOrchestrator(LiteWalletAppRefreshOrchestratorOptions options = {}); + + LiteWalletAppRefreshOrchestrationResult evaluate( + const LiteWalletRefreshReadinessResult& readiness, + const LiteWalletAppRefreshScheduleInput& schedule) const; + +private: + LiteWalletAppRefreshOrchestratorOptions options_; +}; + +} // namespace dragonx::wallet \ No newline at end of file diff --git a/src/wallet/lite_wallet_gateway.cpp b/src/wallet/lite_wallet_gateway.cpp new file mode 100644 index 0000000..361ef9e --- /dev/null +++ b/src/wallet/lite_wallet_gateway.cpp @@ -0,0 +1,409 @@ +#include "wallet/lite_wallet_gateway.h" + +#include +#include + +namespace dragonx::wallet { +namespace { + +std::string trimGatewayCopy(const std::string& value) +{ + auto begin = value.begin(); + while (begin != value.end() && std::isspace(static_cast(*begin))) ++begin; + + auto end = value.end(); + while (end != begin && std::isspace(static_cast(*(end - 1)))) --end; + + return std::string(begin, end); +} + +WalletBackendStatus makeGatewayStatus(WalletBackendState state, std::string message) +{ + WalletBackendStatus status; + status.state = state; + status.message = std::move(message); + return status; +} + +WalletBackendStatus refreshStatusForRequest(const LiteWalletRefreshRequest& request) +{ + if (request.haveSyncStatus) return walletStatusFromLiteSyncStatus(request.syncStatus); + return makeGatewayStatus( + WalletBackendState::Disconnected, + "lite wallet refresh bundle assembled; runtime wallet state is unchanged"); +} + +LiteWalletGatewayCommandResult parsedCommandResult(const LiteWalletGatewayPlan& plan) +{ + LiteWalletGatewayCommandResult result; + result.ok = true; + result.attempted = true; + result.bridgeAccepted = true; + result.plan = plan; + result.parserError = LiteResultParserError::None; + result.status = makeGatewayStatus( + WalletBackendState::Disconnected, + "lite gateway response parsed into intermediate refresh model"); + result.bridgeResponseRedacted = ""; + return result; +} + +} // namespace + +const char* liteWalletGatewayCommandName(LiteWalletGatewayCommand command) +{ + switch (command) { + case LiteWalletGatewayCommand::Info: return "info"; + case LiteWalletGatewayCommand::Height: return "height"; + case LiteWalletGatewayCommand::Balance: return "balance"; + case LiteWalletGatewayCommand::Addresses: return "addresses"; + case LiteWalletGatewayCommand::Notes: return "notes"; + case LiteWalletGatewayCommand::List: return "list"; + } + return "unknown"; +} + +const char* liteWalletGatewayAvailabilityName(LiteWalletGatewayAvailability availability) +{ + switch (availability) { + case LiteWalletGatewayAvailability::Ready: return "Ready"; + case LiteWalletGatewayAvailability::UnsupportedBuild: return "UnsupportedBuild"; + case LiteWalletGatewayAvailability::BackendUnavailable: return "BackendUnavailable"; + case LiteWalletGatewayAvailability::BridgeUnavailable: return "BridgeUnavailable"; + case LiteWalletGatewayAvailability::BridgeCallsDisabled: return "BridgeCallsDisabled"; + case LiteWalletGatewayAvailability::NoUsableServer: return "NoUsableServer"; + } + return "Unknown"; +} + +std::vector liteWalletRefreshCommands(const LiteWalletRefreshRequest& request) +{ + std::vector commands; + if (request.includeInfo) commands.push_back(LiteWalletGatewayCommand::Info); + if (request.includeHeight) commands.push_back(LiteWalletGatewayCommand::Height); + if (request.includeBalance) commands.push_back(LiteWalletGatewayCommand::Balance); + if (request.includeAddresses) commands.push_back(LiteWalletGatewayCommand::Addresses); + if (request.includeNotes) commands.push_back(LiteWalletGatewayCommand::Notes); + if (request.includeTransactions) commands.push_back(LiteWalletGatewayCommand::List); + return commands; +} + +LiteWalletRefreshBundle assembleLiteWalletRefreshBundle(const std::vector& results, + const LiteWalletRefreshRequest& request) +{ + LiteWalletRefreshBundle bundle; + if (request.haveSyncStatus) { + bundle.hasSyncStatus = true; + bundle.syncStatus = request.syncStatus; + } + + for (const auto& result : results) { + if (!result.ok) continue; + ++bundle.successfulCommandCount; + switch (result.plan.command) { + case LiteWalletGatewayCommand::Info: + bundle.hasInfo = true; + bundle.info = result.info; + break; + case LiteWalletGatewayCommand::Height: + bundle.hasHeight = true; + bundle.height = result.height; + break; + case LiteWalletGatewayCommand::Balance: + bundle.hasBalance = true; + bundle.balance = result.balance; + break; + case LiteWalletGatewayCommand::Addresses: + bundle.hasAddresses = true; + bundle.addresses = result.addresses; + break; + case LiteWalletGatewayCommand::Notes: + bundle.hasNotes = true; + bundle.notes = result.notes; + break; + case LiteWalletGatewayCommand::List: + bundle.hasTransactions = true; + bundle.transactions = result.transactions; + break; + } + } + + const auto expectedCommands = liteWalletRefreshCommands(request); + bundle.complete = bundle.successfulCommandCount == expectedCommands.size(); + return bundle; +} + +LiteWalletGateway::LiteWalletGateway(WalletCapabilities capabilities, + LiteConnectionSettings connectionSettings, + LiteClientBridge bridge, + LiteWalletGatewayOptions options) + : capabilities_(capabilities), + connectionSettings_(std::move(connectionSettings)), + bridge_(std::move(bridge)), + options_(options) +{ +} + +LiteWalletGatewayAvailability LiteWalletGateway::availability() const +{ + if (!isLiteBuild(capabilities_)) return LiteWalletGatewayAvailability::UnsupportedBuild; + if (!supportsLiteBackend(capabilities_)) return LiteWalletGatewayAvailability::BackendUnavailable; + if (!bridge_.available()) return LiteWalletGatewayAvailability::BridgeUnavailable; + if (!selectLiteServer(connectionSettings_).ok) return LiteWalletGatewayAvailability::NoUsableServer; + if (!options_.allowBridgeCalls) return LiteWalletGatewayAvailability::BridgeCallsDisabled; + return LiteWalletGatewayAvailability::Ready; +} + +WalletBackendStatus LiteWalletGateway::status() const +{ + const auto currentAvailability = availability(); + if (currentAvailability == LiteWalletGatewayAvailability::NoUsableServer) { + return statusFor(currentAvailability, selectLiteServer(connectionSettings_).error); + } + return statusFor(currentAvailability); +} + +LiteWalletGatewayPlan LiteWalletGateway::planCommand(const LiteWalletGatewayRequest& request) const +{ + LiteWalletGatewayPlan plan; + plan.command = request.command; + plan.commandName = liteWalletGatewayCommandName(request.command); + plan.bridgeExecutionAllowed = options_.allowBridgeCalls; + + auto selection = selectServerForRequest(request.serverUrl); + if (!selection.ok) { + plan.error = selection.error; + return plan; + } + + plan.ok = true; + plan.server = selection.server; + plan.serverIndex = selection.serverIndex; + plan.customServer = selection.customServer; + return plan; +} + +LiteWalletRefreshPlan LiteWalletGateway::planRefresh(const LiteWalletRefreshRequest& request) const +{ + LiteWalletRefreshPlan plan; + const auto commands = liteWalletRefreshCommands(request); + if (commands.empty()) { + plan.error = "lite refresh request has no commands"; + return plan; + } + + for (const auto command : commands) { + const auto commandPlan = planCommand(LiteWalletGatewayRequest{command, request.serverUrl}); + if (!commandPlan.ok) { + plan.error = commandPlan.error; + return plan; + } + plan.commands.push_back(commandPlan); + } + + plan.ok = true; + return plan; +} + +LiteWalletGatewayCommandResult LiteWalletGateway::fetchCommand(const LiteWalletGatewayRequest& request) +{ + const auto plan = planCommand(request); + if (!plan.ok) return blockedCommandResult(plan, makeGatewayStatus(WalletBackendState::Error, plan.error)); + if (availability() != LiteWalletGatewayAvailability::Ready) return blockedCommandResult(plan, status()); + return executePlannedCommand(plan); +} + +LiteWalletRefreshResult LiteWalletGateway::refresh(const LiteWalletRefreshRequest& request) +{ + LiteWalletRefreshResult result; + result.plan = planRefresh(request); + if (!result.plan.ok) { + result.status = makeGatewayStatus(WalletBackendState::Error, result.plan.error); + result.error = result.status.message; + return result; + } + + if (availability() != LiteWalletGatewayAvailability::Ready) { + result.status = status(); + result.error = result.status.message; + return result; + } + + result.attempted = true; + for (const auto& commandPlan : result.plan.commands) { + auto commandResult = executePlannedCommand(commandPlan); + if (!commandResult.ok) { + result.status = commandResult.status; + result.error = commandResult.error; + result.commandResults.push_back(std::move(commandResult)); + return result; + } + result.commandResults.push_back(std::move(commandResult)); + } + + result.bundle = assembleLiteWalletRefreshBundle(result.commandResults, request); + result.ok = result.bundle.complete; + result.status = refreshStatusForRequest(request); + if (!result.ok) { + result.status = makeGatewayStatus(WalletBackendState::Error, "lite refresh bundle is incomplete"); + result.error = result.status.message; + } + return result; +} + +LiteServerSelectionResult LiteWalletGateway::selectServerForRequest(const std::string& serverUrl) const +{ + const auto overrideUrl = trimGatewayCopy(serverUrl); + if (!overrideUrl.empty()) { + if (!isLiteServerUrlUsable(overrideUrl)) { + return LiteServerSelectionResult{false, {}, 0, false, "lite gateway server URL is not usable"}; + } + return LiteServerSelectionResult{ + true, + LiteServerEndpoint{overrideUrl, "Request", true}, + 0, + true, + {} + }; + } + return selectLiteServer(connectionSettings_); +} + +WalletBackendStatus LiteWalletGateway::statusFor(LiteWalletGatewayAvailability availability, + const std::string& detail) const +{ + switch (availability) { + case LiteWalletGatewayAvailability::Ready: + return makeGatewayStatus( + WalletBackendState::Disconnected, + detail.empty() ? "lite wallet gateway scaffold ready; refresh execution is fake-test only" : detail); + case LiteWalletGatewayAvailability::UnsupportedBuild: + return makeGatewayStatus( + WalletBackendState::Unavailable, + "lite wallet gateway is unsupported in full-node builds"); + case LiteWalletGatewayAvailability::BackendUnavailable: + return makeGatewayStatus( + WalletBackendState::Unavailable, + "lite backend is not linked"); + case LiteWalletGatewayAvailability::BridgeUnavailable: + return makeGatewayStatus( + WalletBackendState::Unavailable, + detail.empty() ? bridge_.unavailableReason() : detail); + case LiteWalletGatewayAvailability::BridgeCallsDisabled: + return makeGatewayStatus( + WalletBackendState::Unavailable, + "lite wallet gateway bridge calls are disabled"); + case LiteWalletGatewayAvailability::NoUsableServer: + return makeGatewayStatus( + WalletBackendState::Error, + detail.empty() ? "no usable lite servers are configured" : detail); + } + + return makeGatewayStatus(WalletBackendState::Unavailable, "unknown lite wallet gateway state"); +} + +LiteWalletGatewayCommandResult LiteWalletGateway::blockedCommandResult( + const LiteWalletGatewayPlan& plan, + const WalletBackendStatus& blockedStatus) const +{ + LiteWalletGatewayCommandResult result; + result.plan = plan; + result.status = blockedStatus; + result.error = blockedStatus.message; + return result; +} + +LiteWalletGatewayCommandResult LiteWalletGateway::executePlannedCommand(const LiteWalletGatewayPlan& plan) +{ + LiteWalletGatewayCommandResult result; + result.plan = plan; + result.attempted = true; + + const auto bridgeCall = bridge_.execute(plan.commandName, plan.args); + result.bridgeResponseRedacted = bridgeCall.ok || !bridgeCall.error.empty() ? "" : ""; + if (!bridgeCall.ok) { + result.status = makeGatewayStatus(WalletBackendState::Error, "lite wallet gateway bridge call failed"); + result.error = result.status.message; + return result; + } + + return parseBridgeResponse(plan, bridgeCall.value); +} + +LiteWalletGatewayCommandResult LiteWalletGateway::parseBridgeResponse( + const LiteWalletGatewayPlan& plan, + const std::string& response) const +{ + auto result = parsedCommandResult(plan); + + switch (plan.command) { + case LiteWalletGatewayCommand::Info: { + const auto parsed = parseLiteInfoResponse(response); + if (!parsed.ok) { + result.ok = false; + result.parserError = parsed.error; + break; + } + result.info = parsed.info; + return result; + } + case LiteWalletGatewayCommand::Height: { + const auto parsed = parseLiteHeightResponse(response); + if (!parsed.ok) { + result.ok = false; + result.parserError = parsed.error; + break; + } + result.height = parsed.height; + return result; + } + case LiteWalletGatewayCommand::Balance: { + const auto parsed = parseLiteBalanceResponse(response); + if (!parsed.ok) { + result.ok = false; + result.parserError = parsed.error; + break; + } + result.balance = parsed.balance; + return result; + } + case LiteWalletGatewayCommand::Addresses: { + const auto parsed = parseLiteAddressesResponse(response); + if (!parsed.ok) { + result.ok = false; + result.parserError = parsed.error; + break; + } + result.addresses = parsed.addresses; + return result; + } + case LiteWalletGatewayCommand::Notes: { + const auto parsed = parseLiteNotesResponse(response); + if (!parsed.ok) { + result.ok = false; + result.parserError = parsed.error; + break; + } + result.notes = parsed.notes; + return result; + } + case LiteWalletGatewayCommand::List: { + const auto parsed = parseLiteTransactionsResponse(response); + if (!parsed.ok) { + result.ok = false; + result.parserError = parsed.error; + break; + } + result.transactions = parsed.transactions; + return result; + } + } + + result.bridgeAccepted = true; + result.status = makeGatewayStatus(WalletBackendState::Error, "lite wallet gateway response could not be parsed"); + result.error = result.status.message; + result.bridgeResponseRedacted = ""; + return result; +} + +} // namespace dragonx::wallet \ No newline at end of file diff --git a/src/wallet/lite_wallet_gateway.h b/src/wallet/lite_wallet_gateway.h new file mode 100644 index 0000000..38ff88c --- /dev/null +++ b/src/wallet/lite_wallet_gateway.h @@ -0,0 +1,163 @@ +#pragma once + +#include "lite_client_bridge.h" +#include "lite_connection_service.h" +#include "lite_result_parsers.h" +#include "lite_sync_service.h" +#include "wallet_backend.h" +#include "wallet_capabilities.h" + +#include +#include +#include + +namespace dragonx::wallet { + +enum class LiteWalletGatewayCommand { + Info, + Height, + Balance, + Addresses, + Notes, + List, +}; + +enum class LiteWalletGatewayAvailability { + Ready, + UnsupportedBuild, + BackendUnavailable, + BridgeUnavailable, + BridgeCallsDisabled, + NoUsableServer, +}; + +struct LiteWalletGatewayRequest { + LiteWalletGatewayCommand command = LiteWalletGatewayCommand::Info; + std::string serverUrl; +}; + +struct LiteWalletGatewayPlan { + bool ok = false; + LiteWalletGatewayCommand command = LiteWalletGatewayCommand::Info; + LiteServerEndpoint server; + std::size_t serverIndex = 0; + bool customServer = false; + bool bridgeExecutionAllowed = false; + std::string commandName; + std::string args; + std::string error; +}; + +struct LiteWalletGatewayCommandResult { + bool ok = false; + bool attempted = false; + bool bridgeAccepted = false; + LiteWalletGatewayPlan plan; + LiteResultParserError parserError = LiteResultParserError::None; + WalletBackendStatus status; + std::string bridgeResponseRedacted = ""; + std::string error; + + LiteInfoResponse info; + LiteHeightResponse height; + LiteBalanceResponse balance; + LiteAddressesResponse addresses; + LiteNotesResponse notes; + LiteTransactionsResponse transactions; +}; + +struct LiteWalletRefreshRequest { + std::string serverUrl; + bool includeInfo = true; + bool includeHeight = true; + bool includeBalance = true; + bool includeAddresses = true; + bool includeNotes = true; + bool includeTransactions = true; + bool haveSyncStatus = false; + LiteSyncStatusResponse syncStatus; +}; + +struct LiteWalletRefreshPlan { + bool ok = false; + std::vector commands; + std::string error; +}; + +struct LiteWalletRefreshBundle { + bool hasInfo = false; + bool hasHeight = false; + bool hasBalance = false; + bool hasAddresses = false; + bool hasNotes = false; + bool hasTransactions = false; + bool hasSyncStatus = false; + bool complete = false; + std::size_t successfulCommandCount = 0; + + LiteInfoResponse info; + LiteHeightResponse height; + LiteBalanceResponse balance; + LiteAddressesResponse addresses; + LiteNotesResponse notes; + LiteTransactionsResponse transactions; + LiteSyncStatusResponse syncStatus; +}; + +struct LiteWalletRefreshResult { + bool ok = false; + bool attempted = false; + LiteWalletRefreshPlan plan; + std::vector commandResults; + LiteWalletRefreshBundle bundle; + WalletBackendStatus status; + std::string error; +}; + +struct LiteWalletGatewayOptions { + bool allowBridgeCalls = false; +}; + +const char* liteWalletGatewayCommandName(LiteWalletGatewayCommand command); +const char* liteWalletGatewayAvailabilityName(LiteWalletGatewayAvailability availability); + +std::vector liteWalletRefreshCommands(const LiteWalletRefreshRequest& request); +LiteWalletRefreshBundle assembleLiteWalletRefreshBundle(const std::vector& results, + const LiteWalletRefreshRequest& request); + +class LiteWalletGateway { +public: + LiteWalletGateway(WalletCapabilities capabilities, + LiteConnectionSettings connectionSettings, + LiteClientBridge bridge, + LiteWalletGatewayOptions options = {}); + + const WalletCapabilities& capabilities() const { return capabilities_; } + const LiteConnectionSettings& connectionSettings() const { return connectionSettings_; } + const LiteWalletGatewayOptions& options() const { return options_; } + + LiteWalletGatewayAvailability availability() const; + WalletBackendStatus status() const; + + LiteWalletGatewayPlan planCommand(const LiteWalletGatewayRequest& request) const; + LiteWalletRefreshPlan planRefresh(const LiteWalletRefreshRequest& request) const; + LiteWalletGatewayCommandResult fetchCommand(const LiteWalletGatewayRequest& request); + LiteWalletRefreshResult refresh(const LiteWalletRefreshRequest& request); + +private: + LiteServerSelectionResult selectServerForRequest(const std::string& serverUrl) const; + WalletBackendStatus statusFor(LiteWalletGatewayAvailability availability, + const std::string& detail = {}) const; + LiteWalletGatewayCommandResult blockedCommandResult(const LiteWalletGatewayPlan& plan, + const WalletBackendStatus& blockedStatus) const; + LiteWalletGatewayCommandResult executePlannedCommand(const LiteWalletGatewayPlan& plan); + LiteWalletGatewayCommandResult parseBridgeResponse(const LiteWalletGatewayPlan& plan, + const std::string& response) const; + + WalletCapabilities capabilities_; + LiteConnectionSettings connectionSettings_; + LiteClientBridge bridge_; + LiteWalletGatewayOptions options_; +}; + +} // namespace dragonx::wallet \ No newline at end of file diff --git a/src/wallet/lite_wallet_lifecycle_service.cpp b/src/wallet/lite_wallet_lifecycle_service.cpp new file mode 100644 index 0000000..7519979 --- /dev/null +++ b/src/wallet/lite_wallet_lifecycle_service.cpp @@ -0,0 +1,397 @@ +// DragonX Wallet - ImGui Edition +// Copyright 2024-2026 The Hush Developers +// Released under the GPLv3 + +#include "lite_wallet_lifecycle_service.h" + +#include +#include + +#include + +namespace dragonx { +namespace wallet { + +namespace { + +std::string trimLifecycleCopy(const std::string& value) +{ + auto begin = value.begin(); + while (begin != value.end() && std::isspace(static_cast(*begin))) ++begin; + + auto end = value.end(); + while (end != begin && std::isspace(static_cast(*(end - 1)))) --end; + + return std::string(begin, end); +} + +LiteRedactedPrivateData redactedField(LitePrivateDataKind kind, const std::string& value) +{ + return LiteRedactedPrivateData{kind, !value.empty(), redactLitePrivateDataValue(value)}; +} + +std::vector createPrivateData(const LiteWalletCreateRequest& request) +{ + return {redactedField(LitePrivateDataKind::Passphrase, request.passphrase)}; +} + +std::vector openPrivateData(const LiteWalletOpenRequest& request) +{ + return { + redactedField(LitePrivateDataKind::WalletPath, request.walletPath), + redactedField(LitePrivateDataKind::Passphrase, request.passphrase) + }; +} + +std::vector restorePrivateData(const LiteWalletRestoreRequest& request) +{ + return { + redactedField(LitePrivateDataKind::SeedPhrase, request.seedPhrase), + redactedField(LitePrivateDataKind::WalletPath, request.walletPath), + redactedField(LitePrivateDataKind::Passphrase, request.passphrase) + }; +} + +WalletBackendStatus lifecycleCompletedStatus() +{ + return WalletBackendStatus{ + WalletBackendState::Disconnected, + "lite wallet lifecycle bridge call completed; sync is not implemented", + {}, + {}, + 0.0 + }; +} + +} // namespace + +const char* liteWalletLifecycleOperationName(LiteWalletLifecycleOperation operation) +{ + switch (operation) { + case LiteWalletLifecycleOperation::CreateNew: + return "CreateNew"; + case LiteWalletLifecycleOperation::OpenExisting: + return "OpenExisting"; + case LiteWalletLifecycleOperation::RestoreFromSeed: + return "RestoreFromSeed"; + } + return "Unknown"; +} + +const char* liteWalletLifecycleAvailabilityName(LiteWalletLifecycleAvailability availability) +{ + switch (availability) { + case LiteWalletLifecycleAvailability::Ready: + return "Ready"; + case LiteWalletLifecycleAvailability::UnsupportedBuild: + return "UnsupportedBuild"; + case LiteWalletLifecycleAvailability::BackendUnavailable: + return "BackendUnavailable"; + case LiteWalletLifecycleAvailability::BridgeUnavailable: + return "BridgeUnavailable"; + case LiteWalletLifecycleAvailability::BridgeCallsDisabled: + return "BridgeCallsDisabled"; + case LiteWalletLifecycleAvailability::NoUsableServer: + return "NoUsableServer"; + } + return "Unknown"; +} + +const char* litePrivateDataKindName(LitePrivateDataKind kind) +{ + switch (kind) { + case LitePrivateDataKind::SeedPhrase: + return "SeedPhrase"; + case LitePrivateDataKind::Passphrase: + return "Passphrase"; + case LitePrivateDataKind::WalletPath: + return "WalletPath"; + case LitePrivateDataKind::BridgeResponse: + return "BridgeResponse"; + } + return "Unknown"; +} + +std::string redactLitePrivateDataValue(const std::string& value) +{ + return value.empty() ? "" : ""; +} + +LiteWalletLifecycleService::LiteWalletLifecycleService(WalletCapabilities capabilities, + LiteConnectionSettings connectionSettings, + LiteClientBridge bridge, + LiteWalletLifecycleOptions options) + : capabilities_(capabilities), + connectionSettings_(std::move(connectionSettings)), + bridge_(std::move(bridge)), + options_(options) +{ +} + +LiteWalletLifecycleAvailability LiteWalletLifecycleService::availability() const +{ + if (!isLiteBuild(capabilities_)) return LiteWalletLifecycleAvailability::UnsupportedBuild; + if (!supportsLiteBackend(capabilities_)) return LiteWalletLifecycleAvailability::BackendUnavailable; + if (!bridge_.available()) return LiteWalletLifecycleAvailability::BridgeUnavailable; + if (!selectLiteServer(connectionSettings_).ok) return LiteWalletLifecycleAvailability::NoUsableServer; + if (!options_.allowBridgeCalls) return LiteWalletLifecycleAvailability::BridgeCallsDisabled; + return LiteWalletLifecycleAvailability::Ready; +} + +WalletBackendStatus LiteWalletLifecycleService::status() const +{ + const auto currentAvailability = availability(); + if (currentAvailability == LiteWalletLifecycleAvailability::NoUsableServer) { + return statusFor(currentAvailability, selectLiteServer(connectionSettings_).error); + } + return statusFor(currentAvailability); +} + +LiteWalletLifecyclePlan LiteWalletLifecycleService::planCreateWallet( + const LiteWalletCreateRequest& request) const +{ + return makePlan(LiteWalletLifecycleOperation::CreateNew, + request.serverUrl, + createPrivateData(request)); +} + +LiteWalletLifecyclePlan LiteWalletLifecycleService::planOpenWallet( + const LiteWalletOpenRequest& request) const +{ + return makePlan(LiteWalletLifecycleOperation::OpenExisting, + request.serverUrl, + openPrivateData(request)); +} + +LiteWalletLifecyclePlan LiteWalletLifecycleService::planRestoreWallet( + const LiteWalletRestoreRequest& request) const +{ + const std::string validationError = trimLifecycleCopy(request.seedPhrase).empty() + ? "restore seed phrase is required" + : std::string(); + return makePlan(LiteWalletLifecycleOperation::RestoreFromSeed, + request.serverUrl, + restorePrivateData(request), + validationError); +} + +LiteWalletLifecycleResult LiteWalletLifecycleService::createWallet( + const LiteWalletCreateRequest& request) +{ + const auto plan = planCreateWallet(request); + if (!plan.ok) return blockedResult(plan, WalletBackendStatus{WalletBackendState::Error, plan.error, {}, {}, 0.0}); + + const auto currentStatus = status(); + if (availability() != LiteWalletLifecycleAvailability::Ready) return blockedResult(plan, currentStatus); + + return executeCreate(request, plan); +} + +LiteWalletLifecycleResult LiteWalletLifecycleService::openWallet( + const LiteWalletOpenRequest& request) +{ + const auto plan = planOpenWallet(request); + if (!plan.ok) return blockedResult(plan, WalletBackendStatus{WalletBackendState::Error, plan.error, {}, {}, 0.0}); + + const auto currentStatus = status(); + if (availability() != LiteWalletLifecycleAvailability::Ready) return blockedResult(plan, currentStatus); + + return executeOpen(request, plan); +} + +LiteWalletLifecycleResult LiteWalletLifecycleService::restoreWallet( + const LiteWalletRestoreRequest& request) +{ + const auto plan = planRestoreWallet(request); + if (!plan.ok) return blockedResult(plan, WalletBackendStatus{WalletBackendState::Error, plan.error, {}, {}, 0.0}); + + const auto currentStatus = status(); + if (availability() != LiteWalletLifecycleAvailability::Ready) return blockedResult(plan, currentStatus); + + return executeRestore(request, plan); +} + +LiteServerSelectionResult LiteWalletLifecycleService::selectServerForRequest( + const std::string& serverUrl) const +{ + const std::string overrideUrl = trimLifecycleCopy(serverUrl); + if (!overrideUrl.empty()) { + if (!isLiteServerUrlUsable(overrideUrl)) { + return LiteServerSelectionResult{false, {}, 0, false, "lite lifecycle server URL is not usable"}; + } + return LiteServerSelectionResult{ + true, + LiteServerEndpoint{overrideUrl, "Request", true}, + 0, + true, + {} + }; + } + return selectLiteServer(connectionSettings_); +} + +LiteWalletLifecyclePlan LiteWalletLifecycleService::makePlan( + LiteWalletLifecycleOperation operation, + const std::string& serverUrl, + std::vector privateData, + const std::string& validationError) const +{ + LiteWalletLifecyclePlan plan; + plan.operation = operation; + plan.privateData = std::move(privateData); + plan.bridgeExecutionAllowed = options_.allowBridgeCalls; + + if (!validationError.empty()) { + plan.error = validationError; + return plan; + } + + auto selection = selectServerForRequest(serverUrl); + if (!selection.ok) { + plan.error = selection.error; + return plan; + } + + plan.ok = true; + plan.server = selection.server; + plan.serverIndex = selection.serverIndex; + plan.customServer = selection.customServer; + return plan; +} + +WalletBackendStatus LiteWalletLifecycleService::statusFor( + LiteWalletLifecycleAvailability availability, + const std::string& detail) const +{ + switch (availability) { + case LiteWalletLifecycleAvailability::Ready: + return WalletBackendStatus{ + WalletBackendState::Disconnected, + detail.empty() ? "lite wallet lifecycle scaffold ready; sync is not implemented" : detail, + {}, + {}, + 0.0 + }; + case LiteWalletLifecycleAvailability::UnsupportedBuild: + return WalletBackendStatus{ + WalletBackendState::Unavailable, + "lite wallet lifecycle is unsupported in full-node builds", + {}, + {}, + 0.0 + }; + case LiteWalletLifecycleAvailability::BackendUnavailable: + return WalletBackendStatus{ + WalletBackendState::Unavailable, + "lite backend is not linked", + {}, + {}, + 0.0 + }; + case LiteWalletLifecycleAvailability::BridgeUnavailable: + return WalletBackendStatus{ + WalletBackendState::Unavailable, + detail.empty() ? bridge_.unavailableReason() : detail, + {}, + {}, + 0.0 + }; + case LiteWalletLifecycleAvailability::BridgeCallsDisabled: + return WalletBackendStatus{ + WalletBackendState::Unavailable, + "lite wallet lifecycle bridge calls are disabled", + {}, + {}, + 0.0 + }; + case LiteWalletLifecycleAvailability::NoUsableServer: + return WalletBackendStatus{ + WalletBackendState::Error, + detail.empty() ? "no usable lite servers are configured" : detail, + {}, + {}, + 0.0 + }; + } + + return WalletBackendStatus{WalletBackendState::Unavailable, "unknown lite wallet lifecycle state", {}, {}, 0.0}; +} + +LiteWalletLifecycleResult LiteWalletLifecycleService::executeCreate( + const LiteWalletCreateRequest& request, + const LiteWalletLifecyclePlan& plan) +{ + auto bridgeCall = bridge_.initializeNew(request.dangerous, plan.server.url); + return bridgeResult(plan, lifecycleCompletedStatus(), bridgeCall); +} + +LiteWalletLifecycleResult LiteWalletLifecycleService::executeOpen( + const LiteWalletOpenRequest& request, + const LiteWalletLifecyclePlan& plan) +{ + auto bridgeCall = bridge_.initializeExisting(request.dangerous, plan.server.url); + return bridgeResult(plan, lifecycleCompletedStatus(), bridgeCall); +} + +LiteWalletLifecycleResult LiteWalletLifecycleService::executeRestore( + const LiteWalletRestoreRequest& request, + const LiteWalletLifecyclePlan& plan) +{ + auto bridgeCall = bridge_.initializeNewFromPhrase( + request.dangerous, + plan.server.url, + request.seedPhrase, + request.birthday, + request.account, + request.overwrite); + return bridgeResult(plan, lifecycleCompletedStatus(), bridgeCall); +} + +LiteWalletLifecycleResult LiteWalletLifecycleService::blockedResult( + const LiteWalletLifecyclePlan& plan, + const WalletBackendStatus& blockedStatus) const +{ + LiteWalletLifecycleResult result; + result.operation = plan.operation; + result.plan = plan; + result.status = blockedStatus; + result.error = blockedStatus.message; + return result; +} + +LiteWalletLifecycleResult LiteWalletLifecycleService::bridgeResult( + const LiteWalletLifecyclePlan& plan, + const WalletBackendStatus& successStatus, + const LiteBridgeStringResult& bridgeCall) const +{ + LiteWalletLifecycleResult result; + result.operation = plan.operation; + result.plan = plan; + result.attempted = true; + result.bridgeResponseRedacted = redactLitePrivateDataValue(bridgeCall.ok ? bridgeCall.value : bridgeCall.error); + + if (!bridgeCall.ok) { + result.status = WalletBackendStatus{ + WalletBackendState::Error, + "lite wallet lifecycle bridge call failed", + {}, + {}, + 0.0 + }; + result.error = result.status.message; + return result; + } + + result.ok = true; + result.bridgeAccepted = true; + // The bridge already classifies "Error:"-prefixed responses as failures (ok=false). + // A successful init returns a JSON document (seed info for create, wallet info for + // open/restore); treat a well-formed JSON response as a genuinely ready wallet rather + // than discarding it. (Richer field extraction lands with the sync slice.) + result.walletReady = nlohmann::json::accept(bridgeCall.value); + result.status = successStatus; + return result; +} + +} // namespace wallet +} // namespace dragonx \ No newline at end of file diff --git a/src/wallet/lite_wallet_lifecycle_service.h b/src/wallet/lite_wallet_lifecycle_service.h new file mode 100644 index 0000000..b7dfaa1 --- /dev/null +++ b/src/wallet/lite_wallet_lifecycle_service.h @@ -0,0 +1,152 @@ +// DragonX Wallet - ImGui Edition +// Copyright 2024-2026 The Hush Developers +// Released under the GPLv3 + +#pragma once + +#include "lite_client_bridge.h" +#include "lite_connection_service.h" +#include "wallet_backend.h" +#include "wallet_capabilities.h" + +#include +#include +#include + +namespace dragonx { +namespace wallet { + +enum class LiteWalletLifecycleOperation { + CreateNew, + OpenExisting, + RestoreFromSeed +}; + +enum class LiteWalletLifecycleAvailability { + Ready, + UnsupportedBuild, + BackendUnavailable, + BridgeUnavailable, + BridgeCallsDisabled, + NoUsableServer +}; + +enum class LitePrivateDataKind { + SeedPhrase, + Passphrase, + WalletPath, + BridgeResponse +}; + +struct LiteRedactedPrivateData { + LitePrivateDataKind kind = LitePrivateDataKind::SeedPhrase; + bool present = false; + std::string redactedValue = ""; +}; + +struct LiteWalletCreateRequest { + bool dangerous = false; + std::string serverUrl; + std::string passphrase; +}; + +struct LiteWalletOpenRequest { + bool dangerous = false; + std::string serverUrl; + std::string walletPath; + std::string passphrase; +}; + +struct LiteWalletRestoreRequest { + bool dangerous = false; + std::string serverUrl; + std::string seedPhrase; + unsigned long long birthday = 0; + unsigned long long account = 0; + bool overwrite = false; + std::string walletPath; + std::string passphrase; +}; + +struct LiteWalletLifecyclePlan { + bool ok = false; + LiteWalletLifecycleOperation operation = LiteWalletLifecycleOperation::CreateNew; + LiteServerEndpoint server; + std::size_t serverIndex = 0; + bool customServer = false; + bool bridgeExecutionAllowed = false; + std::vector privateData; + std::string error; +}; + +struct LiteWalletLifecycleResult { + bool ok = false; + bool attempted = false; + bool bridgeAccepted = false; + bool walletReady = false; + LiteWalletLifecycleOperation operation = LiteWalletLifecycleOperation::CreateNew; + LiteWalletLifecyclePlan plan; + WalletBackendStatus status; + std::string bridgeResponseRedacted = ""; + std::string error; +}; + +struct LiteWalletLifecycleOptions { + bool allowBridgeCalls = false; +}; + +const char* liteWalletLifecycleOperationName(LiteWalletLifecycleOperation operation); +const char* liteWalletLifecycleAvailabilityName(LiteWalletLifecycleAvailability availability); +const char* litePrivateDataKindName(LitePrivateDataKind kind); +std::string redactLitePrivateDataValue(const std::string& value); + +class LiteWalletLifecycleService { +public: + LiteWalletLifecycleService(WalletCapabilities capabilities, + LiteConnectionSettings connectionSettings, + LiteClientBridge bridge, + LiteWalletLifecycleOptions options = {}); + + const LiteConnectionSettings& connectionSettings() const { return connectionSettings_; } + const WalletCapabilities& capabilities() const { return capabilities_; } + const LiteWalletLifecycleOptions& options() const { return options_; } + + LiteWalletLifecycleAvailability availability() const; + WalletBackendStatus status() const; + + LiteWalletLifecyclePlan planCreateWallet(const LiteWalletCreateRequest& request) const; + LiteWalletLifecyclePlan planOpenWallet(const LiteWalletOpenRequest& request) const; + LiteWalletLifecyclePlan planRestoreWallet(const LiteWalletRestoreRequest& request) const; + + LiteWalletLifecycleResult createWallet(const LiteWalletCreateRequest& request); + LiteWalletLifecycleResult openWallet(const LiteWalletOpenRequest& request); + LiteWalletLifecycleResult restoreWallet(const LiteWalletRestoreRequest& request); + +private: + LiteServerSelectionResult selectServerForRequest(const std::string& serverUrl) const; + LiteWalletLifecyclePlan makePlan(LiteWalletLifecycleOperation operation, + const std::string& serverUrl, + std::vector privateData, + const std::string& validationError = {}) const; + WalletBackendStatus statusFor(LiteWalletLifecycleAvailability availability, + const std::string& detail = {}) const; + LiteWalletLifecycleResult executeCreate(const LiteWalletCreateRequest& request, + const LiteWalletLifecyclePlan& plan); + LiteWalletLifecycleResult executeOpen(const LiteWalletOpenRequest& request, + const LiteWalletLifecyclePlan& plan); + LiteWalletLifecycleResult executeRestore(const LiteWalletRestoreRequest& request, + const LiteWalletLifecyclePlan& plan); + LiteWalletLifecycleResult blockedResult(const LiteWalletLifecyclePlan& plan, + const WalletBackendStatus& blockedStatus) const; + LiteWalletLifecycleResult bridgeResult(const LiteWalletLifecyclePlan& plan, + const WalletBackendStatus& successStatus, + const LiteBridgeStringResult& bridgeCall) const; + + WalletCapabilities capabilities_; + LiteConnectionSettings connectionSettings_; + LiteClientBridge bridge_; + LiteWalletLifecycleOptions options_; +}; + +} // namespace wallet +} // namespace dragonx \ No newline at end of file diff --git a/src/wallet/lite_wallet_lifecycle_ui_adapter.cpp b/src/wallet/lite_wallet_lifecycle_ui_adapter.cpp new file mode 100644 index 0000000..3306f88 --- /dev/null +++ b/src/wallet/lite_wallet_lifecycle_ui_adapter.cpp @@ -0,0 +1,440 @@ +#include "lite_wallet_lifecycle_ui_adapter.h" + +#include +#include + +namespace dragonx { +namespace wallet { + +namespace { + +void addIssue(std::vector& issues, + LiteWalletLifecycleUiExecutionIssue issue, + std::string message) +{ + issues.push_back(LiteWalletLifecycleUiExecutionIssueInfo{issue, std::move(message)}); +} + +LiteWalletLifecycleUiExecutionResult stoppedResult( + LiteWalletLifecycleUiExecutionResult result, + LiteWalletLifecycleUiExecutionStatus status, + LiteWalletLifecycleUiExecutionIssue issue, + const std::string& message) +{ + result.status = status; + result.error = message; + result.ok = false; + addIssue(result.issues, issue, message); + return result; +} + +LiteWalletLifecycleUiExecutionStatus statusFromServerSelection( + LiteWalletServerSelectionUiExecutionStatus status) +{ + switch (status) { + case LiteWalletServerSelectionUiExecutionStatus::ReadyForFutureLifecycle: + return LiteWalletLifecycleUiExecutionStatus::ReadyForFutureLifecycleRequest; + case LiteWalletServerSelectionUiExecutionStatus::WaitingForLiteBuild: + return LiteWalletLifecycleUiExecutionStatus::WaitingForLiteBuild; + case LiteWalletServerSelectionUiExecutionStatus::WaitingForBackendCapability: + return LiteWalletLifecycleUiExecutionStatus::WaitingForBackendCapability; + case LiteWalletServerSelectionUiExecutionStatus::WaitingForSettings: + return LiteWalletLifecycleUiExecutionStatus::WaitingForSettings; + case LiteWalletServerSelectionUiExecutionStatus::WaitingForServerSelection: + return LiteWalletLifecycleUiExecutionStatus::WaitingForServerSelection; + case LiteWalletServerSelectionUiExecutionStatus::WaitingForPersistenceOwner: + return LiteWalletLifecycleUiExecutionStatus::WaitingForPersistedServerSelection; + case LiteWalletServerSelectionUiExecutionStatus::WaitingForDisplayStatus: + return LiteWalletLifecycleUiExecutionStatus::WaitingForDisplayStatus; + case LiteWalletServerSelectionUiExecutionStatus::WaitingForLifecycleUi: + return LiteWalletLifecycleUiExecutionStatus::WaitingForLifecycleUi; + case LiteWalletServerSelectionUiExecutionStatus::WaitingForPrivateDataRedaction: + return LiteWalletLifecycleUiExecutionStatus::WaitingForPrivateDataRedaction; + case LiteWalletServerSelectionUiExecutionStatus::WaitingForSyncPlannerFeed: + return LiteWalletLifecycleUiExecutionStatus::WaitingForSyncPlannerFeed; + case LiteWalletServerSelectionUiExecutionStatus::SettingsSaveFailed: + return LiteWalletLifecycleUiExecutionStatus::WaitingForSettings; + case LiteWalletServerSelectionUiExecutionStatus::RuntimeExecutionDisabled: + return LiteWalletLifecycleUiExecutionStatus::RuntimeExecutionDisabled; + } + return LiteWalletLifecycleUiExecutionStatus::WaitingForSettings; +} + +LiteWalletLifecycleUiExecutionStatus statusFromLifecycle( + LiteWalletServerLifecycleReadinessStatus status) +{ + switch (status) { + case LiteWalletServerLifecycleReadinessStatus::ReadyForFutureLifecycle: + return LiteWalletLifecycleUiExecutionStatus::ReadyForFutureLifecycleRequest; + case LiteWalletServerLifecycleReadinessStatus::WaitingForLiteBuild: + return LiteWalletLifecycleUiExecutionStatus::WaitingForLiteBuild; + case LiteWalletServerLifecycleReadinessStatus::WaitingForBackendCapability: + return LiteWalletLifecycleUiExecutionStatus::WaitingForBackendCapability; + case LiteWalletServerLifecycleReadinessStatus::WaitingForServerSelection: + return LiteWalletLifecycleUiExecutionStatus::WaitingForServerSelection; + case LiteWalletServerLifecycleReadinessStatus::WaitingForPersistenceIntent: + return LiteWalletLifecycleUiExecutionStatus::WaitingForPersistedServerSelection; + case LiteWalletServerLifecycleReadinessStatus::WaitingForDisplayStatus: + return LiteWalletLifecycleUiExecutionStatus::WaitingForDisplayStatus; + case LiteWalletServerLifecycleReadinessStatus::WaitingForLifecycleUi: + return LiteWalletLifecycleUiExecutionStatus::WaitingForLifecycleUi; + case LiteWalletServerLifecycleReadinessStatus::WaitingForPrivateDataRedaction: + return LiteWalletLifecycleUiExecutionStatus::WaitingForPrivateDataRedaction; + case LiteWalletServerLifecycleReadinessStatus::WaitingForSyncPlannerFeed: + return LiteWalletLifecycleUiExecutionStatus::WaitingForSyncPlannerFeed; + case LiteWalletServerLifecycleReadinessStatus::RuntimeExecutionDisabled: + return LiteWalletLifecycleUiExecutionStatus::RuntimeExecutionDisabled; + } + return LiteWalletLifecycleUiExecutionStatus::WaitingForSettings; +} + +LiteWalletLifecycleUiExecutionIssue issueFromLifecycle( + LiteWalletServerLifecycleReadinessIssue issue) +{ + switch (issue) { + case LiteWalletServerLifecycleReadinessIssue::FullNodeBuild: + return LiteWalletLifecycleUiExecutionIssue::FullNodeBuild; + case LiteWalletServerLifecycleReadinessIssue::LiteBackendCapabilityMissing: + return LiteWalletLifecycleUiExecutionIssue::LiteBackendCapabilityMissing; + case LiteWalletServerLifecycleReadinessIssue::PersistedSettingsNotLoaded: + return LiteWalletLifecycleUiExecutionIssue::SettingsNotLoaded; + case LiteWalletServerLifecycleReadinessIssue::PersistedServerSelectionIntentMissing: + return LiteWalletLifecycleUiExecutionIssue::PersistedServerSelectionIntentMissing; + case LiteWalletServerLifecycleReadinessIssue::ServerSelectionMissing: + return LiteWalletLifecycleUiExecutionIssue::ServerSelectionMissing; + case LiteWalletServerLifecycleReadinessIssue::ServerPersistenceOwnerMissing: + return LiteWalletLifecycleUiExecutionIssue::PersistedServerSelectionIntentMissing; + case LiteWalletServerLifecycleReadinessIssue::SelectedServerDisplayMissing: + return LiteWalletLifecycleUiExecutionIssue::SelectedServerDisplayMissing; + case LiteWalletServerLifecycleReadinessIssue::LifecycleUiOwnerMissing: + return LiteWalletLifecycleUiExecutionIssue::LifecycleUiOwnerMissing; + case LiteWalletServerLifecycleReadinessIssue::LifecycleOperationUnconfirmed: + return LiteWalletLifecycleUiExecutionIssue::LifecycleOperationUnconfirmed; + case LiteWalletServerLifecycleReadinessIssue::OpenWalletPathMissing: + return LiteWalletLifecycleUiExecutionIssue::OpenWalletPathMissing; + case LiteWalletServerLifecycleReadinessIssue::RestoreSeedMissing: + return LiteWalletLifecycleUiExecutionIssue::RestoreSeedMissing; + case LiteWalletServerLifecycleReadinessIssue::PrivateDataRedactionMissing: + return LiteWalletLifecycleUiExecutionIssue::PrivateDataRedactionMissing; + case LiteWalletServerLifecycleReadinessIssue::SyncPlannerFeedMissing: + return LiteWalletLifecycleUiExecutionIssue::SyncPlannerFeedMissing; + case LiteWalletServerLifecycleReadinessIssue::RealLifecycleExecutionRequested: + return LiteWalletLifecycleUiExecutionIssue::WalletLifecycleExecutionRequested; + } + return LiteWalletLifecycleUiExecutionIssue::SettingsNotLoaded; +} + +LiteWalletLifecycleUiExecutionIssue issueFromServerSelection( + LiteWalletServerSelectionUiExecutionIssue issue) +{ + switch (issue) { + case LiteWalletServerSelectionUiExecutionIssue::FullNodeBuild: + return LiteWalletLifecycleUiExecutionIssue::FullNodeBuild; + case LiteWalletServerSelectionUiExecutionIssue::LiteBackendCapabilityMissing: + return LiteWalletLifecycleUiExecutionIssue::LiteBackendCapabilityMissing; + case LiteWalletServerSelectionUiExecutionIssue::SettingsNotLoaded: + return LiteWalletLifecycleUiExecutionIssue::SettingsNotLoaded; + case LiteWalletServerSelectionUiExecutionIssue::ServerSelectionMissing: + return LiteWalletLifecycleUiExecutionIssue::ServerSelectionMissing; + case LiteWalletServerSelectionUiExecutionIssue::ServerPersistenceOwnerMissing: + return LiteWalletLifecycleUiExecutionIssue::PersistedServerSelectionIntentMissing; + case LiteWalletServerSelectionUiExecutionIssue::SelectedServerDisplayMissing: + return LiteWalletLifecycleUiExecutionIssue::SelectedServerDisplayMissing; + case LiteWalletServerSelectionUiExecutionIssue::LifecycleUiOwnerMissing: + return LiteWalletLifecycleUiExecutionIssue::LifecycleUiOwnerMissing; + case LiteWalletServerSelectionUiExecutionIssue::PrivateDataRedactionMissing: + return LiteWalletLifecycleUiExecutionIssue::PrivateDataRedactionMissing; + case LiteWalletServerSelectionUiExecutionIssue::SyncPlannerFeedMissing: + return LiteWalletLifecycleUiExecutionIssue::SyncPlannerFeedMissing; + case LiteWalletServerSelectionUiExecutionIssue::SettingsSaveFailed: + return LiteWalletLifecycleUiExecutionIssue::SettingsNotLoaded; + case LiteWalletServerSelectionUiExecutionIssue::ServerConnectivityCheckRequested: + return LiteWalletLifecycleUiExecutionIssue::ServerConnectivityCheckRequested; + case LiteWalletServerSelectionUiExecutionIssue::WalletLifecycleExecutionRequested: + return LiteWalletLifecycleUiExecutionIssue::WalletLifecycleExecutionRequested; + case LiteWalletServerSelectionUiExecutionIssue::SyncRequested: + return LiteWalletLifecycleUiExecutionIssue::SyncRequested; + case LiteWalletServerSelectionUiExecutionIssue::SyncStatusPollingRequested: + return LiteWalletLifecycleUiExecutionIssue::SyncStatusPollingRequested; + case LiteWalletServerSelectionUiExecutionIssue::WorkerQueueRequested: + return LiteWalletLifecycleUiExecutionIssue::WorkerQueueRequested; + case LiteWalletServerSelectionUiExecutionIssue::WalletStateMutationRequested: + return LiteWalletLifecycleUiExecutionIssue::WalletStateMutationRequested; + case LiteWalletServerSelectionUiExecutionIssue::WalletFilePersistenceRequested: + return LiteWalletLifecycleUiExecutionIssue::WalletFilePersistenceRequested; + case LiteWalletServerSelectionUiExecutionIssue::SendImportExportRequested: + return LiteWalletLifecycleUiExecutionIssue::SendImportExportRequested; + } + return LiteWalletLifecycleUiExecutionIssue::SettingsNotLoaded; +} + +void copyServerSelectionIssues(LiteWalletLifecycleUiExecutionResult& result) +{ + for (const auto& issue : result.serverSelectionReport.issues) { + addIssue(result.issues, issueFromServerSelection(issue.issue), issue.message); + } +} + +void copyLifecycleIssues(LiteWalletLifecycleUiExecutionResult& result) +{ + for (const auto& issue : result.lifecycleReadiness.issues) { + addIssue(result.issues, issueFromLifecycle(issue.issue), issue.message); + } +} + +LiteWalletServerSelectionUiExecutionInput makeServerSelectionInput( + const LiteWalletLifecycleUiExecutionInput& input, + const config::Settings& settings) +{ + LiteWalletServerSelectionUiExecutionInput selection; + selection.capabilities = input.capabilities; + selection.persistence.settingsLoaded = input.settingsLoaded; + selection.persistence.havePersistedSelectionIntent = + !input.requirePersistedServerSelectionIntent || settings.getLitePersistSelectedServer(); + selection.persistence.persistSelectedServer = false; + selection.persistence.persistenceOwnerReady = true; + selection.persistence.writeSettings = false; + selection.ui = input.ui; + selection.operation = input.request.operation; + selection.createRequest = input.request.createRequest; + selection.openRequest = input.request.openRequest; + selection.restoreRequest = input.request.restoreRequest; + selection.requireLifecycleReadiness = true; + return selection; +} + +std::string buildDiagnosticSummary(const LiteWalletLifecycleUiExecutionResult& result) +{ + std::ostringstream out; + out << "operation=" << liteWalletLifecycleOperationName(result.lifecycleInput.operation) + << ";server=" << result.selectedServerUrlRedacted + << ";request=" << result.requestSummaryRedacted + << ";network=false;bridge=false;lifecycle=false;sync=false;wallet_state=false;wallet_file=false"; + return out.str(); +} + +} // namespace + +const char* liteWalletLifecycleUiExecutionStatusName( + LiteWalletLifecycleUiExecutionStatus status) +{ + switch (status) { + case LiteWalletLifecycleUiExecutionStatus::ReadyForFutureLifecycleRequest: + return "ReadyForFutureLifecycleRequest"; + case LiteWalletLifecycleUiExecutionStatus::WaitingForLiteBuild: + return "WaitingForLiteBuild"; + case LiteWalletLifecycleUiExecutionStatus::WaitingForBackendCapability: + return "WaitingForBackendCapability"; + case LiteWalletLifecycleUiExecutionStatus::WaitingForSettings: + return "WaitingForSettings"; + case LiteWalletLifecycleUiExecutionStatus::WaitingForPersistedServerSelection: + return "WaitingForPersistedServerSelection"; + case LiteWalletLifecycleUiExecutionStatus::WaitingForServerSelection: + return "WaitingForServerSelection"; + case LiteWalletLifecycleUiExecutionStatus::WaitingForDisplayStatus: + return "WaitingForDisplayStatus"; + case LiteWalletLifecycleUiExecutionStatus::WaitingForLifecycleUi: + return "WaitingForLifecycleUi"; + case LiteWalletLifecycleUiExecutionStatus::WaitingForRequest: + return "WaitingForRequest"; + case LiteWalletLifecycleUiExecutionStatus::WaitingForPrivateDataRedaction: + return "WaitingForPrivateDataRedaction"; + case LiteWalletLifecycleUiExecutionStatus::WaitingForSyncPlannerFeed: + return "WaitingForSyncPlannerFeed"; + case LiteWalletLifecycleUiExecutionStatus::RuntimeExecutionDisabled: + return "RuntimeExecutionDisabled"; + } + return "WaitingForSettings"; +} + +const char* liteWalletLifecycleUiExecutionIssueName( + LiteWalletLifecycleUiExecutionIssue issue) +{ + switch (issue) { + case LiteWalletLifecycleUiExecutionIssue::FullNodeBuild: + return "FullNodeBuild"; + case LiteWalletLifecycleUiExecutionIssue::LiteBackendCapabilityMissing: + return "LiteBackendCapabilityMissing"; + case LiteWalletLifecycleUiExecutionIssue::SettingsNotLoaded: + return "SettingsNotLoaded"; + case LiteWalletLifecycleUiExecutionIssue::PersistedServerSelectionIntentMissing: + return "PersistedServerSelectionIntentMissing"; + case LiteWalletLifecycleUiExecutionIssue::ServerSelectionMissing: + return "ServerSelectionMissing"; + case LiteWalletLifecycleUiExecutionIssue::SelectedServerDisplayMissing: + return "SelectedServerDisplayMissing"; + case LiteWalletLifecycleUiExecutionIssue::LifecycleUiOwnerMissing: + return "LifecycleUiOwnerMissing"; + case LiteWalletLifecycleUiExecutionIssue::LifecycleOperationUnconfirmed: + return "LifecycleOperationUnconfirmed"; + case LiteWalletLifecycleUiExecutionIssue::OpenWalletPathMissing: + return "OpenWalletPathMissing"; + case LiteWalletLifecycleUiExecutionIssue::RestoreSeedMissing: + return "RestoreSeedMissing"; + case LiteWalletLifecycleUiExecutionIssue::PrivateDataRedactionMissing: + return "PrivateDataRedactionMissing"; + case LiteWalletLifecycleUiExecutionIssue::SyncPlannerFeedMissing: + return "SyncPlannerFeedMissing"; + case LiteWalletLifecycleUiExecutionIssue::ServerConnectivityCheckRequested: + return "ServerConnectivityCheckRequested"; + case LiteWalletLifecycleUiExecutionIssue::WalletExistsCheckRequested: + return "WalletExistsCheckRequested"; + case LiteWalletLifecycleUiExecutionIssue::WalletLifecycleExecutionRequested: + return "WalletLifecycleExecutionRequested"; + case LiteWalletLifecycleUiExecutionIssue::SyncRequested: + return "SyncRequested"; + case LiteWalletLifecycleUiExecutionIssue::SyncStatusPollingRequested: + return "SyncStatusPollingRequested"; + case LiteWalletLifecycleUiExecutionIssue::WorkerQueueRequested: + return "WorkerQueueRequested"; + case LiteWalletLifecycleUiExecutionIssue::WalletStateMutationRequested: + return "WalletStateMutationRequested"; + case LiteWalletLifecycleUiExecutionIssue::WalletFilePersistenceRequested: + return "WalletFilePersistenceRequested"; + case LiteWalletLifecycleUiExecutionIssue::SendImportExportRequested: + return "SendImportExportRequested"; + case LiteWalletLifecycleUiExecutionIssue::SettingsWriteRequested: + return "SettingsWriteRequested"; + } + return "SettingsNotLoaded"; +} + +LiteWalletLifecycleUiExecutionResult executeLiteWalletLifecycleUiRequest( + config::Settings& settings, + const LiteWalletLifecycleUiExecutionInput& input) +{ + LiteWalletLifecycleUiExecutionResult result; + + auto stopForRuntime = [&](LiteWalletLifecycleUiExecutionIssue issue, + const std::string& message) { + return stoppedResult(std::move(result), + LiteWalletLifecycleUiExecutionStatus::RuntimeExecutionDisabled, + issue, + message); + }; + + if (input.settingsWriteRequested) { + return stopForRuntime(LiteWalletLifecycleUiExecutionIssue::SettingsWriteRequested, + "lite lifecycle request adapter cannot write settings"); + } + if (input.serverConnectivityCheckRequested) { + return stopForRuntime(LiteWalletLifecycleUiExecutionIssue::ServerConnectivityCheckRequested, + "lite lifecycle request adapter cannot check server connectivity"); + } + if (input.walletExistsCheckRequested) { + return stopForRuntime(LiteWalletLifecycleUiExecutionIssue::WalletExistsCheckRequested, + "lite lifecycle request adapter cannot check wallet existence"); + } + if (input.walletLifecycleExecutionRequested || input.ui.realLifecycleExecutionRequested) { + return stopForRuntime(LiteWalletLifecycleUiExecutionIssue::WalletLifecycleExecutionRequested, + "lite lifecycle request adapter cannot execute wallet lifecycle actions"); + } + if (input.syncStartRequested) { + return stopForRuntime(LiteWalletLifecycleUiExecutionIssue::SyncRequested, + "lite lifecycle request adapter cannot start sync"); + } + if (input.syncStatusPollingRequested) { + return stopForRuntime(LiteWalletLifecycleUiExecutionIssue::SyncStatusPollingRequested, + "lite lifecycle request adapter cannot poll syncstatus"); + } + if (input.workerQueueEnqueueRequested) { + return stopForRuntime(LiteWalletLifecycleUiExecutionIssue::WorkerQueueRequested, + "lite lifecycle request adapter cannot enqueue wallet workers"); + } + if (input.walletStateMutationRequested) { + return stopForRuntime(LiteWalletLifecycleUiExecutionIssue::WalletStateMutationRequested, + "lite lifecycle request adapter cannot mutate WalletState"); + } + if (input.walletFilePersistenceRequested) { + return stopForRuntime(LiteWalletLifecycleUiExecutionIssue::WalletFilePersistenceRequested, + "lite lifecycle request adapter cannot persist wallet files"); + } + if (input.sendImportExportExecutionRequested) { + return stopForRuntime(LiteWalletLifecycleUiExecutionIssue::SendImportExportRequested, + "lite lifecycle request adapter cannot execute send/import/export flows"); + } + + if (!input.settingsLoaded) { + return stoppedResult(std::move(result), + LiteWalletLifecycleUiExecutionStatus::WaitingForSettings, + LiteWalletLifecycleUiExecutionIssue::SettingsNotLoaded, + "lite lifecycle settings are not loaded"); + } + if (!input.request.requestProvided) { + return stoppedResult(std::move(result), + LiteWalletLifecycleUiExecutionStatus::WaitingForRequest, + LiteWalletLifecycleUiExecutionIssue::LifecycleUiOwnerMissing, + "lite lifecycle request intent is missing"); + } + if (input.requirePersistedServerSelectionIntent && !settings.getLitePersistSelectedServer()) { + return stoppedResult(std::move(result), + LiteWalletLifecycleUiExecutionStatus::WaitingForPersistedServerSelection, + LiteWalletLifecycleUiExecutionIssue::PersistedServerSelectionIntentMissing, + "lite lifecycle requires persisted selected-server intent"); + } + + result.connectionSettings = liteConnectionSettingsFromAppSettings(settings); + result.selectedServerSettingsLoaded = true; + + LiteWalletServerSelectionUiExecutionInput selectionInput = makeServerSelectionInput(input, settings); + result.serverSelectionReport = executeLiteWalletServerSelectionUi(settings, selectionInput); + result.connectionSettings = result.serverSelectionReport.connectionSettings; + result.selectedServer = result.serverSelectionReport.selectedServer; + result.selectedServerUrlRedacted = result.serverSelectionReport.selectedServerUrlRedacted; + result.selectedServerIntentAccepted = result.serverSelectionReport.selectedServerIntentAccepted; + result.status = statusFromServerSelection(result.serverSelectionReport.status); + + result.lifecycleInput = result.serverSelectionReport.lifecycleInput; + result.lifecycleReadiness = result.serverSelectionReport.lifecycleReadiness; + result.lifecycleReadinessAccepted = result.lifecycleReadiness.ok; + result.lifecycleReportCouldFeedSyncPlanners = + result.lifecycleReadiness.lifecycleReportCouldFeedSyncPlanners; + result.requestAccepted = result.lifecycleReadiness.requestAccepted; + result.privateDataRedacted = result.lifecycleReadiness.requestPlan.privateInputsRedacted; + result.privateData = result.lifecycleReadiness.requestPlan.privateData; + result.requestSummaryRedacted = result.lifecycleReadiness.requestPlan.requestSummary; + result.diagnosticSummary = buildDiagnosticSummary(result); + copyServerSelectionIssues(result); + copyLifecycleIssues(result); + + const bool lifecycleReadinessEvaluated = result.lifecycleReadiness.ok || + !result.lifecycleReadiness.issues.empty() || + !result.lifecycleReadiness.error.empty() || + result.lifecycleReadiness.serverSelectionAccepted || + result.lifecycleReadiness.requestAccepted; + + if (!result.serverSelectionReport.ok && !lifecycleReadinessEvaluated) { + result.ok = false; + result.status = statusFromServerSelection(result.serverSelectionReport.status); + result.error = result.serverSelectionReport.error; + return result; + } + + if (!result.lifecycleReadiness.ok) { + result.ok = false; + result.status = statusFromLifecycle(result.lifecycleReadiness.status); + result.error = result.lifecycleReadiness.error.empty() + ? result.serverSelectionReport.error + : result.lifecycleReadiness.error; + return result; + } + + result.ok = true; + result.status = LiteWalletLifecycleUiExecutionStatus::ReadyForFutureLifecycleRequest; + return result; +} + +LiteWalletLifecycleUiExecutionAdapter::LiteWalletLifecycleUiExecutionAdapter( + config::Settings& settings) + : settings_(settings) +{ +} + +LiteWalletLifecycleUiExecutionResult LiteWalletLifecycleUiExecutionAdapter::execute( + const LiteWalletLifecycleUiExecutionInput& input) const +{ + return executeLiteWalletLifecycleUiRequest(settings_, input); +} + +} // namespace wallet +} // namespace dragonx \ No newline at end of file diff --git a/src/wallet/lite_wallet_lifecycle_ui_adapter.h b/src/wallet/lite_wallet_lifecycle_ui_adapter.h new file mode 100644 index 0000000..c43fc2a --- /dev/null +++ b/src/wallet/lite_wallet_lifecycle_ui_adapter.h @@ -0,0 +1,146 @@ +#pragma once + +#include "lite_wallet_server_selection_adapter.h" + +#include "../config/settings.h" + +#include +#include + +namespace dragonx { +namespace wallet { + +enum class LiteWalletLifecycleUiExecutionStatus { + ReadyForFutureLifecycleRequest, + WaitingForLiteBuild, + WaitingForBackendCapability, + WaitingForSettings, + WaitingForPersistedServerSelection, + WaitingForServerSelection, + WaitingForDisplayStatus, + WaitingForLifecycleUi, + WaitingForRequest, + WaitingForPrivateDataRedaction, + WaitingForSyncPlannerFeed, + RuntimeExecutionDisabled +}; + +enum class LiteWalletLifecycleUiExecutionIssue { + FullNodeBuild, + LiteBackendCapabilityMissing, + SettingsNotLoaded, + PersistedServerSelectionIntentMissing, + ServerSelectionMissing, + SelectedServerDisplayMissing, + LifecycleUiOwnerMissing, + LifecycleOperationUnconfirmed, + OpenWalletPathMissing, + RestoreSeedMissing, + PrivateDataRedactionMissing, + SyncPlannerFeedMissing, + ServerConnectivityCheckRequested, + WalletExistsCheckRequested, + WalletLifecycleExecutionRequested, + SyncRequested, + SyncStatusPollingRequested, + WorkerQueueRequested, + WalletStateMutationRequested, + WalletFilePersistenceRequested, + SendImportExportRequested, + SettingsWriteRequested +}; + +struct LiteWalletLifecycleUiRequestIntent { + bool requestProvided = false; + LiteWalletLifecycleOperation operation = LiteWalletLifecycleOperation::CreateNew; + LiteWalletCreateRequest createRequest; + LiteWalletOpenRequest openRequest; + LiteWalletRestoreRequest restoreRequest; +}; + +struct LiteWalletLifecycleUiExecutionInput { + WalletCapabilities capabilities; + LiteWalletLifecycleUiRequestIntent request; + bool settingsLoaded = true; + bool requirePersistedServerSelectionIntent = true; + LiteWalletLifecycleUiPrerequisites ui; + + bool settingsWriteRequested = false; + bool serverConnectivityCheckRequested = false; + bool walletExistsCheckRequested = false; + bool walletLifecycleExecutionRequested = false; + bool syncStartRequested = false; + bool syncStatusPollingRequested = false; + bool workerQueueEnqueueRequested = false; + bool walletStateMutationRequested = false; + bool walletFilePersistenceRequested = false; + bool sendImportExportExecutionRequested = false; +}; + +struct LiteWalletLifecycleUiExecutionIssueInfo { + LiteWalletLifecycleUiExecutionIssue issue = LiteWalletLifecycleUiExecutionIssue::SettingsNotLoaded; + std::string message; +}; + +struct LiteWalletLifecycleUiExecutionResult { + bool ok = false; + bool dryRunOnly = true; + bool noNetwork = true; + bool noBridgeCalls = true; + bool noServerHealthChecked = true; + bool noWalletExistsChecked = true; + bool noWalletCreated = true; + bool noWalletOpened = true; + bool noWalletRestored = true; + bool noSyncStarted = true; + bool noSyncStatusPolled = true; + bool noWalletPersistence = true; + bool noSettingsPersistence = true; + bool noSendImportExportExecution = true; + bool settingsWritten = false; + bool workerQueueEnqueued = false; + bool stateMutationAllowed = false; + bool stateMutated = false; + bool walletStateWritten = false; + bool selectedServerSettingsLoaded = false; + bool selectedServerIntentAccepted = false; + bool lifecycleReadinessAccepted = false; + bool requestAccepted = false; + bool privateDataRedacted = false; + bool lifecycleReportCouldFeedSyncPlanners = false; + LiteWalletLifecycleUiExecutionStatus status = LiteWalletLifecycleUiExecutionStatus::WaitingForSettings; + std::string error; + std::string selectedServerUrlRedacted; + std::string requestSummaryRedacted; + std::string diagnosticSummary; + LiteConnectionSettings connectionSettings; + LiteServerSelectionResult selectedServer; + LiteWalletServerSelectionUiExecutionResult serverSelectionReport; + LiteWalletServerLifecycleReadinessInput lifecycleInput; + LiteWalletServerLifecycleReadinessResult lifecycleReadiness; + std::vector privateData; + std::vector issues; +}; + +const char* liteWalletLifecycleUiExecutionStatusName( + LiteWalletLifecycleUiExecutionStatus status); +const char* liteWalletLifecycleUiExecutionIssueName( + LiteWalletLifecycleUiExecutionIssue issue); + +LiteWalletLifecycleUiExecutionResult executeLiteWalletLifecycleUiRequest( + config::Settings& settings, + const LiteWalletLifecycleUiExecutionInput& input); + +class LiteWalletLifecycleUiExecutionAdapter { +public: + explicit LiteWalletLifecycleUiExecutionAdapter(config::Settings& settings); + + LiteWalletLifecycleUiExecutionResult execute( + const LiteWalletLifecycleUiExecutionInput& input) const; + +private: + config::Settings& settings_; +}; + +} // namespace wallet +} // namespace dragonx \ No newline at end of file diff --git a/src/wallet/lite_wallet_refresh_readiness_policy.cpp b/src/wallet/lite_wallet_refresh_readiness_policy.cpp new file mode 100644 index 0000000..1711d3d --- /dev/null +++ b/src/wallet/lite_wallet_refresh_readiness_policy.cpp @@ -0,0 +1,205 @@ +#include "wallet/lite_wallet_refresh_readiness_policy.h" + +#include + +namespace dragonx::wallet { +namespace { + +void addIssue(LiteWalletRefreshReadinessResult& result, + LiteWalletRefreshReadinessIssue issue, + std::string message) +{ + result.issues.push_back(LiteWalletRefreshReadinessIssueInfo{issue, std::move(message)}); +} + +std::string statusMessageOrDefault(const WalletBackendStatus& status, + const std::string& fallback) +{ + return status.message.empty() ? fallback : status.message; +} + +LiteWalletRefreshReadinessResult failReadiness( + LiteWalletRefreshReadinessResult result, + LiteWalletRefreshReadinessStatus status, + LiteWalletRefreshReadinessIssue issue, + std::string message) +{ + result.status = status; + addIssue(result, issue, std::move(message)); + result.error = result.issues.back().message; + return result; +} + +bool coordinatorReportIsUnsafe(const LiteWalletAppRefreshCoordinationResult& coordination) +{ + return !coordination.dryRunOnly || + !coordination.noNetwork || + coordination.stateMutationRequested || + coordination.stateMutationAllowed || + coordination.stateMutated || + coordination.walletStateWritten; +} + +} // namespace + +const char* liteWalletRefreshReadinessStatusName(LiteWalletRefreshReadinessStatus status) +{ + switch (status) { + case LiteWalletRefreshReadinessStatus::EligibleDryRun: return "EligibleDryRun"; + case LiteWalletRefreshReadinessStatus::CoordinatorRejected: return "CoordinatorRejected"; + case LiteWalletRefreshReadinessStatus::UnsafeReport: return "UnsafeReport"; + case LiteWalletRefreshReadinessStatus::WaitingForLifecycle: return "WaitingForLifecycle"; + case LiteWalletRefreshReadinessStatus::WaitingForSync: return "WaitingForSync"; + case LiteWalletRefreshReadinessStatus::Stale: return "Stale"; + } + return "Unknown"; +} + +const char* liteWalletRefreshReadinessIssueName(LiteWalletRefreshReadinessIssue issue) +{ + switch (issue) { + case LiteWalletRefreshReadinessIssue::CoordinatorReportRejected: return "CoordinatorReportRejected"; + case LiteWalletRefreshReadinessIssue::CoordinatorReportIncomplete: return "CoordinatorReportIncomplete"; + case LiteWalletRefreshReadinessIssue::CoordinatorReportUnsafe: return "CoordinatorReportUnsafe"; + case LiteWalletRefreshReadinessIssue::FullNodeRouteRejected: return "FullNodeRouteRejected"; + case LiteWalletRefreshReadinessIssue::LifecycleNotReady: return "LifecycleNotReady"; + case LiteWalletRefreshReadinessIssue::SyncNotReady: return "SyncNotReady"; + case LiteWalletRefreshReadinessIssue::RefreshTimestampMissing: return "RefreshTimestampMissing"; + case LiteWalletRefreshReadinessIssue::RefreshTimestampInFuture: return "RefreshTimestampInFuture"; + case LiteWalletRefreshReadinessIssue::RefreshStale: return "RefreshStale"; + case LiteWalletRefreshReadinessIssue::StaleRefreshAllowed: return "StaleRefreshAllowed"; + } + return "Unknown"; +} + +LiteWalletRefreshReadinessResult evaluateLiteWalletRefreshReadiness( + const LiteWalletAppRefreshCoordinationResult& coordination, + const LiteWalletRefreshReadinessInputs& inputs, + LiteWalletRefreshReadinessPolicyOptions options) +{ + LiteWalletRefreshReadinessResult result; + result.route = coordination.route; + result.dryRunOnly = coordination.dryRunOnly; + result.noNetwork = coordination.noNetwork; + result.stateMutationRequested = coordination.stateMutationRequested; + result.stateMutationAllowed = coordination.stateMutationAllowed; + result.stateMutated = coordination.stateMutated; + result.walletStateWritten = coordination.walletStateWritten; + result.lifecycleReady = inputs.lifecycleReady; + result.lifecycleStatus = inputs.lifecycleStatus; + result.syncReady = inputs.syncReady; + result.syncStatus = inputs.syncStatus; + result.maxRefreshAgeSeconds = options.maxRefreshAgeSeconds; + + if (coordination.fullNodeRefreshDelegated || coordination.route == LiteWalletRefreshRouteKind::FullNodeRpc) { + return failReadiness( + std::move(result), + LiteWalletRefreshReadinessStatus::CoordinatorRejected, + LiteWalletRefreshReadinessIssue::FullNodeRouteRejected, + "full-node refresh reports are not eligible for lite UI refresh readiness"); + } + + if (!coordination.ok) { + return failReadiness( + std::move(result), + LiteWalletRefreshReadinessStatus::CoordinatorRejected, + LiteWalletRefreshReadinessIssue::CoordinatorReportRejected, + coordination.error.empty() + ? "lite app refresh coordinator report is not successful" + : coordination.error); + } + + result.coordinatorReportAccepted = true; + + if (!coordination.mapped || !coordination.planned || !coordination.executionReported || + coordination.successfulCommandCount == 0) { + return failReadiness( + std::move(result), + LiteWalletRefreshReadinessStatus::CoordinatorRejected, + LiteWalletRefreshReadinessIssue::CoordinatorReportIncomplete, + "lite app refresh coordinator report is incomplete"); + } + + if (coordinatorReportIsUnsafe(coordination)) { + return failReadiness( + std::move(result), + LiteWalletRefreshReadinessStatus::UnsafeReport, + LiteWalletRefreshReadinessIssue::CoordinatorReportUnsafe, + "lite app refresh coordinator report is not a no-network dry-run report"); + } + + if (options.requireLifecycleReady && !inputs.lifecycleReady) { + return failReadiness( + std::move(result), + LiteWalletRefreshReadinessStatus::WaitingForLifecycle, + LiteWalletRefreshReadinessIssue::LifecycleNotReady, + statusMessageOrDefault(inputs.lifecycleStatus, "lite wallet lifecycle is not ready")); + } + + if (options.requireSyncReady && !inputs.syncReady) { + return failReadiness( + std::move(result), + LiteWalletRefreshReadinessStatus::WaitingForSync, + LiteWalletRefreshReadinessIssue::SyncNotReady, + statusMessageOrDefault(inputs.syncStatus, "lite wallet sync is not ready")); + } + + if (options.requireFreshRefresh) { + if (!inputs.freshness.haveSnapshotTime) { + return failReadiness( + std::move(result), + LiteWalletRefreshReadinessStatus::Stale, + LiteWalletRefreshReadinessIssue::RefreshTimestampMissing, + "lite refresh snapshot time is not known"); + } + + if (inputs.freshness.snapshotTimeSeconds > inputs.freshness.nowSeconds) { + return failReadiness( + std::move(result), + LiteWalletRefreshReadinessStatus::Stale, + LiteWalletRefreshReadinessIssue::RefreshTimestampInFuture, + "lite refresh snapshot time is in the future"); + } + + result.refreshAgeSeconds = inputs.freshness.nowSeconds - inputs.freshness.snapshotTimeSeconds; + if (result.refreshAgeSeconds > options.maxRefreshAgeSeconds) { + result.refreshStale = true; + if (!options.allowStaleRefresh) { + return failReadiness( + std::move(result), + LiteWalletRefreshReadinessStatus::Stale, + LiteWalletRefreshReadinessIssue::RefreshStale, + "lite refresh coordinator report is stale"); + } + + result.staleRefreshAllowed = true; + addIssue(result, + LiteWalletRefreshReadinessIssue::StaleRefreshAllowed, + "stale lite refresh coordinator report is allowed for reporting only"); + } else { + result.refreshFresh = true; + } + } else { + result.refreshFresh = true; + } + + result.ok = true; + result.eligibleForFutureUiRefresh = true; + result.status = LiteWalletRefreshReadinessStatus::EligibleDryRun; + return result; +} + +LiteWalletRefreshReadinessPolicy::LiteWalletRefreshReadinessPolicy( + LiteWalletRefreshReadinessPolicyOptions options) + : options_(options) +{ +} + +LiteWalletRefreshReadinessResult LiteWalletRefreshReadinessPolicy::evaluate( + const LiteWalletAppRefreshCoordinationResult& coordination, + const LiteWalletRefreshReadinessInputs& inputs) const +{ + return evaluateLiteWalletRefreshReadiness(coordination, inputs, options_); +} + +} // namespace dragonx::wallet \ No newline at end of file diff --git a/src/wallet/lite_wallet_refresh_readiness_policy.h b/src/wallet/lite_wallet_refresh_readiness_policy.h new file mode 100644 index 0000000..84e3d5e --- /dev/null +++ b/src/wallet/lite_wallet_refresh_readiness_policy.h @@ -0,0 +1,106 @@ +#pragma once + +#include "lite_wallet_app_refresh_coordinator.h" + +#include +#include +#include + +namespace dragonx::wallet { + +enum class LiteWalletRefreshReadinessStatus { + EligibleDryRun, + CoordinatorRejected, + UnsafeReport, + WaitingForLifecycle, + WaitingForSync, + Stale, +}; + +enum class LiteWalletRefreshReadinessIssue { + CoordinatorReportRejected, + CoordinatorReportIncomplete, + CoordinatorReportUnsafe, + FullNodeRouteRejected, + LifecycleNotReady, + SyncNotReady, + RefreshTimestampMissing, + RefreshTimestampInFuture, + RefreshStale, + StaleRefreshAllowed, +}; + +struct LiteWalletRefreshFreshnessInput { + bool haveSnapshotTime = false; + std::uint64_t snapshotTimeSeconds = 0; + std::uint64_t nowSeconds = 0; +}; + +struct LiteWalletRefreshReadinessInputs { + bool lifecycleReady = false; + WalletBackendStatus lifecycleStatus; + bool syncReady = false; + WalletBackendStatus syncStatus; + LiteWalletRefreshFreshnessInput freshness; +}; + +struct LiteWalletRefreshReadinessPolicyOptions { + bool requireLifecycleReady = true; + bool requireSyncReady = true; + bool requireFreshRefresh = true; + bool allowStaleRefresh = false; + std::uint64_t maxRefreshAgeSeconds = 120; +}; + +struct LiteWalletRefreshReadinessIssueInfo { + LiteWalletRefreshReadinessIssue issue = LiteWalletRefreshReadinessIssue::CoordinatorReportRejected; + std::string message; +}; + +struct LiteWalletRefreshReadinessResult { + bool ok = false; + bool eligibleForFutureUiRefresh = false; + bool coordinatorReportAccepted = false; + bool dryRunOnly = true; + bool noNetwork = true; + bool stateMutationRequested = false; + bool stateMutationAllowed = false; + bool stateMutated = false; + bool walletStateWritten = false; + bool lifecycleReady = false; + bool syncReady = false; + bool refreshFresh = false; + bool refreshStale = false; + bool staleRefreshAllowed = false; + + LiteWalletRefreshReadinessStatus status = LiteWalletRefreshReadinessStatus::CoordinatorRejected; + LiteWalletRefreshRouteKind route = LiteWalletRefreshRouteKind::Unavailable; + WalletBackendStatus lifecycleStatus; + WalletBackendStatus syncStatus; + std::uint64_t refreshAgeSeconds = 0; + std::uint64_t maxRefreshAgeSeconds = 0; + std::vector issues; + std::string error; +}; + +const char* liteWalletRefreshReadinessStatusName(LiteWalletRefreshReadinessStatus status); +const char* liteWalletRefreshReadinessIssueName(LiteWalletRefreshReadinessIssue issue); + +LiteWalletRefreshReadinessResult evaluateLiteWalletRefreshReadiness( + const LiteWalletAppRefreshCoordinationResult& coordination, + const LiteWalletRefreshReadinessInputs& inputs, + LiteWalletRefreshReadinessPolicyOptions options = {}); + +class LiteWalletRefreshReadinessPolicy { +public: + explicit LiteWalletRefreshReadinessPolicy(LiteWalletRefreshReadinessPolicyOptions options = {}); + + LiteWalletRefreshReadinessResult evaluate( + const LiteWalletAppRefreshCoordinationResult& coordination, + const LiteWalletRefreshReadinessInputs& inputs) const; + +private: + LiteWalletRefreshReadinessPolicyOptions options_; +}; + +} // namespace dragonx::wallet \ No newline at end of file diff --git a/src/wallet/lite_wallet_refresh_service.cpp b/src/wallet/lite_wallet_refresh_service.cpp new file mode 100644 index 0000000..79f106a --- /dev/null +++ b/src/wallet/lite_wallet_refresh_service.cpp @@ -0,0 +1,189 @@ +#include "wallet/lite_wallet_refresh_service.h" + +#include + +namespace dragonx::wallet { +namespace { + +WalletBackendStatus makeRefreshStatus(WalletBackendState state, std::string message) +{ + WalletBackendStatus status; + status.state = state; + status.message = std::move(message); + return status; +} + +} // namespace + +LiteWalletGatewayRefreshAdapter::LiteWalletGatewayRefreshAdapter(LiteWalletGateway& gateway) + : gateway_(gateway) +{ +} + +LiteWalletRefreshPlan LiteWalletGatewayRefreshAdapter::planRefresh( + const LiteWalletRefreshRequest& request) const +{ + return gateway_.planRefresh(request); +} + +LiteWalletRefreshResult LiteWalletGatewayRefreshAdapter::refresh( + const LiteWalletRefreshRequest& request) +{ + return gateway_.refresh(request); +} + +WalletBackendStatus LiteWalletGatewayRefreshAdapter::status() const +{ + return gateway_.status(); +} + +const char* liteWalletRefreshRouteKindName(LiteWalletRefreshRouteKind route) +{ + switch (route) { + case LiteWalletRefreshRouteKind::FullNodeRpc: return "FullNodeRpc"; + case LiteWalletRefreshRouteKind::LiteGateway: return "LiteGateway"; + case LiteWalletRefreshRouteKind::Unavailable: return "Unavailable"; + } + return "Unknown"; +} + +LiteWalletRefreshRouteKind liteWalletRefreshRouteForCapabilities(const WalletCapabilities& capabilities) +{ + if (capabilities.fullNodeRpcAvailable) return LiteWalletRefreshRouteKind::FullNodeRpc; + if (isLiteBuild(capabilities) && supportsLiteBackend(capabilities)) { + return LiteWalletRefreshRouteKind::LiteGateway; + } + return LiteWalletRefreshRouteKind::Unavailable; +} + +LiteWalletRefreshService::LiteWalletRefreshService(WalletCapabilities capabilities, + LiteWalletRefreshGateway* liteGateway, + LiteWalletRefreshServiceOptions options) + : capabilities_(capabilities), liteGateway_(liteGateway), options_(options) +{ +} + +LiteWalletRefreshRouteKind LiteWalletRefreshService::route() const +{ + return liteWalletRefreshRouteForCapabilities(capabilities_); +} + +WalletBackendStatus LiteWalletRefreshService::status() const +{ + const auto selectedRoute = route(); + if (selectedRoute == LiteWalletRefreshRouteKind::LiteGateway) { + if (!liteGateway_) return statusForRoute(selectedRoute, "lite wallet gateway is not configured"); + return liteGateway_->status(); + } + return statusForRoute(selectedRoute); +} + +LiteWalletRefreshServicePlan LiteWalletRefreshService::planRefresh( + const LiteWalletRefreshRequest& request) const +{ + LiteWalletRefreshServicePlan plan; + plan.route = route(); + + if (plan.route == LiteWalletRefreshRouteKind::FullNodeRpc) { + plan.ok = true; + plan.fullNodeRefreshDelegated = true; + plan.status = statusForRoute(plan.route); + return plan; + } + + if (plan.route == LiteWalletRefreshRouteKind::Unavailable) { + plan.status = statusForRoute(plan.route); + plan.error = plan.status.message; + return plan; + } + + if (!liteGateway_) { + plan.status = statusForRoute(plan.route, "lite wallet gateway is not configured"); + plan.error = plan.status.message; + return plan; + } + + plan.liteGatewayConfigured = true; + plan.liteGatewayExecutionAllowed = options_.allowLiteGatewayRefresh; + plan.liteGatewayPlan = liteGateway_->planRefresh(request); + if (!plan.liteGatewayPlan.ok) { + plan.status = makeRefreshStatus(WalletBackendState::Error, plan.liteGatewayPlan.error); + plan.error = plan.status.message; + return plan; + } + + plan.ok = true; + plan.status = liteGateway_->status(); + return plan; +} + +LiteWalletRefreshServiceResult LiteWalletRefreshService::refresh( + const LiteWalletRefreshRequest& request) +{ + auto plan = planRefresh(request); + if (!plan.ok) return resultFromPlan(plan); + + if (plan.route == LiteWalletRefreshRouteKind::FullNodeRpc) { + auto result = resultFromPlan(plan); + result.ok = true; + return result; + } + + if (!plan.liteGatewayExecutionAllowed) { + plan.status = makeRefreshStatus( + WalletBackendState::Unavailable, + "lite wallet refresh gateway execution is disabled"); + plan.error = plan.status.message; + return resultFromPlan(plan); + } + + LiteWalletRefreshServiceResult result; + result.plan = plan; + result.liteGatewayCalled = true; + result.liteGatewayResult = liteGateway_->refresh(request); + result.attempted = result.liteGatewayResult.attempted; + result.bundle = result.liteGatewayResult.bundle; + result.status = result.liteGatewayResult.status; + result.error = result.liteGatewayResult.error; + result.ok = result.liteGatewayResult.ok; + return result; +} + +WalletBackendStatus LiteWalletRefreshService::statusForRoute( + LiteWalletRefreshRouteKind selectedRoute, + const std::string& detail) const +{ + switch (selectedRoute) { + case LiteWalletRefreshRouteKind::FullNodeRpc: + return makeRefreshStatus( + WalletBackendState::Disconnected, + detail.empty() + ? "full-node refresh remains handled by existing NetworkRefreshService" + : detail); + case LiteWalletRefreshRouteKind::LiteGateway: + return makeRefreshStatus( + detail.empty() ? WalletBackendState::Disconnected : WalletBackendState::Unavailable, + detail.empty() + ? "lite wallet refresh route is ready for gateway planning" + : detail); + case LiteWalletRefreshRouteKind::Unavailable: + return makeRefreshStatus( + WalletBackendState::Unavailable, + detail.empty() ? "lite backend is not linked" : detail); + } + + return makeRefreshStatus(WalletBackendState::Unavailable, "unknown wallet refresh route"); +} + +LiteWalletRefreshServiceResult LiteWalletRefreshService::resultFromPlan( + const LiteWalletRefreshServicePlan& plan) const +{ + LiteWalletRefreshServiceResult result; + result.plan = plan; + result.fullNodeRefreshDelegated = plan.fullNodeRefreshDelegated; + result.status = plan.status; + result.error = plan.error; + return result; +} + +} // namespace dragonx::wallet \ No newline at end of file diff --git a/src/wallet/lite_wallet_refresh_service.h b/src/wallet/lite_wallet_refresh_service.h new file mode 100644 index 0000000..ba72e39 --- /dev/null +++ b/src/wallet/lite_wallet_refresh_service.h @@ -0,0 +1,92 @@ +#pragma once + +#include "lite_wallet_gateway.h" +#include "wallet_backend.h" +#include "wallet_capabilities.h" + +#include + +namespace dragonx::wallet { + +enum class LiteWalletRefreshRouteKind { + FullNodeRpc, + LiteGateway, + Unavailable, +}; + +struct LiteWalletRefreshServiceOptions { + bool allowLiteGatewayRefresh = false; +}; + +struct LiteWalletRefreshServicePlan { + bool ok = false; + LiteWalletRefreshRouteKind route = LiteWalletRefreshRouteKind::Unavailable; + bool fullNodeRefreshDelegated = false; + bool liteGatewayConfigured = false; + bool liteGatewayExecutionAllowed = false; + LiteWalletRefreshPlan liteGatewayPlan; + WalletBackendStatus status; + std::string error; +}; + +struct LiteWalletRefreshServiceResult { + bool ok = false; + bool attempted = false; + bool fullNodeRefreshDelegated = false; + bool liteGatewayCalled = false; + LiteWalletRefreshServicePlan plan; + LiteWalletRefreshResult liteGatewayResult; + LiteWalletRefreshBundle bundle; + WalletBackendStatus status; + std::string error; +}; + +class LiteWalletRefreshGateway { +public: + virtual ~LiteWalletRefreshGateway() = default; + + virtual LiteWalletRefreshPlan planRefresh(const LiteWalletRefreshRequest& request) const = 0; + virtual LiteWalletRefreshResult refresh(const LiteWalletRefreshRequest& request) = 0; + virtual WalletBackendStatus status() const = 0; +}; + +class LiteWalletGatewayRefreshAdapter final : public LiteWalletRefreshGateway { +public: + explicit LiteWalletGatewayRefreshAdapter(LiteWalletGateway& gateway); + + LiteWalletRefreshPlan planRefresh(const LiteWalletRefreshRequest& request) const override; + LiteWalletRefreshResult refresh(const LiteWalletRefreshRequest& request) override; + WalletBackendStatus status() const override; + +private: + LiteWalletGateway& gateway_; +}; + +const char* liteWalletRefreshRouteKindName(LiteWalletRefreshRouteKind route); +LiteWalletRefreshRouteKind liteWalletRefreshRouteForCapabilities(const WalletCapabilities& capabilities); + +class LiteWalletRefreshService { +public: + LiteWalletRefreshService(WalletCapabilities capabilities, + LiteWalletRefreshGateway* liteGateway = nullptr, + LiteWalletRefreshServiceOptions options = {}); + + const WalletCapabilities& capabilities() const { return capabilities_; } + const LiteWalletRefreshServiceOptions& options() const { return options_; } + + LiteWalletRefreshRouteKind route() const; + WalletBackendStatus status() const; + LiteWalletRefreshServicePlan planRefresh(const LiteWalletRefreshRequest& request) const; + LiteWalletRefreshServiceResult refresh(const LiteWalletRefreshRequest& request); + +private: + WalletBackendStatus statusForRoute(LiteWalletRefreshRouteKind route, + const std::string& detail = {}) const; + LiteWalletRefreshServiceResult resultFromPlan(const LiteWalletRefreshServicePlan& plan) const; + + WalletCapabilities capabilities_; + LiteWalletRefreshGateway* liteGateway_ = nullptr; + LiteWalletRefreshServiceOptions options_; +}; + +} // namespace dragonx::wallet \ No newline at end of file diff --git a/src/wallet/lite_wallet_server_lifecycle_readiness.cpp b/src/wallet/lite_wallet_server_lifecycle_readiness.cpp new file mode 100644 index 0000000..0526891 --- /dev/null +++ b/src/wallet/lite_wallet_server_lifecycle_readiness.cpp @@ -0,0 +1,407 @@ +#include "wallet/lite_wallet_server_lifecycle_readiness.h" + +#include +#include + +namespace dragonx::wallet { +namespace { + +std::string trimCopy(const std::string& value) +{ + auto begin = value.begin(); + while (begin != value.end() && std::isspace(static_cast(*begin))) ++begin; + + auto end = value.end(); + while (end != begin && std::isspace(static_cast(*(end - 1)))) --end; + + return std::string(begin, end); +} + +void addIssue(LiteWalletServerLifecycleReadinessResult& result, + LiteWalletServerLifecycleReadinessIssue issue, + std::string message) +{ + result.issues.push_back(LiteWalletServerLifecycleReadinessIssueInfo{issue, std::move(message)}); +} + +LiteWalletServerLifecycleReadinessResult stoppedResult( + LiteWalletServerLifecycleReadinessResult result, + LiteWalletServerLifecycleReadinessStatus status, + LiteWalletServerLifecycleReadinessIssue issue, + std::string message) +{ + result.status = status; + addIssue(result, issue, std::move(message)); + result.error = result.issues.back().message; + result.lifecycleStatus = WalletBackendStatus{WalletBackendState::Unavailable, result.error, {}, {}, 0.0}; + result.syncLifecycleInput.status = result.lifecycleStatus; + return result; +} + +LiteRedactedPrivateData redactedPrivateField(LitePrivateDataKind kind, const std::string& value) +{ + return LiteRedactedPrivateData{kind, !trimCopy(value).empty(), redactLitePrivateDataValue(value)}; +} + +bool privateDataIsRedacted(const std::vector& privateData) +{ + for (const auto& item : privateData) { + if (!item.present && item.redactedValue != "") return false; + if (item.present && item.redactedValue != "") return false; + } + return true; +} + +LiteWalletSelectedServerDisplayReport displayReportForSelection( + const LiteServerSelectionResult& selection) +{ + LiteWalletSelectedServerDisplayReport report; + if (!selection.ok) { + report.status = LiteWalletSelectedServerDisplayStatus::Missing; + report.message = selection.error.empty() ? "no usable lite server is selected" : selection.error; + return report; + } + + report.ok = true; + report.status = selection.customServer + ? LiteWalletSelectedServerDisplayStatus::CustomServer + : LiteWalletSelectedServerDisplayStatus::SelectedServer; + report.label = selection.server.label; + report.url = selection.server.url; + report.serverIndex = selection.serverIndex; + report.customServer = selection.customServer; + report.message = selection.customServer + ? "custom lite server selected for display" + : "configured lite server selected for display"; + return report; +} + +LiteWalletLifecyclePlan lifecyclePlanForRequest( + LiteWalletLifecycleOperation operation, + const LiteServerSelectionResult& selection) +{ + LiteWalletLifecyclePlan plan; + plan.operation = operation; + plan.bridgeExecutionAllowed = false; + if (!selection.ok) { + plan.error = selection.error.empty() ? "no usable lite server is selected" : selection.error; + return plan; + } + + plan.ok = true; + plan.server = selection.server; + plan.serverIndex = selection.serverIndex; + plan.customServer = selection.customServer; + return plan; +} + +LiteWalletLifecycleUiRequestPlan requestPlanForInput( + const LiteWalletServerLifecycleReadinessInput& input, + const LiteServerSelectionResult& selection) +{ + LiteWalletLifecycleUiRequestPlan plan; + plan.operation = input.operation; + plan.lifecyclePlan = lifecyclePlanForRequest(input.operation, selection); + if (!plan.lifecyclePlan.ok) { + plan.error = plan.lifecyclePlan.error; + return plan; + } + + switch (input.operation) { + case LiteWalletLifecycleOperation::CreateNew: + plan.privateData.push_back(redactedPrivateField( + LitePrivateDataKind::Passphrase, + input.createRequest.passphrase)); + plan.requestSummary = "operation=create;server=;passphrase=" + + std::string(input.createRequest.passphrase.empty() ? "" : ""); + break; + case LiteWalletLifecycleOperation::OpenExisting: + if (trimCopy(input.openRequest.walletPath).empty()) { + plan.error = "lite wallet open requires a wallet path selected by the UI"; + return plan; + } + plan.privateData.push_back(redactedPrivateField( + LitePrivateDataKind::WalletPath, + input.openRequest.walletPath)); + plan.privateData.push_back(redactedPrivateField( + LitePrivateDataKind::Passphrase, + input.openRequest.passphrase)); + plan.requestSummary = "operation=open;server=;wallet_path=;passphrase=" + + std::string(input.openRequest.passphrase.empty() ? "" : ""); + break; + case LiteWalletLifecycleOperation::RestoreFromSeed: + if (trimCopy(input.restoreRequest.seedPhrase).empty()) { + plan.error = "lite wallet restore requires redacted seed material metadata"; + return plan; + } + plan.privateData.push_back(redactedPrivateField( + LitePrivateDataKind::SeedPhrase, + input.restoreRequest.seedPhrase)); + plan.privateData.push_back(redactedPrivateField( + LitePrivateDataKind::WalletPath, + input.restoreRequest.walletPath)); + plan.privateData.push_back(redactedPrivateField( + LitePrivateDataKind::Passphrase, + input.restoreRequest.passphrase)); + plan.requestSummary = "operation=restore;server=;seed=;wallet_path=" + + std::string(input.restoreRequest.walletPath.empty() ? "" : "") + + ";passphrase=" + + std::string(input.restoreRequest.passphrase.empty() ? "" : ""); + break; + } + + plan.privateInputsRedacted = privateDataIsRedacted(plan.privateData); + plan.lifecyclePlan.privateData = plan.privateData; + plan.ok = plan.privateInputsRedacted; + if (!plan.ok) plan.error = "lite wallet lifecycle private inputs are not redacted"; + return plan; +} + +LiteWalletServerSelectionPersistencePlan persistencePlanForInput( + const LiteWalletServerLifecycleReadinessInput& input, + const LiteServerSelectionResult& selection) +{ + LiteWalletServerSelectionPersistencePlan plan; + plan.settingsLoaded = input.persistence.settingsLoaded; + plan.persistedSelectionIntentAccepted = input.persistence.havePersistedSelectionIntent; + plan.wouldPersistSelectedServer = input.persistence.persistSelectedServer; + plan.persistenceOwnerAccepted = input.persistence.persistenceOwnerReady; + plan.selectionMode = input.settings.selectionMode; + if (selection.ok) { + plan.selectedServerUrl = selection.server.url; + plan.selectedServerIndex = selection.serverIndex; + plan.selectedServerCustom = selection.customServer; + } + plan.settingsWritten = false; + plan.ok = true; + return plan; +} + +WalletBackendStatus readyLifecycleStatus(const LiteWalletSelectedServerDisplayReport& display) +{ + const std::string serverLabel = display.label.empty() ? display.url : display.label; + return WalletBackendStatus{ + WalletBackendState::Disconnected, + "lite lifecycle UI readiness accepted for " + serverLabel + "; wallet lifecycle execution is still disabled", + {}, + {}, + 0.0 + }; +} + +} // namespace + +const char* liteWalletServerLifecycleReadinessStatusName( + LiteWalletServerLifecycleReadinessStatus status) +{ + switch (status) { + case LiteWalletServerLifecycleReadinessStatus::ReadyForFutureLifecycle: return "ReadyForFutureLifecycle"; + case LiteWalletServerLifecycleReadinessStatus::WaitingForLiteBuild: return "WaitingForLiteBuild"; + case LiteWalletServerLifecycleReadinessStatus::WaitingForBackendCapability: return "WaitingForBackendCapability"; + case LiteWalletServerLifecycleReadinessStatus::WaitingForServerSelection: return "WaitingForServerSelection"; + case LiteWalletServerLifecycleReadinessStatus::WaitingForPersistenceIntent: return "WaitingForPersistenceIntent"; + case LiteWalletServerLifecycleReadinessStatus::WaitingForDisplayStatus: return "WaitingForDisplayStatus"; + case LiteWalletServerLifecycleReadinessStatus::WaitingForLifecycleUi: return "WaitingForLifecycleUi"; + case LiteWalletServerLifecycleReadinessStatus::WaitingForPrivateDataRedaction: return "WaitingForPrivateDataRedaction"; + case LiteWalletServerLifecycleReadinessStatus::WaitingForSyncPlannerFeed: return "WaitingForSyncPlannerFeed"; + case LiteWalletServerLifecycleReadinessStatus::RuntimeExecutionDisabled: return "RuntimeExecutionDisabled"; + } + return "Unknown"; +} + +const char* liteWalletServerLifecycleReadinessIssueName( + LiteWalletServerLifecycleReadinessIssue issue) +{ + switch (issue) { + case LiteWalletServerLifecycleReadinessIssue::FullNodeBuild: return "FullNodeBuild"; + case LiteWalletServerLifecycleReadinessIssue::LiteBackendCapabilityMissing: return "LiteBackendCapabilityMissing"; + case LiteWalletServerLifecycleReadinessIssue::PersistedSettingsNotLoaded: return "PersistedSettingsNotLoaded"; + case LiteWalletServerLifecycleReadinessIssue::PersistedServerSelectionIntentMissing: return "PersistedServerSelectionIntentMissing"; + case LiteWalletServerLifecycleReadinessIssue::ServerSelectionMissing: return "ServerSelectionMissing"; + case LiteWalletServerLifecycleReadinessIssue::ServerPersistenceOwnerMissing: return "ServerPersistenceOwnerMissing"; + case LiteWalletServerLifecycleReadinessIssue::SelectedServerDisplayMissing: return "SelectedServerDisplayMissing"; + case LiteWalletServerLifecycleReadinessIssue::LifecycleUiOwnerMissing: return "LifecycleUiOwnerMissing"; + case LiteWalletServerLifecycleReadinessIssue::LifecycleOperationUnconfirmed: return "LifecycleOperationUnconfirmed"; + case LiteWalletServerLifecycleReadinessIssue::OpenWalletPathMissing: return "OpenWalletPathMissing"; + case LiteWalletServerLifecycleReadinessIssue::RestoreSeedMissing: return "RestoreSeedMissing"; + case LiteWalletServerLifecycleReadinessIssue::PrivateDataRedactionMissing: return "PrivateDataRedactionMissing"; + case LiteWalletServerLifecycleReadinessIssue::SyncPlannerFeedMissing: return "SyncPlannerFeedMissing"; + case LiteWalletServerLifecycleReadinessIssue::RealLifecycleExecutionRequested: return "RealLifecycleExecutionRequested"; + } + return "Unknown"; +} + +const char* liteWalletSelectedServerDisplayStatusName( + LiteWalletSelectedServerDisplayStatus status) +{ + switch (status) { + case LiteWalletSelectedServerDisplayStatus::Hidden: return "Hidden"; + case LiteWalletSelectedServerDisplayStatus::SelectedServer: return "SelectedServer"; + case LiteWalletSelectedServerDisplayStatus::CustomServer: return "CustomServer"; + case LiteWalletSelectedServerDisplayStatus::Missing: return "Missing"; + } + return "Unknown"; +} + +LiteWalletServerLifecycleReadinessResult evaluateLiteWalletServerLifecycleReadiness( + const LiteWalletServerLifecycleReadinessInput& input, + LiteWalletServerLifecycleReadinessOptions options) +{ + LiteWalletServerLifecycleReadinessResult result; + result.capabilities = input.capabilities; + result.persistencePlan = persistencePlanForInput(input, {}); + + if (options.requireLiteBuild && !isLiteBuild(input.capabilities)) { + return stoppedResult( + std::move(result), + LiteWalletServerLifecycleReadinessStatus::WaitingForLiteBuild, + LiteWalletServerLifecycleReadinessIssue::FullNodeBuild, + "lite server lifecycle readiness requires a lite build"); + } + result.liteBuildAccepted = true; + + if (options.requireLiteBackendCapability && !supportsLiteBackend(input.capabilities)) { + return stoppedResult( + std::move(result), + LiteWalletServerLifecycleReadinessStatus::WaitingForBackendCapability, + LiteWalletServerLifecycleReadinessIssue::LiteBackendCapabilityMissing, + "lite backend capability is required before lifecycle UI readiness can feed sync planners"); + } + result.backendCapabilityAccepted = true; + + if (options.requirePersistedSettingsLoaded && !input.persistence.settingsLoaded) { + return stoppedResult( + std::move(result), + LiteWalletServerLifecycleReadinessStatus::WaitingForPersistenceIntent, + LiteWalletServerLifecycleReadinessIssue::PersistedSettingsNotLoaded, + "lite server settings must be loaded before lifecycle UI readiness is evaluated"); + } + + if (options.requirePersistedSelectionIntent && !input.persistence.havePersistedSelectionIntent) { + return stoppedResult( + std::move(result), + LiteWalletServerLifecycleReadinessStatus::WaitingForPersistenceIntent, + LiteWalletServerLifecycleReadinessIssue::PersistedServerSelectionIntentMissing, + "lite server selection persistence intent is missing"); + } + + result.selectedServer = selectLiteServer(input.settings); + result.persistencePlan = persistencePlanForInput(input, result.selectedServer); + if (!result.selectedServer.ok) { + return stoppedResult( + std::move(result), + LiteWalletServerLifecycleReadinessStatus::WaitingForServerSelection, + LiteWalletServerLifecycleReadinessIssue::ServerSelectionMissing, + result.selectedServer.error.empty() + ? "no usable lite server is selected" + : result.selectedServer.error); + } + result.serverSelectionAccepted = true; + + if (input.persistence.persistSelectedServer && !input.persistence.persistenceOwnerReady) { + return stoppedResult( + std::move(result), + LiteWalletServerLifecycleReadinessStatus::WaitingForPersistenceIntent, + LiteWalletServerLifecycleReadinessIssue::ServerPersistenceOwnerMissing, + "lite server selection persistence owner is not ready"); + } + result.persistenceIntentAccepted = true; + result.persistencePlan.ok = true; + + result.selectedServerDisplay = displayReportForSelection(result.selectedServer); + if (options.requireSelectedServerDisplay && !input.ui.selectedServerDisplayReady) { + return stoppedResult( + std::move(result), + LiteWalletServerLifecycleReadinessStatus::WaitingForDisplayStatus, + LiteWalletServerLifecycleReadinessIssue::SelectedServerDisplayMissing, + "selected lite server display status is not ready"); + } + result.selectedServerDisplayAccepted = true; + + if (options.requireLifecycleUiOwner && !input.ui.lifecycleUiOwnerReady) { + return stoppedResult( + std::move(result), + LiteWalletServerLifecycleReadinessStatus::WaitingForLifecycleUi, + LiteWalletServerLifecycleReadinessIssue::LifecycleUiOwnerMissing, + "lite wallet lifecycle UI owner is not ready"); + } + result.lifecycleUiOwnerAccepted = true; + + if (input.ui.realLifecycleExecutionRequested) { + return stoppedResult( + std::move(result), + LiteWalletServerLifecycleReadinessStatus::RuntimeExecutionDisabled, + LiteWalletServerLifecycleReadinessIssue::RealLifecycleExecutionRequested, + "real lite wallet lifecycle execution is disabled in this scaffold"); + } + + if (options.requireOperationConfirmation && !input.ui.operationConfirmed) { + return stoppedResult( + std::move(result), + LiteWalletServerLifecycleReadinessStatus::WaitingForLifecycleUi, + LiteWalletServerLifecycleReadinessIssue::LifecycleOperationUnconfirmed, + "lite wallet lifecycle operation requires explicit UI confirmation"); + } + + result.requestPlan = requestPlanForInput(input, result.selectedServer); + if (!result.requestPlan.ok) { + const auto issue = input.operation == LiteWalletLifecycleOperation::OpenExisting + ? LiteWalletServerLifecycleReadinessIssue::OpenWalletPathMissing + : LiteWalletServerLifecycleReadinessIssue::RestoreSeedMissing; + return stoppedResult( + std::move(result), + LiteWalletServerLifecycleReadinessStatus::WaitingForLifecycleUi, + issue, + result.requestPlan.error.empty() + ? "lite wallet lifecycle UI request is incomplete" + : result.requestPlan.error); + } + result.requestAccepted = true; + + if (options.requirePrivateDataRedaction && !input.ui.privateDataRedactionReady) { + return stoppedResult( + std::move(result), + LiteWalletServerLifecycleReadinessStatus::WaitingForPrivateDataRedaction, + LiteWalletServerLifecycleReadinessIssue::PrivateDataRedactionMissing, + "lite wallet lifecycle private-data redaction owner is not ready"); + } + result.privateDataRedactionAccepted = true; + + if (options.requireSyncPlannerFeed && !input.ui.syncPlannerFeedReady) { + return stoppedResult( + std::move(result), + LiteWalletServerLifecycleReadinessStatus::WaitingForSyncPlannerFeed, + LiteWalletServerLifecycleReadinessIssue::SyncPlannerFeedMissing, + "lite lifecycle readiness feed for sync planners is not ready"); + } + result.syncPlannerFeedAccepted = true; + + result.ok = true; + result.status = LiteWalletServerLifecycleReadinessStatus::ReadyForFutureLifecycle; + result.futureLifecycleCouldBeEnabled = true; + result.lifecycleReportCouldFeedSyncPlanners = true; + result.lifecycleStatus = readyLifecycleStatus(result.selectedServerDisplay); + result.syncLifecycleInput.ready = true; + result.syncLifecycleInput.status = result.lifecycleStatus; + return result; +} + +LiteWalletSyncAppRefreshLifecycleInput liteWalletSyncLifecycleInputFromServerLifecycleReadiness( + const LiteWalletServerLifecycleReadinessResult& result) +{ + return result.syncLifecycleInput; +} + +LiteWalletServerLifecycleReadinessPlanner::LiteWalletServerLifecycleReadinessPlanner( + LiteWalletServerLifecycleReadinessOptions options) + : options_(options) +{ +} + +LiteWalletServerLifecycleReadinessResult LiteWalletServerLifecycleReadinessPlanner::evaluate( + const LiteWalletServerLifecycleReadinessInput& input) const +{ + return evaluateLiteWalletServerLifecycleReadiness(input, options_); +} + +} // namespace dragonx::wallet \ No newline at end of file diff --git a/src/wallet/lite_wallet_server_lifecycle_readiness.h b/src/wallet/lite_wallet_server_lifecycle_readiness.h new file mode 100644 index 0000000..1db9e69 --- /dev/null +++ b/src/wallet/lite_wallet_server_lifecycle_readiness.h @@ -0,0 +1,197 @@ +#pragma once + +#include "lite_wallet_lifecycle_service.h" +#include "lite_wallet_sync_app_refresh_integration.h" + +#include +#include +#include + +namespace dragonx::wallet { + +enum class LiteWalletServerLifecycleReadinessStatus { + ReadyForFutureLifecycle, + WaitingForLiteBuild, + WaitingForBackendCapability, + WaitingForServerSelection, + WaitingForPersistenceIntent, + WaitingForDisplayStatus, + WaitingForLifecycleUi, + WaitingForPrivateDataRedaction, + WaitingForSyncPlannerFeed, + RuntimeExecutionDisabled, +}; + +enum class LiteWalletServerLifecycleReadinessIssue { + FullNodeBuild, + LiteBackendCapabilityMissing, + PersistedSettingsNotLoaded, + PersistedServerSelectionIntentMissing, + ServerSelectionMissing, + ServerPersistenceOwnerMissing, + SelectedServerDisplayMissing, + LifecycleUiOwnerMissing, + LifecycleOperationUnconfirmed, + OpenWalletPathMissing, + RestoreSeedMissing, + PrivateDataRedactionMissing, + SyncPlannerFeedMissing, + RealLifecycleExecutionRequested, +}; + +enum class LiteWalletSelectedServerDisplayStatus { + Hidden, + SelectedServer, + CustomServer, + Missing, +}; + +struct LiteWalletServerSelectionPersistenceInput { + bool settingsLoaded = false; + bool havePersistedSelectionIntent = false; + bool persistSelectedServer = false; + bool persistenceOwnerReady = false; +}; + +struct LiteWalletLifecycleUiPrerequisites { + bool selectedServerDisplayReady = false; + bool lifecycleUiOwnerReady = false; + bool operationConfirmed = false; + bool privateDataRedactionReady = false; + bool syncPlannerFeedReady = false; + bool realLifecycleExecutionRequested = false; +}; + +struct LiteWalletServerLifecycleReadinessInput { + WalletCapabilities capabilities; + LiteConnectionSettings settings; + LiteWalletLifecycleOperation operation = LiteWalletLifecycleOperation::CreateNew; + LiteWalletServerSelectionPersistenceInput persistence; + LiteWalletLifecycleUiPrerequisites ui; + LiteWalletCreateRequest createRequest; + LiteWalletOpenRequest openRequest; + LiteWalletRestoreRequest restoreRequest; +}; + +struct LiteWalletServerLifecycleReadinessOptions { + bool requireLiteBuild = true; + bool requireLiteBackendCapability = true; + bool requirePersistedSettingsLoaded = true; + bool requirePersistedSelectionIntent = true; + bool requireSelectedServerDisplay = true; + bool requireLifecycleUiOwner = true; + bool requireOperationConfirmation = true; + bool requirePrivateDataRedaction = true; + bool requireSyncPlannerFeed = true; +}; + +struct LiteWalletSelectedServerDisplayReport { + bool ok = false; + LiteWalletSelectedServerDisplayStatus status = LiteWalletSelectedServerDisplayStatus::Hidden; + std::string label; + std::string url; + std::size_t serverIndex = 0; + bool customServer = false; + std::string message; +}; + +struct LiteWalletServerSelectionPersistencePlan { + bool ok = false; + bool settingsLoaded = false; + bool persistedSelectionIntentAccepted = false; + bool wouldPersistSelectedServer = false; + bool persistenceOwnerAccepted = false; + bool settingsWritten = false; + LiteServerSelectionMode selectionMode = LiteServerSelectionMode::Sticky; + std::string selectedServerUrl; + std::size_t selectedServerIndex = 0; + bool selectedServerCustom = false; + std::string error; +}; + +struct LiteWalletLifecycleUiRequestPlan { + bool ok = false; + LiteWalletLifecycleOperation operation = LiteWalletLifecycleOperation::CreateNew; + LiteWalletLifecyclePlan lifecyclePlan; + std::vector privateData; + bool privateInputsRedacted = true; + std::string requestSummary; + std::string error; +}; + +struct LiteWalletServerLifecycleReadinessIssueInfo { + LiteWalletServerLifecycleReadinessIssue issue = LiteWalletServerLifecycleReadinessIssue::FullNodeBuild; + std::string message; +}; + +struct LiteWalletServerLifecycleReadinessResult { + bool ok = false; + bool dryRunOnly = true; + bool noNetwork = true; + bool noBridgeCalls = true; + bool noServerHealthChecked = true; + bool noWalletExistsChecked = true; + bool noWalletCreated = true; + bool noWalletOpened = true; + bool noWalletRestored = true; + bool noSyncStarted = true; + bool noSyncStatusPolled = true; + bool noWalletPersistence = true; + bool noSettingsPersistence = true; + bool settingsWritten = false; + bool workerQueueEnqueued = false; + bool stateMutationAllowed = false; + bool stateMutated = false; + bool walletStateWritten = false; + bool walletReady = false; + + bool liteBuildAccepted = false; + bool backendCapabilityAccepted = false; + bool serverSelectionAccepted = false; + bool persistenceIntentAccepted = false; + bool selectedServerDisplayAccepted = false; + bool lifecycleUiOwnerAccepted = false; + bool requestAccepted = false; + bool privateDataRedactionAccepted = false; + bool syncPlannerFeedAccepted = false; + bool futureLifecycleCouldBeEnabled = false; + bool lifecycleReportCouldFeedSyncPlanners = false; + + LiteWalletServerLifecycleReadinessStatus status = LiteWalletServerLifecycleReadinessStatus::WaitingForLiteBuild; + WalletCapabilities capabilities; + LiteServerSelectionResult selectedServer; + LiteWalletSelectedServerDisplayReport selectedServerDisplay; + LiteWalletServerSelectionPersistencePlan persistencePlan; + LiteWalletLifecycleUiRequestPlan requestPlan; + LiteWalletSyncAppRefreshLifecycleInput syncLifecycleInput; + WalletBackendStatus lifecycleStatus; + std::vector issues; + std::string error; +}; + +const char* liteWalletServerLifecycleReadinessStatusName( + LiteWalletServerLifecycleReadinessStatus status); +const char* liteWalletServerLifecycleReadinessIssueName( + LiteWalletServerLifecycleReadinessIssue issue); +const char* liteWalletSelectedServerDisplayStatusName( + LiteWalletSelectedServerDisplayStatus status); + +LiteWalletServerLifecycleReadinessResult evaluateLiteWalletServerLifecycleReadiness( + const LiteWalletServerLifecycleReadinessInput& input, + LiteWalletServerLifecycleReadinessOptions options = {}); +LiteWalletSyncAppRefreshLifecycleInput liteWalletSyncLifecycleInputFromServerLifecycleReadiness( + const LiteWalletServerLifecycleReadinessResult& result); + +class LiteWalletServerLifecycleReadinessPlanner { +public: + explicit LiteWalletServerLifecycleReadinessPlanner( + LiteWalletServerLifecycleReadinessOptions options = {}); + + LiteWalletServerLifecycleReadinessResult evaluate( + const LiteWalletServerLifecycleReadinessInput& input) const; + +private: + LiteWalletServerLifecycleReadinessOptions options_; +}; + +} // namespace dragonx::wallet \ No newline at end of file diff --git a/src/wallet/lite_wallet_server_selection_adapter.cpp b/src/wallet/lite_wallet_server_selection_adapter.cpp new file mode 100644 index 0000000..9f12a10 --- /dev/null +++ b/src/wallet/lite_wallet_server_selection_adapter.cpp @@ -0,0 +1,463 @@ +#include "lite_wallet_server_selection_adapter.h" + +#include +#include +#include +#include + +namespace dragonx { +namespace wallet { + +namespace { + +std::string trimCopy(const std::string& value) +{ + const auto first = std::find_if_not(value.begin(), value.end(), [](unsigned char ch) { + return std::isspace(ch) != 0; + }); + const auto last = std::find_if_not(value.rbegin(), value.rend(), [](unsigned char ch) { + return std::isspace(ch) != 0; + }).base(); + if (first >= last) return {}; + return std::string(first, last); +} + +LiteServerSelectionMode walletModeFromSettings( + config::Settings::LiteServerSelectionPreferenceMode mode) +{ + switch (mode) { + case config::Settings::LiteServerSelectionPreferenceMode::Sticky: + return LiteServerSelectionMode::Sticky; + case config::Settings::LiteServerSelectionPreferenceMode::Random: + return LiteServerSelectionMode::Random; + } + return LiteServerSelectionMode::Sticky; +} + +config::Settings::LiteServerSelectionPreferenceMode settingsModeFromWallet( + LiteServerSelectionMode mode) +{ + switch (mode) { + case LiteServerSelectionMode::Sticky: + return config::Settings::LiteServerSelectionPreferenceMode::Sticky; + case LiteServerSelectionMode::Random: + return config::Settings::LiteServerSelectionPreferenceMode::Random; + } + return config::Settings::LiteServerSelectionPreferenceMode::Sticky; +} + +void addIssue(std::vector& issues, + LiteWalletServerSelectionUiExecutionIssue issue, + std::string message) +{ + issues.push_back(LiteWalletServerSelectionUiExecutionIssueInfo{issue, std::move(message)}); +} + +LiteWalletServerSelectionUiExecutionStatus statusFromLifecycle( + LiteWalletServerLifecycleReadinessStatus status) +{ + switch (status) { + case LiteWalletServerLifecycleReadinessStatus::ReadyForFutureLifecycle: + return LiteWalletServerSelectionUiExecutionStatus::ReadyForFutureLifecycle; + case LiteWalletServerLifecycleReadinessStatus::WaitingForLiteBuild: + return LiteWalletServerSelectionUiExecutionStatus::WaitingForLiteBuild; + case LiteWalletServerLifecycleReadinessStatus::WaitingForBackendCapability: + return LiteWalletServerSelectionUiExecutionStatus::WaitingForBackendCapability; + case LiteWalletServerLifecycleReadinessStatus::WaitingForPersistenceIntent: + return LiteWalletServerSelectionUiExecutionStatus::WaitingForSettings; + case LiteWalletServerLifecycleReadinessStatus::WaitingForServerSelection: + return LiteWalletServerSelectionUiExecutionStatus::WaitingForServerSelection; + case LiteWalletServerLifecycleReadinessStatus::WaitingForDisplayStatus: + return LiteWalletServerSelectionUiExecutionStatus::WaitingForDisplayStatus; + case LiteWalletServerLifecycleReadinessStatus::WaitingForLifecycleUi: + return LiteWalletServerSelectionUiExecutionStatus::WaitingForLifecycleUi; + case LiteWalletServerLifecycleReadinessStatus::WaitingForPrivateDataRedaction: + return LiteWalletServerSelectionUiExecutionStatus::WaitingForPrivateDataRedaction; + case LiteWalletServerLifecycleReadinessStatus::WaitingForSyncPlannerFeed: + return LiteWalletServerSelectionUiExecutionStatus::WaitingForSyncPlannerFeed; + case LiteWalletServerLifecycleReadinessStatus::RuntimeExecutionDisabled: + return LiteWalletServerSelectionUiExecutionStatus::RuntimeExecutionDisabled; + } + return LiteWalletServerSelectionUiExecutionStatus::WaitingForSettings; +} + +LiteWalletServerSelectionUiExecutionIssue issueFromLifecycle( + LiteWalletServerLifecycleReadinessIssue issue) +{ + switch (issue) { + case LiteWalletServerLifecycleReadinessIssue::FullNodeBuild: + return LiteWalletServerSelectionUiExecutionIssue::FullNodeBuild; + case LiteWalletServerLifecycleReadinessIssue::LiteBackendCapabilityMissing: + return LiteWalletServerSelectionUiExecutionIssue::LiteBackendCapabilityMissing; + case LiteWalletServerLifecycleReadinessIssue::PersistedSettingsNotLoaded: + case LiteWalletServerLifecycleReadinessIssue::PersistedServerSelectionIntentMissing: + return LiteWalletServerSelectionUiExecutionIssue::SettingsNotLoaded; + case LiteWalletServerLifecycleReadinessIssue::ServerSelectionMissing: + return LiteWalletServerSelectionUiExecutionIssue::ServerSelectionMissing; + case LiteWalletServerLifecycleReadinessIssue::ServerPersistenceOwnerMissing: + return LiteWalletServerSelectionUiExecutionIssue::ServerPersistenceOwnerMissing; + case LiteWalletServerLifecycleReadinessIssue::SelectedServerDisplayMissing: + return LiteWalletServerSelectionUiExecutionIssue::SelectedServerDisplayMissing; + case LiteWalletServerLifecycleReadinessIssue::LifecycleUiOwnerMissing: + case LiteWalletServerLifecycleReadinessIssue::LifecycleOperationUnconfirmed: + case LiteWalletServerLifecycleReadinessIssue::OpenWalletPathMissing: + case LiteWalletServerLifecycleReadinessIssue::RestoreSeedMissing: + return LiteWalletServerSelectionUiExecutionIssue::LifecycleUiOwnerMissing; + case LiteWalletServerLifecycleReadinessIssue::PrivateDataRedactionMissing: + return LiteWalletServerSelectionUiExecutionIssue::PrivateDataRedactionMissing; + case LiteWalletServerLifecycleReadinessIssue::SyncPlannerFeedMissing: + return LiteWalletServerSelectionUiExecutionIssue::SyncPlannerFeedMissing; + case LiteWalletServerLifecycleReadinessIssue::RealLifecycleExecutionRequested: + return LiteWalletServerSelectionUiExecutionIssue::WalletLifecycleExecutionRequested; + } + return LiteWalletServerSelectionUiExecutionIssue::SettingsNotLoaded; +} + +void copyLifecycleIssues(LiteWalletServerSelectionUiExecutionResult& result) +{ + for (const auto& issue : result.lifecycleReadiness.issues) { + addIssue(result.issues, issueFromLifecycle(issue.issue), issue.message); + } +} + +LiteWalletServerSelectionUiExecutionResult stoppedResult( + LiteWalletServerSelectionUiExecutionResult result, + LiteWalletServerSelectionUiExecutionStatus status, + LiteWalletServerSelectionUiExecutionIssue issue, + const std::string& message) +{ + result.status = status; + result.error = message; + result.ok = false; + addIssue(result.issues, issue, message); + return result; +} + +std::string buildDiagnosticSummary(const LiteWalletServerSelectionUiExecutionResult& result) +{ + std::ostringstream out; + out << "mode=" << liteServerSelectionModeName(result.connectionSettings.selectionMode) + << ";server=" << result.selectedServerUrlRedacted + << ";settings_written=" << (result.settingsWritten ? "true" : "false") + << ";network=false;bridge=false;lifecycle=false;sync=false;wallet_state=false"; + return out.str(); +} + +LiteConnectionSettings settingsWithIntent(const LiteConnectionSettings& current, + const LiteWalletServerSelectionUiIntent& intent) +{ + LiteConnectionSettings settings = current; + if (!intent.selectedServerIntentProvided) return settings; + + settings.selectionMode = intent.selectionMode; + if (!intent.chainName.empty()) settings.chainName = trimCopy(intent.chainName); + if (intent.replaceServers) settings.servers = intent.servers; + + switch (intent.selectionMode) { + case LiteServerSelectionMode::Sticky: + settings.stickyServerUrl = trimCopy(intent.selectedServerUrl); + break; + case LiteServerSelectionMode::Random: + settings.randomSelectionSeed = intent.randomSelectionSeed; + break; + } + return settings; +} + +LiteWalletServerLifecycleReadinessInput makeLifecycleInput( + const LiteWalletServerSelectionUiExecutionInput& input, + const LiteConnectionSettings& connectionSettings) +{ + LiteWalletServerLifecycleReadinessInput lifecycle; + lifecycle.capabilities = input.capabilities; + lifecycle.settings = connectionSettings; + lifecycle.operation = input.operation; + lifecycle.persistence.settingsLoaded = input.persistence.settingsLoaded; + lifecycle.persistence.havePersistedSelectionIntent = + input.persistence.havePersistedSelectionIntent || input.intent.selectedServerIntentProvided; + lifecycle.persistence.persistSelectedServer = input.persistence.persistSelectedServer; + lifecycle.persistence.persistenceOwnerReady = input.persistence.persistenceOwnerReady; + lifecycle.ui = input.ui; + lifecycle.ui.realLifecycleExecutionRequested = + lifecycle.ui.realLifecycleExecutionRequested || input.walletLifecycleExecutionRequested; + lifecycle.createRequest = input.createRequest; + lifecycle.openRequest = input.openRequest; + lifecycle.restoreRequest = input.restoreRequest; + return lifecycle; +} + +} // namespace + +LiteConnectionSettings liteConnectionSettingsFromAppSettings(const config::Settings& settings) +{ + LiteConnectionSettings connectionSettings; + connectionSettings.servers.clear(); + for (const auto& server : settings.getLiteServers()) { + connectionSettings.servers.push_back(LiteServerEndpoint{ + trimCopy(server.url), + server.label, + server.enabled + }); + } + connectionSettings.selectionMode = walletModeFromSettings(settings.getLiteServerSelectionMode()); + connectionSettings.stickyServerUrl = trimCopy(settings.getLiteStickyServerUrl()); + connectionSettings.chainName = trimCopy(settings.getLiteChainName()); + if (connectionSettings.chainName.empty()) connectionSettings.chainName = kDragonXLiteChainName; + connectionSettings.randomSelectionSeed = settings.getLiteRandomSelectionSeed(); + return connectionSettings; +} + +void applyLiteConnectionSettingsToAppSettings(config::Settings& settings, + const LiteConnectionSettings& connectionSettings) +{ + std::vector servers; + servers.reserve(connectionSettings.servers.size()); + for (const auto& server : connectionSettings.servers) { + servers.push_back(config::Settings::LiteServerPreference{ + trimCopy(server.url), + server.label, + server.enabled + }); + } + + settings.setLiteServerSelectionMode(settingsModeFromWallet(connectionSettings.selectionMode)); + settings.setLiteStickyServerUrl(trimCopy(connectionSettings.stickyServerUrl)); + settings.setLiteChainName(trimCopy(connectionSettings.chainName).empty() + ? kDragonXLiteChainName + : trimCopy(connectionSettings.chainName)); + settings.setLiteRandomSelectionSeed(connectionSettings.randomSelectionSeed); + settings.setLiteServers(servers); +} + +const char* liteWalletServerSelectionUiExecutionStatusName( + LiteWalletServerSelectionUiExecutionStatus status) +{ + switch (status) { + case LiteWalletServerSelectionUiExecutionStatus::ReadyForFutureLifecycle: + return "ReadyForFutureLifecycle"; + case LiteWalletServerSelectionUiExecutionStatus::WaitingForLiteBuild: + return "WaitingForLiteBuild"; + case LiteWalletServerSelectionUiExecutionStatus::WaitingForBackendCapability: + return "WaitingForBackendCapability"; + case LiteWalletServerSelectionUiExecutionStatus::WaitingForSettings: + return "WaitingForSettings"; + case LiteWalletServerSelectionUiExecutionStatus::WaitingForServerSelection: + return "WaitingForServerSelection"; + case LiteWalletServerSelectionUiExecutionStatus::WaitingForPersistenceOwner: + return "WaitingForPersistenceOwner"; + case LiteWalletServerSelectionUiExecutionStatus::WaitingForDisplayStatus: + return "WaitingForDisplayStatus"; + case LiteWalletServerSelectionUiExecutionStatus::WaitingForLifecycleUi: + return "WaitingForLifecycleUi"; + case LiteWalletServerSelectionUiExecutionStatus::WaitingForPrivateDataRedaction: + return "WaitingForPrivateDataRedaction"; + case LiteWalletServerSelectionUiExecutionStatus::WaitingForSyncPlannerFeed: + return "WaitingForSyncPlannerFeed"; + case LiteWalletServerSelectionUiExecutionStatus::SettingsSaveFailed: + return "SettingsSaveFailed"; + case LiteWalletServerSelectionUiExecutionStatus::RuntimeExecutionDisabled: + return "RuntimeExecutionDisabled"; + } + return "WaitingForSettings"; +} + +const char* liteWalletServerSelectionUiExecutionIssueName( + LiteWalletServerSelectionUiExecutionIssue issue) +{ + switch (issue) { + case LiteWalletServerSelectionUiExecutionIssue::FullNodeBuild: + return "FullNodeBuild"; + case LiteWalletServerSelectionUiExecutionIssue::LiteBackendCapabilityMissing: + return "LiteBackendCapabilityMissing"; + case LiteWalletServerSelectionUiExecutionIssue::SettingsNotLoaded: + return "SettingsNotLoaded"; + case LiteWalletServerSelectionUiExecutionIssue::ServerSelectionMissing: + return "ServerSelectionMissing"; + case LiteWalletServerSelectionUiExecutionIssue::ServerPersistenceOwnerMissing: + return "ServerPersistenceOwnerMissing"; + case LiteWalletServerSelectionUiExecutionIssue::SelectedServerDisplayMissing: + return "SelectedServerDisplayMissing"; + case LiteWalletServerSelectionUiExecutionIssue::LifecycleUiOwnerMissing: + return "LifecycleUiOwnerMissing"; + case LiteWalletServerSelectionUiExecutionIssue::PrivateDataRedactionMissing: + return "PrivateDataRedactionMissing"; + case LiteWalletServerSelectionUiExecutionIssue::SyncPlannerFeedMissing: + return "SyncPlannerFeedMissing"; + case LiteWalletServerSelectionUiExecutionIssue::SettingsSaveFailed: + return "SettingsSaveFailed"; + case LiteWalletServerSelectionUiExecutionIssue::ServerConnectivityCheckRequested: + return "ServerConnectivityCheckRequested"; + case LiteWalletServerSelectionUiExecutionIssue::WalletLifecycleExecutionRequested: + return "WalletLifecycleExecutionRequested"; + case LiteWalletServerSelectionUiExecutionIssue::SyncRequested: + return "SyncRequested"; + case LiteWalletServerSelectionUiExecutionIssue::SyncStatusPollingRequested: + return "SyncStatusPollingRequested"; + case LiteWalletServerSelectionUiExecutionIssue::WorkerQueueRequested: + return "WorkerQueueRequested"; + case LiteWalletServerSelectionUiExecutionIssue::WalletStateMutationRequested: + return "WalletStateMutationRequested"; + case LiteWalletServerSelectionUiExecutionIssue::WalletFilePersistenceRequested: + return "WalletFilePersistenceRequested"; + case LiteWalletServerSelectionUiExecutionIssue::SendImportExportRequested: + return "SendImportExportRequested"; + } + return "SettingsNotLoaded"; +} + +std::string redactLiteServerSelectionValue(const std::string& value) +{ + const std::string trimmed = trimCopy(value); + if (trimmed.empty()) return ""; + const auto scheme = trimmed.find("://"); + if (scheme == std::string::npos) return ""; + return trimmed.substr(0, scheme + 3) + ""; +} + +LiteWalletServerSelectionUiExecutionResult executeLiteWalletServerSelectionUi( + config::Settings& settings, + const LiteWalletServerSelectionUiExecutionInput& input) +{ + LiteWalletServerSelectionUiExecutionResult result; + + auto stopForRuntime = [&](LiteWalletServerSelectionUiExecutionIssue issue, + const std::string& message) { + return stoppedResult(std::move(result), + LiteWalletServerSelectionUiExecutionStatus::RuntimeExecutionDisabled, + issue, + message); + }; + + if (input.serverConnectivityCheckRequested) { + return stopForRuntime(LiteWalletServerSelectionUiExecutionIssue::ServerConnectivityCheckRequested, + "lite server selection settings adapter cannot check server connectivity"); + } + if (input.walletExistsCheckRequested) { + return stopForRuntime(LiteWalletServerSelectionUiExecutionIssue::ServerConnectivityCheckRequested, + "lite server selection settings adapter cannot check wallet existence"); + } + if (input.walletLifecycleExecutionRequested || input.ui.realLifecycleExecutionRequested) { + return stopForRuntime(LiteWalletServerSelectionUiExecutionIssue::WalletLifecycleExecutionRequested, + "lite server selection settings adapter cannot execute wallet lifecycle actions"); + } + if (input.syncStartRequested) { + return stopForRuntime(LiteWalletServerSelectionUiExecutionIssue::SyncRequested, + "lite server selection settings adapter cannot start sync"); + } + if (input.syncStatusPollingRequested) { + return stopForRuntime(LiteWalletServerSelectionUiExecutionIssue::SyncStatusPollingRequested, + "lite server selection settings adapter cannot poll syncstatus"); + } + if (input.workerQueueEnqueueRequested) { + return stopForRuntime(LiteWalletServerSelectionUiExecutionIssue::WorkerQueueRequested, + "lite server selection settings adapter cannot enqueue wallet workers"); + } + if (input.walletStateMutationRequested) { + return stopForRuntime(LiteWalletServerSelectionUiExecutionIssue::WalletStateMutationRequested, + "lite server selection settings adapter cannot mutate WalletState"); + } + if (input.walletFilePersistenceRequested) { + return stopForRuntime(LiteWalletServerSelectionUiExecutionIssue::WalletFilePersistenceRequested, + "lite server selection settings adapter cannot persist wallet files"); + } + if (input.sendImportExportExecutionRequested) { + return stopForRuntime(LiteWalletServerSelectionUiExecutionIssue::SendImportExportRequested, + "lite server selection settings adapter cannot execute send/import/export flows"); + } + + if (!input.persistence.settingsLoaded) { + return stoppedResult(std::move(result), + LiteWalletServerSelectionUiExecutionStatus::WaitingForSettings, + LiteWalletServerSelectionUiExecutionIssue::SettingsNotLoaded, + "lite server settings are not loaded"); + } + + result.connectionSettings = settingsWithIntent( + liteConnectionSettingsFromAppSettings(settings), input.intent); + if (input.intent.selectedServerIntentProvided && + input.intent.selectionMode == LiteServerSelectionMode::Sticky && + !isLiteServerUrlUsable(trimCopy(input.intent.selectedServerUrl))) { + result.selectedServerUrlRedacted = redactLiteServerSelectionValue(input.intent.selectedServerUrl); + result.selectedServerRedacted = true; + return stoppedResult(std::move(result), + LiteWalletServerSelectionUiExecutionStatus::WaitingForServerSelection, + LiteWalletServerSelectionUiExecutionIssue::ServerSelectionMissing, + "lite server selection URL is not usable"); + } + result.selectedServer = selectLiteServer(result.connectionSettings); + result.selectedServerUrlRedacted = result.selectedServer.ok + ? redactLiteServerSelectionValue(result.selectedServer.server.url) + : redactLiteServerSelectionValue(result.connectionSettings.stickyServerUrl); + result.selectedServerRedacted = true; + + if (!result.selectedServer.ok) { + return stoppedResult(std::move(result), + LiteWalletServerSelectionUiExecutionStatus::WaitingForServerSelection, + LiteWalletServerSelectionUiExecutionIssue::ServerSelectionMissing, + result.selectedServer.error.empty() + ? "lite server selection is missing" + : result.selectedServer.error); + } + result.selectedServerIntentAccepted = true; + + if ((input.persistence.persistSelectedServer || input.persistence.writeSettings) && + !input.persistence.persistenceOwnerReady) { + return stoppedResult(std::move(result), + LiteWalletServerSelectionUiExecutionStatus::WaitingForPersistenceOwner, + LiteWalletServerSelectionUiExecutionIssue::ServerPersistenceOwnerMissing, + "lite server settings persistence owner is not ready"); + } + result.settingsPersistenceAccepted = true; + + if (input.persistence.persistSelectedServer || input.persistence.writeSettings) { + applyLiteConnectionSettingsToAppSettings(settings, result.connectionSettings); + settings.setLitePersistSelectedServer(input.persistence.persistSelectedServer); + result.settingsMutated = true; + } + + if (input.persistence.writeSettings) { + result.noSettingsPersistence = false; + const bool saved = input.persistence.settingsSavePath.empty() + ? settings.save() + : settings.save(input.persistence.settingsSavePath); + if (!saved) { + return stoppedResult(std::move(result), + LiteWalletServerSelectionUiExecutionStatus::SettingsSaveFailed, + LiteWalletServerSelectionUiExecutionIssue::SettingsSaveFailed, + "failed to save lite server settings"); + } + result.settingsWritten = true; + } + + result.lifecycleInput = makeLifecycleInput(input, result.connectionSettings); + result.lifecycleReadiness = evaluateLiteWalletServerLifecycleReadiness(result.lifecycleInput); + result.lifecycleReadinessAccepted = result.lifecycleReadiness.ok; + result.lifecycleReportCouldFeedSyncPlanners = result.lifecycleReadiness.lifecycleReportCouldFeedSyncPlanners; + result.status = statusFromLifecycle(result.lifecycleReadiness.status); + copyLifecycleIssues(result); + result.diagnosticSummary = buildDiagnosticSummary(result); + + if (input.requireLifecycleReadiness && !result.lifecycleReadiness.ok) { + result.ok = false; + result.error = result.lifecycleReadiness.error; + return result; + } + + result.ok = true; + return result; +} + +LiteWalletServerSelectionUiExecutionAdapter::LiteWalletServerSelectionUiExecutionAdapter( + config::Settings& settings) + : settings_(settings) +{ +} + +LiteWalletServerSelectionUiExecutionResult LiteWalletServerSelectionUiExecutionAdapter::execute( + const LiteWalletServerSelectionUiExecutionInput& input) const +{ + return executeLiteWalletServerSelectionUi(settings_, input); +} + +} // namespace wallet +} // namespace dragonx \ No newline at end of file diff --git a/src/wallet/lite_wallet_server_selection_adapter.h b/src/wallet/lite_wallet_server_selection_adapter.h new file mode 100644 index 0000000..b2a848b --- /dev/null +++ b/src/wallet/lite_wallet_server_selection_adapter.h @@ -0,0 +1,161 @@ +#pragma once + +#include "lite_connection_service.h" +#include "lite_wallet_server_lifecycle_readiness.h" +#include "wallet_capabilities.h" + +#include "../config/settings.h" + +#include +#include +#include + +namespace dragonx { +namespace wallet { + +enum class LiteWalletServerSelectionUiExecutionStatus { + ReadyForFutureLifecycle, + WaitingForLiteBuild, + WaitingForBackendCapability, + WaitingForSettings, + WaitingForServerSelection, + WaitingForPersistenceOwner, + WaitingForDisplayStatus, + WaitingForLifecycleUi, + WaitingForPrivateDataRedaction, + WaitingForSyncPlannerFeed, + SettingsSaveFailed, + RuntimeExecutionDisabled +}; + +enum class LiteWalletServerSelectionUiExecutionIssue { + FullNodeBuild, + LiteBackendCapabilityMissing, + SettingsNotLoaded, + ServerSelectionMissing, + ServerPersistenceOwnerMissing, + SelectedServerDisplayMissing, + LifecycleUiOwnerMissing, + PrivateDataRedactionMissing, + SyncPlannerFeedMissing, + SettingsSaveFailed, + ServerConnectivityCheckRequested, + WalletLifecycleExecutionRequested, + SyncRequested, + SyncStatusPollingRequested, + WorkerQueueRequested, + WalletStateMutationRequested, + WalletFilePersistenceRequested, + SendImportExportRequested +}; + +struct LiteWalletServerSelectionUiIntent { + bool selectedServerIntentProvided = false; + LiteServerSelectionMode selectionMode = LiteServerSelectionMode::Sticky; + std::string selectedServerUrl; + std::size_t randomSelectionSeed = 0; + std::string chainName; + bool replaceServers = false; + std::vector servers; +}; + +struct LiteWalletServerSelectionPersistenceExecutionInput { + bool settingsLoaded = true; + bool havePersistedSelectionIntent = true; + bool persistSelectedServer = true; + bool persistenceOwnerReady = true; + bool writeSettings = false; + std::string settingsSavePath; +}; + +struct LiteWalletServerSelectionUiExecutionInput { + WalletCapabilities capabilities; + LiteWalletServerSelectionUiIntent intent; + LiteWalletServerSelectionPersistenceExecutionInput persistence; + LiteWalletLifecycleUiPrerequisites ui; + LiteWalletLifecycleOperation operation = LiteWalletLifecycleOperation::CreateNew; + LiteWalletCreateRequest createRequest; + LiteWalletOpenRequest openRequest; + LiteWalletRestoreRequest restoreRequest; + bool requireLifecycleReadiness = false; + + bool serverConnectivityCheckRequested = false; + bool walletExistsCheckRequested = false; + bool walletLifecycleExecutionRequested = false; + bool syncStartRequested = false; + bool syncStatusPollingRequested = false; + bool workerQueueEnqueueRequested = false; + bool walletStateMutationRequested = false; + bool walletFilePersistenceRequested = false; + bool sendImportExportExecutionRequested = false; +}; + +struct LiteWalletServerSelectionUiExecutionIssueInfo { + LiteWalletServerSelectionUiExecutionIssue issue = LiteWalletServerSelectionUiExecutionIssue::SettingsNotLoaded; + std::string message; +}; + +struct LiteWalletServerSelectionUiExecutionResult { + bool ok = false; + bool dryRunOnly = true; + bool noNetwork = true; + bool noBridgeCalls = true; + bool noServerHealthChecked = true; + bool noWalletExistsChecked = true; + bool noWalletCreated = true; + bool noWalletOpened = true; + bool noWalletRestored = true; + bool noSyncStarted = true; + bool noSyncStatusPolled = true; + bool noWalletPersistence = true; + bool noSendImportExportExecution = true; + bool workerQueueEnqueued = false; + bool stateMutationAllowed = false; + bool stateMutated = false; + bool walletStateWritten = false; + bool settingsMutationAllowed = true; + bool settingsMutated = false; + bool noSettingsPersistence = true; + bool settingsWritten = false; + bool settingsPersistenceAccepted = false; + bool selectedServerIntentAccepted = false; + bool lifecycleReadinessAccepted = false; + bool lifecycleReportCouldFeedSyncPlanners = false; + bool selectedServerRedacted = false; + LiteWalletServerSelectionUiExecutionStatus status = LiteWalletServerSelectionUiExecutionStatus::WaitingForSettings; + std::string error; + std::string selectedServerUrlRedacted; + std::string diagnosticSummary; + LiteConnectionSettings connectionSettings; + LiteServerSelectionResult selectedServer; + LiteWalletServerLifecycleReadinessInput lifecycleInput; + LiteWalletServerLifecycleReadinessResult lifecycleReadiness; + std::vector issues; +}; + +LiteConnectionSettings liteConnectionSettingsFromAppSettings(const config::Settings& settings); +void applyLiteConnectionSettingsToAppSettings(config::Settings& settings, + const LiteConnectionSettings& connectionSettings); +const char* liteWalletServerSelectionUiExecutionStatusName( + LiteWalletServerSelectionUiExecutionStatus status); +const char* liteWalletServerSelectionUiExecutionIssueName( + LiteWalletServerSelectionUiExecutionIssue issue); +std::string redactLiteServerSelectionValue(const std::string& value); + +LiteWalletServerSelectionUiExecutionResult executeLiteWalletServerSelectionUi( + config::Settings& settings, + const LiteWalletServerSelectionUiExecutionInput& input); + +class LiteWalletServerSelectionUiExecutionAdapter { +public: + explicit LiteWalletServerSelectionUiExecutionAdapter(config::Settings& settings); + + LiteWalletServerSelectionUiExecutionResult execute( + const LiteWalletServerSelectionUiExecutionInput& input) const; + +private: + config::Settings& settings_; +}; + +} // namespace wallet +} // namespace dragonx \ No newline at end of file diff --git a/src/wallet/lite_wallet_state_apply_executor.cpp b/src/wallet/lite_wallet_state_apply_executor.cpp new file mode 100644 index 0000000..81d3d93 --- /dev/null +++ b/src/wallet/lite_wallet_state_apply_executor.cpp @@ -0,0 +1,118 @@ +#include "wallet/lite_wallet_state_apply_executor.h" + +#include + +namespace dragonx::wallet { +namespace { + +void addIssue(LiteWalletStateApplyExecutionResult& result, + LiteWalletStateApplyExecutionIssue issue, + std::string message) +{ + result.issues.push_back(LiteWalletStateApplyExecutionIssueInfo{issue, std::move(message)}); +} + +std::size_t countPlannedChanges(const LiteWalletStateApplyPlan& plan) +{ + std::size_t count = 0; + for (const auto& fieldPlan : plan.fieldPlans) { + if (fieldPlan.wouldChange) ++count; + } + for (const auto& collectionPlan : plan.collectionPlans) { + if (collectionPlan.wouldReplace) ++count; + } + return count; +} + +LiteWalletStateApplyExecutionResult baseResult(const LiteWalletStateApplyPlan& plan, + LiteWalletStateApplyExecutorOptions options) +{ + LiteWalletStateApplyExecutionResult result; + result.stateMutationRequested = options.requestStateMutation; + result.stateMutationAllowed = false; + result.applyImplemented = false; + result.fieldPlanCount = plan.fieldPlans.size(); + result.collectionPlanCount = plan.collectionPlans.size(); + result.plannedChangeCount = countPlannedChanges(plan); + result.planIssueCount = plan.issues.size(); + return result; +} + +} // namespace + +const char* liteWalletStateApplyExecutionStatusName(LiteWalletStateApplyExecutionStatus status) +{ + switch (status) { + case LiteWalletStateApplyExecutionStatus::Disabled: return "Disabled"; + case LiteWalletStateApplyExecutionStatus::Rejected: return "Rejected"; + case LiteWalletStateApplyExecutionStatus::ImplementationMissing: return "ImplementationMissing"; + } + return "Unknown"; +} + +const char* liteWalletStateApplyExecutionIssueName(LiteWalletStateApplyExecutionIssue issue) +{ + switch (issue) { + case LiteWalletStateApplyExecutionIssue::InvalidPlan: return "InvalidPlan"; + case LiteWalletStateApplyExecutionIssue::MutablePlanRejected: return "MutablePlanRejected"; + case LiteWalletStateApplyExecutionIssue::StateMutationDisabled: return "StateMutationDisabled"; + case LiteWalletStateApplyExecutionIssue::StateMutationImplementationMissing: return "StateMutationImplementationMissing"; + } + return "Unknown"; +} + +LiteWalletStateApplyExecutionResult executeLiteWalletStateApplyPlan( + const LiteWalletStateApplyPlan& plan, + LiteWalletStateApplyExecutorOptions options) +{ + auto result = baseResult(plan, options); + + if (!plan.ok) { + result.status = LiteWalletStateApplyExecutionStatus::Rejected; + addIssue(result, + LiteWalletStateApplyExecutionIssue::InvalidPlan, + "lite WalletState apply plan is not valid"); + result.error = plan.error.empty() ? result.issues.back().message : plan.error; + return result; + } + + if (!plan.dryRunOnly || plan.applyImplemented || plan.stateMutationAllowed) { + result.status = LiteWalletStateApplyExecutionStatus::Rejected; + addIssue(result, + LiteWalletStateApplyExecutionIssue::MutablePlanRejected, + "lite WalletState apply executor accepts dry-run-only plans only"); + result.error = result.issues.back().message; + return result; + } + + result.planAccepted = true; + + if (options.requestStateMutation) { + result.status = LiteWalletStateApplyExecutionStatus::ImplementationMissing; + addIssue(result, + LiteWalletStateApplyExecutionIssue::StateMutationImplementationMissing, + "real lite WalletState application requires a future explicit implementation"); + result.error = result.issues.back().message; + return result; + } + + result.ok = true; + result.status = LiteWalletStateApplyExecutionStatus::Disabled; + addIssue(result, + LiteWalletStateApplyExecutionIssue::StateMutationDisabled, + "lite WalletState application is disabled; dry-run plan was accepted for reporting only"); + return result; +} + +LiteWalletStateApplyExecutor::LiteWalletStateApplyExecutor(LiteWalletStateApplyExecutorOptions options) + : options_(options) +{ +} + +LiteWalletStateApplyExecutionResult LiteWalletStateApplyExecutor::execute( + const LiteWalletStateApplyPlan& plan) const +{ + return executeLiteWalletStateApplyPlan(plan, options_); +} + +} // namespace dragonx::wallet \ No newline at end of file diff --git a/src/wallet/lite_wallet_state_apply_executor.h b/src/wallet/lite_wallet_state_apply_executor.h new file mode 100644 index 0000000..c213e91 --- /dev/null +++ b/src/wallet/lite_wallet_state_apply_executor.h @@ -0,0 +1,71 @@ +#pragma once + +#include "lite_wallet_state_apply_plan.h" + +#include +#include +#include + +namespace dragonx::wallet { + +enum class LiteWalletStateApplyExecutionStatus { + Disabled, + Rejected, + ImplementationMissing, +}; + +enum class LiteWalletStateApplyExecutionIssue { + InvalidPlan, + MutablePlanRejected, + StateMutationDisabled, + StateMutationImplementationMissing, +}; + +struct LiteWalletStateApplyExecutorOptions { + bool requestStateMutation = false; +}; + +struct LiteWalletStateApplyExecutionIssueInfo { + LiteWalletStateApplyExecutionIssue issue = LiteWalletStateApplyExecutionIssue::StateMutationDisabled; + std::string message; +}; + +struct LiteWalletStateApplyExecutionResult { + bool ok = false; + bool planAccepted = false; + bool attempted = false; + bool applied = false; + bool stateMutated = false; + bool dryRunOnly = true; + bool noNetwork = true; + bool stateMutationRequested = false; + bool stateMutationAllowed = false; + bool applyImplemented = false; + + LiteWalletStateApplyExecutionStatus status = LiteWalletStateApplyExecutionStatus::Disabled; + std::size_t fieldPlanCount = 0; + std::size_t collectionPlanCount = 0; + std::size_t plannedChangeCount = 0; + std::size_t planIssueCount = 0; + std::vector issues; + std::string error; +}; + +const char* liteWalletStateApplyExecutionStatusName(LiteWalletStateApplyExecutionStatus status); +const char* liteWalletStateApplyExecutionIssueName(LiteWalletStateApplyExecutionIssue issue); + +LiteWalletStateApplyExecutionResult executeLiteWalletStateApplyPlan( + const LiteWalletStateApplyPlan& plan, + LiteWalletStateApplyExecutorOptions options = {}); + +class LiteWalletStateApplyExecutor { +public: + explicit LiteWalletStateApplyExecutor(LiteWalletStateApplyExecutorOptions options = {}); + + LiteWalletStateApplyExecutionResult execute(const LiteWalletStateApplyPlan& plan) const; + +private: + LiteWalletStateApplyExecutorOptions options_; +}; + +} // namespace dragonx::wallet \ No newline at end of file diff --git a/src/wallet/lite_wallet_state_apply_plan.cpp b/src/wallet/lite_wallet_state_apply_plan.cpp new file mode 100644 index 0000000..0641b1a --- /dev/null +++ b/src/wallet/lite_wallet_state_apply_plan.cpp @@ -0,0 +1,405 @@ +#include "wallet/lite_wallet_state_apply_plan.h" + +#include +#include +#include +#include +#include + +namespace dragonx::wallet { +namespace { + +constexpr double kZatoshisPerCoin = 100000000.0; + +std::string stringValue(const std::string& value) +{ + return value; +} + +std::string intValue(std::int64_t value) +{ + return std::to_string(value); +} + +std::string uintValue(std::uint64_t value) +{ + return std::to_string(value); +} + +std::string doubleValue(double value) +{ + std::ostringstream output; + output << value; + return output.str(); +} + +std::string boolValue(bool value) +{ + return value ? "true" : "false"; +} + +std::uint64_t coinsToZatoshis(double coins) +{ + if (coins <= 0.0) return 0; + const double zatoshis = std::round(coins * kZatoshisPerCoin); + const double maxValue = static_cast(std::numeric_limits::max()); + if (zatoshis >= maxValue) return std::numeric_limits::max(); + return static_cast(zatoshis); +} + +bool modelHasAnySection(const LiteWalletAppRefreshModel& model) +{ + return model.hasChainInfo || model.hasHeight || model.hasBalance || model.hasAddresses || + model.hasSpendableOutputs || model.hasTransactions || model.hasSyncStatus; +} + +void addIssue(LiteWalletStateApplyPlan& plan, + LiteWalletStateApplyIssue issue, + std::string message) +{ + plan.issues.push_back(LiteWalletStateApplyIssueInfo{issue, std::move(message)}); +} + +void addFieldPlan(LiteWalletStateApplyPlan& plan, + LiteWalletStateApplySection section, + const std::string& fieldName, + std::string currentValue, + std::string proposedValue) +{ + LiteWalletStateApplyFieldPlan fieldPlan; + fieldPlan.section = section; + fieldPlan.fieldName = fieldName; + fieldPlan.currentValue = std::move(currentValue); + fieldPlan.proposedValue = std::move(proposedValue); + fieldPlan.wouldChange = fieldPlan.currentValue != fieldPlan.proposedValue; + fieldPlan.action = fieldPlan.wouldChange + ? LiteWalletStateApplyAction::SetField + : LiteWalletStateApplyAction::Noop; + if (fieldPlan.wouldChange) plan.wouldChangeWalletState = true; + plan.fieldPlans.push_back(std::move(fieldPlan)); +} + +void addCollectionPlan(LiteWalletStateApplyPlan& plan, + LiteWalletStateApplySection section, + std::string collectionName, + std::size_t currentCount, + std::size_t proposedCount, + bool hasWalletStateTarget, + bool wouldReplace) +{ + LiteWalletStateApplyCollectionPlan collectionPlan; + collectionPlan.section = section; + collectionPlan.collectionName = std::move(collectionName); + collectionPlan.currentCount = currentCount; + collectionPlan.proposedCount = proposedCount; + collectionPlan.hasWalletStateTarget = hasWalletStateTarget; + collectionPlan.wouldReplace = hasWalletStateTarget && wouldReplace; + if (!hasWalletStateTarget) { + collectionPlan.action = LiteWalletStateApplyAction::InspectOnly; + } else { + collectionPlan.action = collectionPlan.wouldReplace + ? LiteWalletStateApplyAction::ReplaceCollection + : LiteWalletStateApplyAction::Noop; + } + if (collectionPlan.wouldReplace) plan.wouldChangeWalletState = true; + plan.collectionPlans.push_back(std::move(collectionPlan)); +} + +std::vector mappedAddresses(const LiteWalletAppRefreshModel& model, + LiteWalletAppAddressKind kind) +{ + std::vector addresses; + for (const auto& address : model.addresses) { + if (address.kind == kind) addresses.push_back(address.address); + } + return addresses; +} + +std::vector mappedAddressStrings(const LiteWalletAppRefreshModel& model) +{ + std::vector addresses; + addresses.reserve(model.addresses.size()); + for (const auto& address : model.addresses) addresses.push_back(address.address); + return addresses; +} + +std::vector stateAddressStrings(const std::vector& addresses) +{ + std::vector values; + values.reserve(addresses.size()); + for (const auto& address : addresses) values.push_back(address.address); + return values; +} + +std::vector mappedTransactionIds(const LiteWalletAppRefreshModel& model) +{ + std::vector txids; + txids.reserve(model.transactions.size()); + for (const auto& transaction : model.transactions) txids.push_back(transaction.txid); + return txids; +} + +std::vector stateTransactionIds(const std::vector& transactions) +{ + std::vector txids; + txids.reserve(transactions.size()); + for (const auto& transaction : transactions) txids.push_back(transaction.txid); + return txids; +} + +void addChainInfoPlans(LiteWalletStateApplyPlan& plan, + const LiteWalletAppRefreshModel& model, + const dragonx::WalletState& state) +{ + if (!model.hasChainInfo) return; + plan.hasChainInfo = true; + + if (model.chain.longestChain) { + addFieldPlan(plan, + LiteWalletStateApplySection::ChainInfo, + "longestchain", + intValue(state.longestchain), + intValue(*model.chain.longestChain)); + } + if (model.chain.notarized) { + addFieldPlan(plan, + LiteWalletStateApplySection::ChainInfo, + "notarized", + intValue(state.notarized), + intValue(*model.chain.notarized)); + } + if (model.chain.chainName) { + addFieldPlan(plan, + LiteWalletStateApplySection::ChainInfo, + "chain_name", + stringValue(state.mining.chain), + stringValue(*model.chain.chainName)); + } +} + +void addHeightPlans(LiteWalletStateApplyPlan& plan, + const LiteWalletAppRefreshModel& model, + const dragonx::WalletState& state) +{ + if (!model.hasHeight) return; + plan.hasHeight = true; + addFieldPlan(plan, + LiteWalletStateApplySection::Height, + "sync.blocks", + intValue(state.sync.blocks), + intValue(model.height.height)); +} + +void addBalancePlans(LiteWalletStateApplyPlan& plan, + const LiteWalletAppRefreshModel& model, + const dragonx::WalletState& state) +{ + if (!model.hasBalance) return; + plan.hasBalance = true; + addFieldPlan(plan, + LiteWalletStateApplySection::Balance, + "privateBalanceZatoshis", + uintValue(coinsToZatoshis(state.privateBalance)), + uintValue(model.balance.shieldedZatoshis)); + addFieldPlan(plan, + LiteWalletStateApplySection::Balance, + "transparentBalanceZatoshis", + uintValue(coinsToZatoshis(state.transparentBalance)), + uintValue(model.balance.transparentZatoshis)); + addFieldPlan(plan, + LiteWalletStateApplySection::Balance, + "totalBalanceZatoshis", + uintValue(coinsToZatoshis(state.totalBalance)), + uintValue(model.balance.totalZatoshis)); + addFieldPlan(plan, + LiteWalletStateApplySection::Balance, + "unconfirmedBalanceZatoshis", + uintValue(coinsToZatoshis(state.unconfirmedBalance)), + uintValue(model.balance.unconfirmedZatoshis)); +} + +void addAddressPlans(LiteWalletStateApplyPlan& plan, + const LiteWalletAppRefreshModel& model, + const dragonx::WalletState& state) +{ + if (!model.hasAddresses) return; + plan.hasAddresses = true; + + const auto proposedShielded = mappedAddresses(model, LiteWalletAppAddressKind::Shielded); + const auto proposedTransparent = mappedAddresses(model, LiteWalletAppAddressKind::Transparent); + const auto proposedCombined = mappedAddressStrings(model); + const auto currentShielded = stateAddressStrings(state.z_addresses); + const auto currentTransparent = stateAddressStrings(state.t_addresses); + const auto currentCombined = stateAddressStrings(state.addresses); + + addCollectionPlan(plan, + LiteWalletStateApplySection::Addresses, + "z_addresses", + currentShielded.size(), + proposedShielded.size(), + true, + currentShielded != proposedShielded); + addCollectionPlan(plan, + LiteWalletStateApplySection::Addresses, + "t_addresses", + currentTransparent.size(), + proposedTransparent.size(), + true, + currentTransparent != proposedTransparent); + addCollectionPlan(plan, + LiteWalletStateApplySection::Addresses, + "addresses", + currentCombined.size(), + proposedCombined.size(), + true, + currentCombined != proposedCombined); + + const auto unknownSpendability = std::any_of(model.addresses.begin(), model.addresses.end(), + [](const LiteWalletAppAddressModel& address) { return !address.spendabilityKnown; }); + if (unknownSpendability) { + addIssue(plan, + LiteWalletStateApplyIssue::AddressSpendabilityUnknown, + "lite address rows do not yet carry wallet spendability policy"); + } +} + +void addSpendableOutputPlans(LiteWalletStateApplyPlan& plan, + const LiteWalletAppRefreshModel& model) +{ + if (!model.hasSpendableOutputs) return; + plan.hasSpendableOutputs = true; + addCollectionPlan(plan, + LiteWalletStateApplySection::SpendableOutputs, + "spendableOutputs", + 0, + model.spendableOutputs.size(), + false, + false); + addIssue(plan, + LiteWalletStateApplyIssue::SpendableOutputsHaveNoWalletStateTarget, + "lite spendable outputs remain source-only until an app apply target is designed"); +} + +void addTransactionPlans(LiteWalletStateApplyPlan& plan, + const LiteWalletAppRefreshModel& model, + const dragonx::WalletState& state) +{ + if (!model.hasTransactions) return; + plan.hasTransactions = true; + const auto proposedTxids = mappedTransactionIds(model); + const auto currentTxids = stateTransactionIds(state.transactions); + addCollectionPlan(plan, + LiteWalletStateApplySection::Transactions, + "transactions", + currentTxids.size(), + proposedTxids.size(), + true, + currentTxids != proposedTxids); +} + +void addSyncPlans(LiteWalletStateApplyPlan& plan, + const LiteWalletAppRefreshModel& model, + const dragonx::WalletState& state) +{ + if (!model.hasSyncStatus) return; + plan.hasSyncStatus = true; + addFieldPlan(plan, + LiteWalletStateApplySection::SyncStatus, + "sync.blocks", + intValue(state.sync.blocks), + uintValue(model.sync.walletHeight)); + addFieldPlan(plan, + LiteWalletStateApplySection::SyncStatus, + "sync.headers", + intValue(state.sync.headers), + uintValue(model.sync.chainHeight)); + addFieldPlan(plan, + LiteWalletStateApplySection::SyncStatus, + "sync.verification_progress", + doubleValue(state.sync.verification_progress), + doubleValue(model.sync.progress)); + addFieldPlan(plan, + LiteWalletStateApplySection::SyncStatus, + "sync.syncing", + boolValue(state.sync.syncing), + boolValue(!model.sync.complete)); +} + +} // namespace + +const char* liteWalletStateApplySectionName(LiteWalletStateApplySection section) +{ + switch (section) { + case LiteWalletStateApplySection::ChainInfo: return "ChainInfo"; + case LiteWalletStateApplySection::Height: return "Height"; + case LiteWalletStateApplySection::Balance: return "Balance"; + case LiteWalletStateApplySection::Addresses: return "Addresses"; + case LiteWalletStateApplySection::SpendableOutputs: return "SpendableOutputs"; + case LiteWalletStateApplySection::Transactions: return "Transactions"; + case LiteWalletStateApplySection::SyncStatus: return "SyncStatus"; + } + return "Unknown"; +} + +const char* liteWalletStateApplyActionName(LiteWalletStateApplyAction action) +{ + switch (action) { + case LiteWalletStateApplyAction::Noop: return "Noop"; + case LiteWalletStateApplyAction::SetField: return "SetField"; + case LiteWalletStateApplyAction::ReplaceCollection: return "ReplaceCollection"; + case LiteWalletStateApplyAction::InspectOnly: return "InspectOnly"; + } + return "Unknown"; +} + +const char* liteWalletStateApplyIssueName(LiteWalletStateApplyIssue issue) +{ + switch (issue) { + case LiteWalletStateApplyIssue::EmptyModel: return "EmptyModel"; + case LiteWalletStateApplyIssue::IncompleteModel: return "IncompleteModel"; + case LiteWalletStateApplyIssue::AddressSpendabilityUnknown: return "AddressSpendabilityUnknown"; + case LiteWalletStateApplyIssue::SpendableOutputsHaveNoWalletStateTarget: return "SpendableOutputsHaveNoWalletStateTarget"; + } + return "Unknown"; +} + +LiteWalletStateApplyPlan planLiteWalletStateApply(const LiteWalletAppRefreshModel& model, + const dragonx::WalletState& state) +{ + LiteWalletStateApplyPlan plan; + plan.sourceComplete = model.complete; + + if (!modelHasAnySection(model)) { + addIssue(plan, + LiteWalletStateApplyIssue::EmptyModel, + "lite app refresh model has no sections to compare"); + plan.error = plan.issues.back().message; + return plan; + } + + if (!model.complete) { + addIssue(plan, + LiteWalletStateApplyIssue::IncompleteModel, + "lite app refresh model is partial; dry-run apply planning only"); + } + + addChainInfoPlans(plan, model, state); + addHeightPlans(plan, model, state); + addBalancePlans(plan, model, state); + addAddressPlans(plan, model, state); + addSpendableOutputPlans(plan, model); + addTransactionPlans(plan, model, state); + addSyncPlans(plan, model, state); + + plan.ok = true; + return plan; +} + +LiteWalletStateApplyPlan LiteWalletStateApplyPlanner::buildPlan( + const LiteWalletAppRefreshModel& model, + const dragonx::WalletState& state) const +{ + return planLiteWalletStateApply(model, state); +} + +} // namespace dragonx::wallet \ No newline at end of file diff --git a/src/wallet/lite_wallet_state_apply_plan.h b/src/wallet/lite_wallet_state_apply_plan.h new file mode 100644 index 0000000..9039222 --- /dev/null +++ b/src/wallet/lite_wallet_state_apply_plan.h @@ -0,0 +1,98 @@ +#pragma once + +#include "data/wallet_state.h" +#include "lite_wallet_state_mapper.h" + +#include +#include +#include +#include + +namespace dragonx::wallet { + +enum class LiteWalletStateApplySection { + ChainInfo, + Height, + Balance, + Addresses, + SpendableOutputs, + Transactions, + SyncStatus, +}; + +enum class LiteWalletStateApplyAction { + Noop, + SetField, + ReplaceCollection, + InspectOnly, +}; + +enum class LiteWalletStateApplyIssue { + EmptyModel, + IncompleteModel, + AddressSpendabilityUnknown, + SpendableOutputsHaveNoWalletStateTarget, +}; + +struct LiteWalletStateApplyIssueInfo { + LiteWalletStateApplyIssue issue = LiteWalletStateApplyIssue::EmptyModel; + std::string message; +}; + +struct LiteWalletStateApplyFieldPlan { + LiteWalletStateApplySection section = LiteWalletStateApplySection::Balance; + LiteWalletStateApplyAction action = LiteWalletStateApplyAction::Noop; + std::string fieldName; + std::string currentValue; + std::string proposedValue; + bool currentKnown = true; + bool proposedKnown = true; + bool wouldChange = false; +}; + +struct LiteWalletStateApplyCollectionPlan { + LiteWalletStateApplySection section = LiteWalletStateApplySection::Addresses; + LiteWalletStateApplyAction action = LiteWalletStateApplyAction::Noop; + std::string collectionName; + std::size_t currentCount = 0; + std::size_t proposedCount = 0; + bool hasWalletStateTarget = true; + bool wouldReplace = false; +}; + +struct LiteWalletStateApplyPlan { + bool ok = false; + bool dryRunOnly = true; + bool applyImplemented = false; + bool stateMutationAllowed = false; + bool wouldChangeWalletState = false; + bool sourceComplete = false; + + bool hasChainInfo = false; + bool hasHeight = false; + bool hasBalance = false; + bool hasAddresses = false; + bool hasSpendableOutputs = false; + bool hasTransactions = false; + bool hasSyncStatus = false; + + std::vector fieldPlans; + std::vector collectionPlans; + std::vector issues; + std::string error; +}; + +const char* liteWalletStateApplySectionName(LiteWalletStateApplySection section); +const char* liteWalletStateApplyActionName(LiteWalletStateApplyAction action); +const char* liteWalletStateApplyIssueName(LiteWalletStateApplyIssue issue); + +LiteWalletStateApplyPlan planLiteWalletStateApply(const LiteWalletAppRefreshModel& model, + const dragonx::WalletState& state); + +class LiteWalletStateApplyPlanner { +public: + LiteWalletStateApplyPlan buildPlan(const LiteWalletAppRefreshModel& model, + const dragonx::WalletState& state) const; +}; + +} // namespace dragonx::wallet \ No newline at end of file diff --git a/src/wallet/lite_wallet_state_mapper.cpp b/src/wallet/lite_wallet_state_mapper.cpp new file mode 100644 index 0000000..eeffe3b --- /dev/null +++ b/src/wallet/lite_wallet_state_mapper.cpp @@ -0,0 +1,217 @@ +#include "wallet/lite_wallet_state_mapper.h" + +#include + +namespace dragonx::wallet { +namespace { + +LiteWalletAppAddressModel mapAddress(const std::string& address, LiteWalletAppAddressKind kind) +{ + LiteWalletAppAddressModel model; + model.address = address; + model.kind = kind; + return model; +} + +LiteWalletAppSpendableOutputModel mapSpendableOutput(const LiteSpendableOutput& output) +{ + LiteWalletAppSpendableOutputModel model; + model.kind = output.kind; + model.address = output.address; + model.createdInTxid = output.createdInTxid; + model.createdInBlock = output.createdInBlock; + model.valueZatoshis = output.value; + model.spent = output.spent; + model.unconfirmedSpent = output.unconfirmedSpent; + model.pending = output.pending; + model.spendable = output.spendable; + return model; +} + +LiteWalletAppTransactionKind mapTransactionKind(LiteTransactionDirection direction) +{ + switch (direction) { + case LiteTransactionDirection::Send: return LiteWalletAppTransactionKind::Send; + case LiteTransactionDirection::Receive: return LiteWalletAppTransactionKind::Receive; + case LiteTransactionDirection::Unknown: return LiteWalletAppTransactionKind::Unknown; + } + return LiteWalletAppTransactionKind::Unknown; +} + +LiteWalletAppTransactionOutputModel mapTransactionOutput(const LiteTransactionOutput& output) +{ + LiteWalletAppTransactionOutputModel model; + model.address = output.address; + model.valueZatoshis = output.value; + model.memo = output.memo; + return model; +} + +LiteWalletAppTransactionModel mapTransaction(const LiteTransactionRecord& transaction) +{ + LiteWalletAppTransactionModel model; + model.txid = transaction.txid; + model.kind = mapTransactionKind(transaction.direction); + model.timestamp = transaction.datetime; + model.blockHeight = transaction.blockHeight; + model.unconfirmed = transaction.unconfirmed; + model.address = transaction.address; + model.amountZatoshis = transaction.amount; + model.signedAmountZatoshis = model.kind == LiteWalletAppTransactionKind::Send + ? -transaction.amount + : transaction.amount; + model.memo = transaction.memo; + model.position = transaction.position; + + model.outgoingOutputs.reserve(transaction.outgoingMetadata.size()); + for (const auto& output : transaction.outgoingMetadata) { + model.outgoingOutputs.push_back(mapTransactionOutput(output)); + } + return model; +} + +bool modelHasAnyMappedField(const LiteWalletAppRefreshModel& model) +{ + return model.hasChainInfo || model.hasHeight || model.hasBalance || model.hasAddresses || + model.hasSpendableOutputs || model.hasTransactions || model.hasSyncStatus; +} + +void addIssue(LiteWalletStateMapResult& result, LiteWalletStateMapIssue issue, std::string message) +{ + result.issues.push_back(LiteWalletStateMapIssueInfo{issue, std::move(message)}); +} + +} // namespace + +const char* liteWalletAppAddressKindName(LiteWalletAppAddressKind kind) +{ + switch (kind) { + case LiteWalletAppAddressKind::Shielded: return "shielded"; + case LiteWalletAppAddressKind::Transparent: return "transparent"; + } + return "unknown"; +} + +const char* liteWalletAppTransactionKindName(LiteWalletAppTransactionKind kind) +{ + switch (kind) { + case LiteWalletAppTransactionKind::Unknown: return "unknown"; + case LiteWalletAppTransactionKind::Send: return "send"; + case LiteWalletAppTransactionKind::Receive: return "receive"; + } + return "unknown"; +} + +const char* liteWalletStateMapIssueName(LiteWalletStateMapIssue issue) +{ + switch (issue) { + case LiteWalletStateMapIssue::EmptyBundle: return "EmptyBundle"; + case LiteWalletStateMapIssue::IncompleteBundle: return "IncompleteBundle"; + } + return "Unknown"; +} + +LiteWalletStateMapResult mapLiteWalletRefreshBundle(const LiteWalletRefreshBundle& bundle) +{ + LiteWalletStateMapResult result; + result.stateMutationAllowed = false; + result.model.complete = bundle.complete; + result.model.successfulCommandCount = bundle.successfulCommandCount; + + if (bundle.hasInfo) { + result.model.hasChainInfo = true; + result.model.chain.chainName = bundle.info.chainName; + result.model.chain.version = bundle.info.version; + result.model.chain.vendor = bundle.info.vendor; + result.model.chain.latestBlockHeight = bundle.info.latestBlockHeight; + result.model.chain.difficulty = bundle.info.difficulty; + result.model.chain.longestChain = bundle.info.longestChain; + result.model.chain.notarized = bundle.info.notarized; + } + + if (bundle.hasHeight) { + result.model.hasHeight = true; + result.model.height.height = bundle.height.height; + } + + if (bundle.hasBalance) { + result.model.hasBalance = true; + result.model.balance.transparentZatoshis = bundle.balance.transparentBalance; + result.model.balance.shieldedZatoshis = bundle.balance.shieldedBalance; + result.model.balance.unconfirmedZatoshis = bundle.balance.unconfirmedBalance; + result.model.balance.verifiedShieldedZatoshis = bundle.balance.verifiedShieldedBalance; + result.model.balance.spendableShieldedZatoshis = bundle.balance.spendableShieldedBalance; + result.model.balance.totalZatoshis = bundle.balance.transparentBalance + bundle.balance.shieldedBalance; + } + + if (bundle.hasAddresses) { + result.model.hasAddresses = true; + result.model.addresses.reserve(bundle.addresses.zAddresses.size() + bundle.addresses.tAddresses.size()); + for (const auto& address : bundle.addresses.zAddresses) { + result.model.addresses.push_back(mapAddress(address, LiteWalletAppAddressKind::Shielded)); + } + for (const auto& address : bundle.addresses.tAddresses) { + result.model.addresses.push_back(mapAddress(address, LiteWalletAppAddressKind::Transparent)); + } + } + + if (bundle.hasNotes) { + result.model.hasSpendableOutputs = true; + const auto outputCount = bundle.notes.unspentNotes.size() + bundle.notes.utxos.size() + + bundle.notes.pendingNotes.size() + bundle.notes.pendingUtxos.size(); + result.model.spendableOutputs.reserve(outputCount); + for (const auto& output : bundle.notes.unspentNotes) { + result.model.spendableOutputs.push_back(mapSpendableOutput(output)); + } + for (const auto& output : bundle.notes.utxos) { + result.model.spendableOutputs.push_back(mapSpendableOutput(output)); + } + for (const auto& output : bundle.notes.pendingNotes) { + result.model.spendableOutputs.push_back(mapSpendableOutput(output)); + } + for (const auto& output : bundle.notes.pendingUtxos) { + result.model.spendableOutputs.push_back(mapSpendableOutput(output)); + } + } + + if (bundle.hasTransactions) { + result.model.hasTransactions = true; + result.model.transactions.reserve(bundle.transactions.transactions.size()); + for (const auto& transaction : bundle.transactions.transactions) { + result.model.transactions.push_back(mapTransaction(transaction)); + } + } + + if (bundle.hasSyncStatus) { + result.model.hasSyncStatus = true; + result.model.sync.walletHeight = bundle.syncStatus.syncedBlocks; + result.model.sync.chainHeight = bundle.syncStatus.totalBlocks; + result.model.sync.progress = bundle.syncStatus.progress; + result.model.sync.complete = bundle.syncStatus.complete; + } + + if (!modelHasAnyMappedField(result.model)) { + addIssue(result, LiteWalletStateMapIssue::EmptyBundle, "lite refresh bundle has no mappable fields"); + result.error = result.issues.back().message; + return result; + } + + if (!bundle.complete) { + addIssue(result, LiteWalletStateMapIssue::IncompleteBundle, "lite refresh bundle is partial"); + } + + result.ok = true; + return result; +} + +LiteWalletStateMapResult mapLiteWalletRefreshResult(const LiteWalletRefreshResult& result) +{ + return mapLiteWalletRefreshBundle(result.bundle); +} + +LiteWalletStateMapResult mapLiteWalletRefreshServiceResult(const LiteWalletRefreshServiceResult& result) +{ + return mapLiteWalletRefreshBundle(result.bundle); +} + +} // namespace dragonx::wallet \ No newline at end of file diff --git a/src/wallet/lite_wallet_state_mapper.h b/src/wallet/lite_wallet_state_mapper.h new file mode 100644 index 0000000..0460595 --- /dev/null +++ b/src/wallet/lite_wallet_state_mapper.h @@ -0,0 +1,139 @@ +#pragma once + +#include "lite_wallet_refresh_service.h" + +#include +#include +#include +#include +#include + +namespace dragonx::wallet { + +enum class LiteWalletAppAddressKind { + Shielded, + Transparent, +}; + +enum class LiteWalletAppTransactionKind { + Unknown, + Send, + Receive, +}; + +enum class LiteWalletStateMapIssue { + EmptyBundle, + IncompleteBundle, +}; + +struct LiteWalletAppChainModel { + std::optional chainName; + std::optional version; + std::optional vendor; + std::optional latestBlockHeight; + std::optional difficulty; + std::optional longestChain; + std::optional notarized; +}; + +struct LiteWalletAppHeightModel { + std::int64_t height = 0; +}; + +struct LiteWalletAppBalanceModel { + std::uint64_t transparentZatoshis = 0; + std::uint64_t shieldedZatoshis = 0; + std::uint64_t unconfirmedZatoshis = 0; + std::uint64_t verifiedShieldedZatoshis = 0; + std::uint64_t spendableShieldedZatoshis = 0; + std::uint64_t totalZatoshis = 0; +}; + +struct LiteWalletAppAddressModel { + std::string address; + LiteWalletAppAddressKind kind = LiteWalletAppAddressKind::Shielded; + bool spendabilityKnown = false; + bool spendable = false; +}; + +struct LiteWalletAppSpendableOutputModel { + LiteSpendableOutputKind kind = LiteSpendableOutputKind::UnspentNote; + std::string address; + std::string createdInTxid; + std::optional createdInBlock; + std::uint64_t valueZatoshis = 0; + bool spent = false; + bool unconfirmedSpent = false; + bool pending = false; + bool spendable = false; +}; + +struct LiteWalletAppTransactionOutputModel { + std::string address; + std::int64_t valueZatoshis = 0; + std::string memo; +}; + +struct LiteWalletAppTransactionModel { + std::string txid; + LiteWalletAppTransactionKind kind = LiteWalletAppTransactionKind::Unknown; + std::int64_t timestamp = 0; + std::optional blockHeight; + bool unconfirmed = false; + std::string address; + std::int64_t amountZatoshis = 0; + std::int64_t signedAmountZatoshis = 0; + std::string memo; + std::optional position; + std::vector outgoingOutputs; +}; + +struct LiteWalletAppSyncModel { + std::uint64_t walletHeight = 0; + std::uint64_t chainHeight = 0; + double progress = 0.0; + bool complete = false; +}; + +struct LiteWalletAppRefreshModel { + bool complete = false; + bool hasChainInfo = false; + bool hasHeight = false; + bool hasBalance = false; + bool hasAddresses = false; + bool hasSpendableOutputs = false; + bool hasTransactions = false; + bool hasSyncStatus = false; + std::size_t successfulCommandCount = 0; + + LiteWalletAppChainModel chain; + LiteWalletAppHeightModel height; + LiteWalletAppBalanceModel balance; + LiteWalletAppSyncModel sync; + std::vector addresses; + std::vector spendableOutputs; + std::vector transactions; +}; + +struct LiteWalletStateMapIssueInfo { + LiteWalletStateMapIssue issue = LiteWalletStateMapIssue::EmptyBundle; + std::string message; +}; + +struct LiteWalletStateMapResult { + bool ok = false; + bool stateMutationAllowed = false; + LiteWalletAppRefreshModel model; + std::vector issues; + std::string error; +}; + +const char* liteWalletAppAddressKindName(LiteWalletAppAddressKind kind); +const char* liteWalletAppTransactionKindName(LiteWalletAppTransactionKind kind); +const char* liteWalletStateMapIssueName(LiteWalletStateMapIssue issue); + +LiteWalletStateMapResult mapLiteWalletRefreshBundle(const LiteWalletRefreshBundle& bundle); +LiteWalletStateMapResult mapLiteWalletRefreshResult(const LiteWalletRefreshResult& result); +LiteWalletStateMapResult mapLiteWalletRefreshServiceResult(const LiteWalletRefreshServiceResult& result); + +} // namespace dragonx::wallet \ No newline at end of file diff --git a/src/wallet/lite_wallet_sync_app_refresh_integration.cpp b/src/wallet/lite_wallet_sync_app_refresh_integration.cpp new file mode 100644 index 0000000..8bf4302 --- /dev/null +++ b/src/wallet/lite_wallet_sync_app_refresh_integration.cpp @@ -0,0 +1,344 @@ +#include "wallet/lite_wallet_sync_app_refresh_integration.h" + +#include + +namespace dragonx::wallet { +namespace { + +void addIssue(LiteWalletSyncAppRefreshIntegrationResult& result, + LiteWalletSyncAppRefreshIntegrationIssue issue, + std::string message) +{ + result.issues.push_back(LiteWalletSyncAppRefreshIntegrationIssueInfo{issue, std::move(message)}); +} + +std::string statusMessageOrDefault(const WalletBackendStatus& status, + const std::string& fallback) +{ + return status.message.empty() ? fallback : status.message; +} + +bool refreshReportIsUnsafe(const LiteWalletAppRefreshOrchestrationResult& refresh) +{ + return !refresh.dryRunOnly || + !refresh.noNetwork || + refresh.stateMutationRequested || + refresh.stateMutationAllowed || + refresh.stateMutated || + refresh.walletStateWritten; +} + +bool syncStartPlanIsValid(const LiteSyncPlan& plan) +{ + return plan.ok && plan.operation == LiteSyncOperation::StartSync && plan.command == "sync"; +} + +bool syncStatusPlanIsValid(const LiteSyncPlan& plan) +{ + return plan.ok && plan.operation == LiteSyncOperation::PollSyncStatus && plan.command == "syncstatus"; +} + +LiteWalletSyncAppRefreshIntegrationResult stoppedResult( + LiteWalletSyncAppRefreshIntegrationResult result, + LiteWalletSyncAppRefreshIntegrationStatus status, + LiteWalletSyncAppRefreshIntegrationIssue issue, + std::string message) +{ + result.status = status; + addIssue(result, issue, std::move(message)); + result.error = result.issues.back().message; + return result; +} + +LiteWalletSyncAppRefreshIntegrationResult skippedResult( + LiteWalletSyncAppRefreshIntegrationResult result, + LiteWalletSyncAppRefreshIntegrationIssue issue, + std::string message) +{ + result.ok = true; + result.status = LiteWalletSyncAppRefreshIntegrationStatus::RefreshNotQueued; + addIssue(result, issue, std::move(message)); + return result; +} + +void copyRecoveryFlags(LiteWalletSyncAppRefreshIntegrationResult& result, + const LiteSyncRecoveryDecision& decision) +{ + result.recoveryDecision = decision; + result.futureClearRequired = decision.shouldClear; + result.futureRescanRequired = decision.shouldRescan; + result.futureRestartSyncRequired = decision.shouldRestartSync; + result.requiresUserAttention = decision.requiresUserAttention; +} + +} // namespace + +const char* liteWalletSyncAppRefreshIntegrationStatusName( + LiteWalletSyncAppRefreshIntegrationStatus status) +{ + switch (status) { + case LiteWalletSyncAppRefreshIntegrationStatus::FutureWorkerQueueFeedReady: return "FutureWorkerQueueFeedReady"; + case LiteWalletSyncAppRefreshIntegrationStatus::WaitingForLifecycle: return "WaitingForLifecycle"; + case LiteWalletSyncAppRefreshIntegrationStatus::WaitingForSyncPlan: return "WaitingForSyncPlan"; + case LiteWalletSyncAppRefreshIntegrationStatus::WaitingForSyncStatus: return "WaitingForSyncStatus"; + case LiteWalletSyncAppRefreshIntegrationStatus::WaitingForRecovery: return "WaitingForRecovery"; + case LiteWalletSyncAppRefreshIntegrationStatus::WaitingForCancellation: return "WaitingForCancellation"; + case LiteWalletSyncAppRefreshIntegrationStatus::RefreshNotQueued: return "RefreshNotQueued"; + case LiteWalletSyncAppRefreshIntegrationStatus::WorkerQueueUnavailable: return "WorkerQueueUnavailable"; + case LiteWalletSyncAppRefreshIntegrationStatus::UnsafePlan: return "UnsafePlan"; + } + return "Unknown"; +} + +const char* liteWalletSyncAppRefreshIntegrationIssueName( + LiteWalletSyncAppRefreshIntegrationIssue issue) +{ + switch (issue) { + case LiteWalletSyncAppRefreshIntegrationIssue::LifecycleNotReady: return "LifecycleNotReady"; + case LiteWalletSyncAppRefreshIntegrationIssue::MissingSyncStartPlan: return "MissingSyncStartPlan"; + case LiteWalletSyncAppRefreshIntegrationIssue::InvalidSyncStartPlan: return "InvalidSyncStartPlan"; + case LiteWalletSyncAppRefreshIntegrationIssue::SyncStartWouldExecute: return "SyncStartWouldExecute"; + case LiteWalletSyncAppRefreshIntegrationIssue::MissingSyncStatusPlan: return "MissingSyncStatusPlan"; + case LiteWalletSyncAppRefreshIntegrationIssue::InvalidSyncStatusPlan: return "InvalidSyncStatusPlan"; + case LiteWalletSyncAppRefreshIntegrationIssue::SyncStatusWouldExecute: return "SyncStatusWouldExecute"; + case LiteWalletSyncAppRefreshIntegrationIssue::MissingRecoveryDecision: return "MissingRecoveryDecision"; + case LiteWalletSyncAppRefreshIntegrationIssue::SyncStillPolling: return "SyncStillPolling"; + case LiteWalletSyncAppRefreshIntegrationIssue::SyncRecoveryRequired: return "SyncRecoveryRequired"; + case LiteWalletSyncAppRefreshIntegrationIssue::SyncRecoveryNeedsUserAttention: return "SyncRecoveryNeedsUserAttention"; + case LiteWalletSyncAppRefreshIntegrationIssue::CancellationRequired: return "CancellationRequired"; + case LiteWalletSyncAppRefreshIntegrationIssue::CancellationUnsupported: return "CancellationUnsupported"; + case LiteWalletSyncAppRefreshIntegrationIssue::RefreshReportRejected: return "RefreshReportRejected"; + case LiteWalletSyncAppRefreshIntegrationIssue::RefreshReportUnsafe: return "RefreshReportUnsafe"; + case LiteWalletSyncAppRefreshIntegrationIssue::RefreshSkipped: return "RefreshSkipped"; + case LiteWalletSyncAppRefreshIntegrationIssue::RefreshBlocked: return "RefreshBlocked"; + case LiteWalletSyncAppRefreshIntegrationIssue::FutureWorkerQueueDisabled: return "FutureWorkerQueueDisabled"; + case LiteWalletSyncAppRefreshIntegrationIssue::FutureWorkerQueuePressure: return "FutureWorkerQueuePressure"; + } + return "Unknown"; +} + +LiteWalletSyncAppRefreshIntegrationResult planLiteWalletSyncAppRefreshIntegration( + const LiteWalletSyncAppRefreshIntegrationInput& input, + LiteWalletSyncAppRefreshIntegrationOptions options) +{ + LiteWalletSyncAppRefreshIntegrationResult result; + result.lifecycleStatus = input.lifecycle.status; + result.refreshOrchestration = input.refreshOrchestration; + result.route = input.refreshOrchestration.route; + result.refreshWouldQueue = input.refreshOrchestration.wouldQueueRefresh; + result.refreshSkipped = input.refreshOrchestration.skipped; + result.refreshBlocked = input.refreshOrchestration.blocked; + result.futureWorkerQueuePlan.laneName = input.futureWorkerQueue.laneName; + result.futureWorkerQueuePlan.trigger = input.refreshOrchestration.trigger; + result.futureWorkerQueuePlan.route = input.refreshOrchestration.route; + result.futureWorkerQueuePlan.queueDepth = input.futureWorkerQueue.queueDepth; + result.futureWorkerQueuePlan.maxQueueDepth = input.futureWorkerQueue.maxQueueDepth; + + if (input.sync.haveStartPlan) { + result.syncStartPlan = input.sync.startPlan; + result.futureWorkerQueuePlan.startSyncCommand = input.sync.startPlan.command; + } + if (input.sync.haveStatusPlan) { + result.syncStatusPlan = input.sync.statusPlan; + result.futureWorkerQueuePlan.syncStatusCommand = input.sync.statusPlan.command; + } + if (input.sync.haveRecoveryDecision) { + copyRecoveryFlags(result, input.sync.recoveryDecision); + } + + if (options.requireLifecycleReady && !input.lifecycle.ready) { + return stoppedResult( + std::move(result), + LiteWalletSyncAppRefreshIntegrationStatus::WaitingForLifecycle, + LiteWalletSyncAppRefreshIntegrationIssue::LifecycleNotReady, + statusMessageOrDefault(input.lifecycle.status, "lite wallet lifecycle is not ready")); + } + result.lifecycleAccepted = true; + + if (options.requireSyncStartPlan && !input.sync.haveStartPlan) { + return stoppedResult( + std::move(result), + LiteWalletSyncAppRefreshIntegrationStatus::WaitingForSyncPlan, + LiteWalletSyncAppRefreshIntegrationIssue::MissingSyncStartPlan, + "lite sync start plan is required before app refresh integration"); + } + + if (input.sync.haveStartPlan) { + if (!syncStartPlanIsValid(input.sync.startPlan)) { + return stoppedResult( + std::move(result), + LiteWalletSyncAppRefreshIntegrationStatus::WaitingForSyncPlan, + LiteWalletSyncAppRefreshIntegrationIssue::InvalidSyncStartPlan, + input.sync.startPlan.error.empty() + ? "lite sync start plan is invalid" + : input.sync.startPlan.error); + } + if (options.rejectExecutableSyncPlans && input.sync.startPlan.bridgeExecutionAllowed) { + return stoppedResult( + std::move(result), + LiteWalletSyncAppRefreshIntegrationStatus::UnsafePlan, + LiteWalletSyncAppRefreshIntegrationIssue::SyncStartWouldExecute, + "lite sync start plan would allow bridge execution"); + } + result.syncStartPlanAccepted = true; + } + + if (options.requireSyncStatusPlan && !input.sync.haveStatusPlan) { + return stoppedResult( + std::move(result), + LiteWalletSyncAppRefreshIntegrationStatus::WaitingForSyncStatus, + LiteWalletSyncAppRefreshIntegrationIssue::MissingSyncStatusPlan, + "lite syncstatus plan is required before app refresh integration"); + } + + if (input.sync.haveStatusPlan) { + if (!syncStatusPlanIsValid(input.sync.statusPlan)) { + return stoppedResult( + std::move(result), + LiteWalletSyncAppRefreshIntegrationStatus::WaitingForSyncStatus, + LiteWalletSyncAppRefreshIntegrationIssue::InvalidSyncStatusPlan, + input.sync.statusPlan.error.empty() + ? "lite syncstatus plan is invalid" + : input.sync.statusPlan.error); + } + if (options.rejectExecutableSyncPlans && input.sync.statusPlan.bridgeExecutionAllowed) { + return stoppedResult( + std::move(result), + LiteWalletSyncAppRefreshIntegrationStatus::UnsafePlan, + LiteWalletSyncAppRefreshIntegrationIssue::SyncStatusWouldExecute, + "lite syncstatus plan would allow bridge execution"); + } + result.syncStatusPlanAccepted = true; + } + + if (options.requireRecoveryDecision && !input.sync.haveRecoveryDecision) { + return stoppedResult( + std::move(result), + LiteWalletSyncAppRefreshIntegrationStatus::WaitingForSyncStatus, + LiteWalletSyncAppRefreshIntegrationIssue::MissingRecoveryDecision, + "lite sync recovery decision is required before app refresh integration"); + } + + if (input.sync.haveRecoveryDecision) { + const auto& decision = input.sync.recoveryDecision; + if (decision.kind == LiteSyncRecoveryDecisionKind::InvalidStatus) { + result.recoveryRequired = true; + return stoppedResult( + std::move(result), + LiteWalletSyncAppRefreshIntegrationStatus::WaitingForRecovery, + LiteWalletSyncAppRefreshIntegrationIssue::SyncRecoveryNeedsUserAttention, + decision.reason.empty() + ? "lite sync status is invalid and needs user attention" + : decision.reason); + } + if (decision.kind == LiteSyncRecoveryDecisionKind::Stuck || + decision.kind == LiteSyncRecoveryDecisionKind::ReorgDetected) { + result.recoveryRequired = true; + return stoppedResult( + std::move(result), + LiteWalletSyncAppRefreshIntegrationStatus::WaitingForRecovery, + LiteWalletSyncAppRefreshIntegrationIssue::SyncRecoveryRequired, + decision.reason.empty() + ? "lite sync recovery must be modeled before refresh can feed a queue" + : decision.reason); + } + if (options.requireSyncCompleteForRefresh && decision.kind == LiteSyncRecoveryDecisionKind::KeepPolling) { + return stoppedResult( + std::move(result), + LiteWalletSyncAppRefreshIntegrationStatus::WaitingForSyncStatus, + LiteWalletSyncAppRefreshIntegrationIssue::SyncStillPolling, + decision.reason.empty() + ? "lite sync is still polling" + : decision.reason); + } + result.recoveryAccepted = true; + } + + if (input.cancellation.cancellationRequested && input.cancellation.syncInProgress) { + result.cancellationRequired = true; + if (!input.cancellation.cancellationSupported) { + return stoppedResult( + std::move(result), + LiteWalletSyncAppRefreshIntegrationStatus::WaitingForCancellation, + LiteWalletSyncAppRefreshIntegrationIssue::CancellationUnsupported, + "lite sync cancellation is requested but no cancellation path is available"); + } + return stoppedResult( + std::move(result), + LiteWalletSyncAppRefreshIntegrationStatus::WaitingForCancellation, + LiteWalletSyncAppRefreshIntegrationIssue::CancellationRequired, + "lite sync cancellation must complete before app refresh can feed a queue"); + } + result.cancellationAccepted = true; + + if (refreshReportIsUnsafe(input.refreshOrchestration)) { + return stoppedResult( + std::move(result), + LiteWalletSyncAppRefreshIntegrationStatus::UnsafePlan, + LiteWalletSyncAppRefreshIntegrationIssue::RefreshReportUnsafe, + "lite app refresh orchestration report is not a no-network dry-run report"); + } + + if (!input.refreshOrchestration.ok) { + const auto issue = input.refreshOrchestration.blocked + ? LiteWalletSyncAppRefreshIntegrationIssue::RefreshBlocked + : LiteWalletSyncAppRefreshIntegrationIssue::RefreshReportRejected; + return stoppedResult( + std::move(result), + LiteWalletSyncAppRefreshIntegrationStatus::RefreshNotQueued, + issue, + input.refreshOrchestration.error.empty() + ? "lite app refresh orchestration report is not queued" + : input.refreshOrchestration.error); + } + + result.refreshReportAccepted = true; + + if (input.refreshOrchestration.skipped || !input.refreshOrchestration.wouldQueueRefresh) { + return skippedResult( + std::move(result), + LiteWalletSyncAppRefreshIntegrationIssue::RefreshSkipped, + input.refreshOrchestration.issues.empty() + ? "lite app refresh orchestration skipped queueing" + : input.refreshOrchestration.issues.front().message); + } + + if (options.requireFutureWorkerQueue && !input.futureWorkerQueue.enabled) { + return stoppedResult( + std::move(result), + LiteWalletSyncAppRefreshIntegrationStatus::WorkerQueueUnavailable, + LiteWalletSyncAppRefreshIntegrationIssue::FutureWorkerQueueDisabled, + "future lite app refresh worker queue is disabled"); + } + + if (input.futureWorkerQueue.maxQueueDepth > 0 && + input.futureWorkerQueue.queueDepth >= input.futureWorkerQueue.maxQueueDepth) { + return stoppedResult( + std::move(result), + LiteWalletSyncAppRefreshIntegrationStatus::WorkerQueueUnavailable, + LiteWalletSyncAppRefreshIntegrationIssue::FutureWorkerQueuePressure, + "future lite app refresh worker queue is at capacity"); + } + + result.ok = true; + result.status = LiteWalletSyncAppRefreshIntegrationStatus::FutureWorkerQueueFeedReady; + result.futureWorkerQueueFeedReady = true; + result.wouldFeedFutureWorkerQueue = true; + result.futureWorkerQueuePlan.readyToFeed = true; + result.futureWorkerQueuePlan.wouldFeed = true; + return result; +} + +LiteWalletSyncAppRefreshIntegrationPlanner::LiteWalletSyncAppRefreshIntegrationPlanner( + LiteWalletSyncAppRefreshIntegrationOptions options) + : options_(options) +{ +} + +LiteWalletSyncAppRefreshIntegrationResult LiteWalletSyncAppRefreshIntegrationPlanner::plan( + const LiteWalletSyncAppRefreshIntegrationInput& input) const +{ + return planLiteWalletSyncAppRefreshIntegration(input, options_); +} + +} // namespace dragonx::wallet \ No newline at end of file diff --git a/src/wallet/lite_wallet_sync_app_refresh_integration.h b/src/wallet/lite_wallet_sync_app_refresh_integration.h new file mode 100644 index 0000000..0c2628f --- /dev/null +++ b/src/wallet/lite_wallet_sync_app_refresh_integration.h @@ -0,0 +1,172 @@ +#pragma once + +#include "lite_sync_service.h" +#include "lite_wallet_app_refresh_orchestrator.h" + +#include +#include +#include + +namespace dragonx::wallet { + +enum class LiteWalletSyncAppRefreshIntegrationStatus { + FutureWorkerQueueFeedReady, + WaitingForLifecycle, + WaitingForSyncPlan, + WaitingForSyncStatus, + WaitingForRecovery, + WaitingForCancellation, + RefreshNotQueued, + WorkerQueueUnavailable, + UnsafePlan, +}; + +enum class LiteWalletSyncAppRefreshIntegrationIssue { + LifecycleNotReady, + MissingSyncStartPlan, + InvalidSyncStartPlan, + SyncStartWouldExecute, + MissingSyncStatusPlan, + InvalidSyncStatusPlan, + SyncStatusWouldExecute, + MissingRecoveryDecision, + SyncStillPolling, + SyncRecoveryRequired, + SyncRecoveryNeedsUserAttention, + CancellationRequired, + CancellationUnsupported, + RefreshReportRejected, + RefreshReportUnsafe, + RefreshSkipped, + RefreshBlocked, + FutureWorkerQueueDisabled, + FutureWorkerQueuePressure, +}; + +struct LiteWalletSyncAppRefreshLifecycleInput { + bool ready = false; + WalletBackendStatus status; +}; + +struct LiteWalletSyncAppRefreshSyncPlanInput { + bool haveStartPlan = false; + LiteSyncPlan startPlan; + bool haveStatusPlan = false; + LiteSyncPlan statusPlan; + bool haveRecoveryDecision = false; + LiteSyncRecoveryDecision recoveryDecision; +}; + +struct LiteWalletSyncAppRefreshCancellationInput { + bool cancellationRequested = false; + bool syncInProgress = false; + bool cancellationSupported = false; +}; + +struct LiteWalletFutureWorkerQueueInput { + bool enabled = true; + std::size_t queueDepth = 0; + std::size_t maxQueueDepth = 0; + std::string laneName = "lite-app-refresh"; +}; + +struct LiteWalletSyncAppRefreshIntegrationInput { + LiteWalletSyncAppRefreshLifecycleInput lifecycle; + LiteWalletSyncAppRefreshSyncPlanInput sync; + LiteWalletSyncAppRefreshCancellationInput cancellation; + LiteWalletFutureWorkerQueueInput futureWorkerQueue; + LiteWalletAppRefreshOrchestrationResult refreshOrchestration; +}; + +struct LiteWalletSyncAppRefreshIntegrationOptions { + bool requireLifecycleReady = true; + bool requireSyncStartPlan = true; + bool requireSyncStatusPlan = true; + bool requireRecoveryDecision = true; + bool requireSyncCompleteForRefresh = true; + bool rejectExecutableSyncPlans = true; + bool requireFutureWorkerQueue = true; +}; + +struct LiteWalletFutureWorkerQueuePlan { + bool readyToFeed = false; + bool wouldFeed = false; + bool enqueued = false; + std::string laneName; + LiteWalletAppRefreshScheduleTrigger trigger = LiteWalletAppRefreshScheduleTrigger::Periodic; + LiteWalletRefreshRouteKind route = LiteWalletRefreshRouteKind::Unavailable; + std::string startSyncCommand; + std::string syncStatusCommand; + std::size_t queueDepth = 0; + std::size_t maxQueueDepth = 0; +}; + +struct LiteWalletSyncAppRefreshIntegrationIssueInfo { + LiteWalletSyncAppRefreshIntegrationIssue issue = LiteWalletSyncAppRefreshIntegrationIssue::LifecycleNotReady; + std::string message; +}; + +struct LiteWalletSyncAppRefreshIntegrationResult { + bool ok = false; + bool dryRunOnly = true; + bool noNetwork = true; + bool noBridgeCalls = true; + bool noSyncStarted = true; + bool noWalletPersistence = true; + bool stateMutationAllowed = false; + bool stateMutated = false; + bool walletStateWritten = false; + bool workerQueueEnqueued = false; + + bool lifecycleAccepted = false; + bool syncStartPlanAccepted = false; + bool syncStatusPlanAccepted = false; + bool recoveryAccepted = false; + bool cancellationAccepted = false; + bool refreshReportAccepted = false; + bool futureWorkerQueueFeedReady = false; + bool wouldFeedFutureWorkerQueue = false; + bool refreshWouldQueue = false; + bool refreshSkipped = false; + bool refreshBlocked = false; + bool recoveryRequired = false; + bool cancellationRequired = false; + bool futureClearRequired = false; + bool futureRescanRequired = false; + bool futureRestartSyncRequired = false; + bool requiresUserAttention = false; + + LiteWalletSyncAppRefreshIntegrationStatus status = LiteWalletSyncAppRefreshIntegrationStatus::WaitingForLifecycle; + LiteWalletRefreshRouteKind route = LiteWalletRefreshRouteKind::Unavailable; + WalletBackendStatus lifecycleStatus; + LiteSyncPlan syncStartPlan; + LiteSyncPlan syncStatusPlan; + LiteSyncRecoveryDecision recoveryDecision; + LiteWalletAppRefreshOrchestrationResult refreshOrchestration; + LiteWalletFutureWorkerQueuePlan futureWorkerQueuePlan; + std::vector issues; + std::string error; +}; + +const char* liteWalletSyncAppRefreshIntegrationStatusName( + LiteWalletSyncAppRefreshIntegrationStatus status); +const char* liteWalletSyncAppRefreshIntegrationIssueName( + LiteWalletSyncAppRefreshIntegrationIssue issue); + +LiteWalletSyncAppRefreshIntegrationResult planLiteWalletSyncAppRefreshIntegration( + const LiteWalletSyncAppRefreshIntegrationInput& input, + LiteWalletSyncAppRefreshIntegrationOptions options = {}); + +class LiteWalletSyncAppRefreshIntegrationPlanner { +public: + explicit LiteWalletSyncAppRefreshIntegrationPlanner( + LiteWalletSyncAppRefreshIntegrationOptions options = {}); + + LiteWalletSyncAppRefreshIntegrationResult plan( + const LiteWalletSyncAppRefreshIntegrationInput& input) const; + +private: + LiteWalletSyncAppRefreshIntegrationOptions options_; +}; + +} // namespace dragonx::wallet \ No newline at end of file diff --git a/src/wallet/lite_wallet_sync_execution_readiness.cpp b/src/wallet/lite_wallet_sync_execution_readiness.cpp new file mode 100644 index 0000000..7bd170a --- /dev/null +++ b/src/wallet/lite_wallet_sync_execution_readiness.cpp @@ -0,0 +1,461 @@ +#include "wallet/lite_wallet_sync_execution_readiness.h" + +#include + +namespace dragonx::wallet { +namespace { + +void addIssue(LiteWalletSyncExecutionReadinessResult& result, + LiteWalletSyncExecutionReadinessIssue issue, + std::string message) +{ + result.issues.push_back(LiteWalletSyncExecutionReadinessIssueInfo{issue, std::move(message)}); +} + +LiteWalletSyncExecutionReadinessResult stoppedResult( + LiteWalletSyncExecutionReadinessResult result, + LiteWalletSyncExecutionReadinessStatus status, + LiteWalletSyncExecutionReadinessIssue issue, + std::string message) +{ + result.status = status; + addIssue(result, issue, std::move(message)); + result.error = result.issues.back().message; + return result; +} + +bool coreArtifactSymbolsReady(const LiteWalletSdxlArtifactSymbolsInput& symbols) +{ + return symbols.walletExists && + symbols.initializeNew && + symbols.initializeNewFromPhrase && + symbols.initializeExisting && + symbols.execute && + symbols.checkServerOnline; +} + +bool integrationReportIsUnsafe(const LiteWalletSyncAppRefreshIntegrationResult& integration) +{ + return !integration.dryRunOnly || + !integration.noNetwork || + !integration.noBridgeCalls || + !integration.noSyncStarted || + !integration.noWalletPersistence || + integration.stateMutationAllowed || + integration.stateMutated || + integration.walletStateWritten || + integration.workerQueueEnqueued; +} + +std::string backendMessageOrDefault(const WalletBackendStatus& status, + const std::string& fallback) +{ + return status.message.empty() ? fallback : status.message; +} + +bool recoveryRequiredByIntegration(const LiteWalletSyncAppRefreshIntegrationResult& integration) +{ + return integration.recoveryRequired || + integration.futureClearRequired || + integration.futureRescanRequired || + integration.futureRestartSyncRequired || + integration.requiresUserAttention; +} + +bool cancellationRequiredByIntegration(const LiteWalletSyncAppRefreshIntegrationResult& integration) +{ + return integration.cancellationRequired || + integration.status == LiteWalletSyncAppRefreshIntegrationStatus::WaitingForCancellation; +} + +void copyIntegrationSummary(LiteWalletSyncExecutionReadinessResult& result, + const LiteWalletSyncAppRefreshIntegrationResult& integration) +{ + result.integrationReport = integration; + result.integrationFeedReady = integration.futureWorkerQueueFeedReady; + result.recoveryRequired = recoveryRequiredByIntegration(integration); + result.cancellationRequired = cancellationRequiredByIntegration(integration); + result.futureClearRequired = integration.futureClearRequired; + result.futureRescanRequired = integration.futureRescanRequired; + result.futureRestartSyncRequired = integration.futureRestartSyncRequired; + result.requiresUserAttention = integration.requiresUserAttention; + result.enablementPlan.startSyncCommand = integration.syncStartPlan.command; + result.enablementPlan.syncStatusCommand = integration.syncStatusPlan.command; + result.enablementPlan.workerQueueLane = integration.futureWorkerQueuePlan.laneName; + result.enablementPlan.route = integration.route; +} + +LiteWalletSyncExecutionReadinessResult evaluateRecoveryReadiness( + LiteWalletSyncExecutionReadinessResult result, + const LiteWalletSyncExecutionRecoveryReadinessInput& recovery, + LiteWalletSyncExecutionReadinessOptions options) +{ + if (!options.requireRecoveryExecutionReadiness) { + result.recoveryExecutionReady = true; + return stoppedResult( + std::move(result), + LiteWalletSyncExecutionReadinessStatus::WaitingForRecovery, + LiteWalletSyncExecutionReadinessIssue::IntegrationFeedNotReady, + "lite sync recovery must complete before sync execution can be enabled"); + } + + if (result.futureClearRequired && !recovery.clearActionReady) { + return stoppedResult( + std::move(result), + LiteWalletSyncExecutionReadinessStatus::WaitingForRecovery, + LiteWalletSyncExecutionReadinessIssue::RecoveryClearMissing, + "lite sync recovery requires a future clear action before sync execution"); + } + if (result.futureRescanRequired && !recovery.rescanActionReady) { + return stoppedResult( + std::move(result), + LiteWalletSyncExecutionReadinessStatus::WaitingForRecovery, + LiteWalletSyncExecutionReadinessIssue::RecoveryRescanMissing, + "lite sync recovery requires a future rescan action before sync execution"); + } + if (result.futureRestartSyncRequired && !recovery.restartSyncActionReady) { + return stoppedResult( + std::move(result), + LiteWalletSyncExecutionReadinessStatus::WaitingForRecovery, + LiteWalletSyncExecutionReadinessIssue::RecoveryRestartMissing, + "lite sync recovery requires a future restart-sync action before sync execution"); + } + if (result.requiresUserAttention && !recovery.userAttentionPathReady) { + return stoppedResult( + std::move(result), + LiteWalletSyncExecutionReadinessStatus::WaitingForRecovery, + LiteWalletSyncExecutionReadinessIssue::RecoveryUserAttentionMissing, + "lite sync recovery requires a user-attention path before sync execution"); + } + + result.recoveryExecutionReady = true; + return stoppedResult( + std::move(result), + LiteWalletSyncExecutionReadinessStatus::WaitingForRecovery, + LiteWalletSyncExecutionReadinessIssue::IntegrationFeedNotReady, + "lite sync recovery is ready to be modeled but must complete before sync execution"); +} + +} // namespace + +const char* liteWalletSyncExecutionReadinessStatusName( + LiteWalletSyncExecutionReadinessStatus status) +{ + switch (status) { + case LiteWalletSyncExecutionReadinessStatus::ReadyToEnableSyncExecution: return "ReadyToEnableSyncExecution"; + case LiteWalletSyncExecutionReadinessStatus::WaitingForLiteBuild: return "WaitingForLiteBuild"; + case LiteWalletSyncExecutionReadinessStatus::WaitingForArtifact: return "WaitingForArtifact"; + case LiteWalletSyncExecutionReadinessStatus::WaitingForBackendLink: return "WaitingForBackendLink"; + case LiteWalletSyncExecutionReadinessStatus::WaitingForBridge: return "WaitingForBridge"; + case LiteWalletSyncExecutionReadinessStatus::WaitingForIntegration: return "WaitingForIntegration"; + case LiteWalletSyncExecutionReadinessStatus::WaitingForExecutionOwner: return "WaitingForExecutionOwner"; + case LiteWalletSyncExecutionReadinessStatus::WaitingForCancellation: return "WaitingForCancellation"; + case LiteWalletSyncExecutionReadinessStatus::WaitingForShutdown: return "WaitingForShutdown"; + case LiteWalletSyncExecutionReadinessStatus::WaitingForRetry: return "WaitingForRetry"; + case LiteWalletSyncExecutionReadinessStatus::WaitingForRecovery: return "WaitingForRecovery"; + case LiteWalletSyncExecutionReadinessStatus::UnsafePlan: return "UnsafePlan"; + } + return "Unknown"; +} + +const char* liteWalletSyncExecutionReadinessIssueName( + LiteWalletSyncExecutionReadinessIssue issue) +{ + switch (issue) { + case LiteWalletSyncExecutionReadinessIssue::FullNodeBuild: return "FullNodeBuild"; + case LiteWalletSyncExecutionReadinessIssue::LiteBackendCapabilityMissing: return "LiteBackendCapabilityMissing"; + case LiteWalletSyncExecutionReadinessIssue::ArtifactPathMissing: return "ArtifactPathMissing"; + case LiteWalletSyncExecutionReadinessIssue::ArtifactMissing: return "ArtifactMissing"; + case LiteWalletSyncExecutionReadinessIssue::ArtifactUnreadable: return "ArtifactUnreadable"; + case LiteWalletSyncExecutionReadinessIssue::ArtifactNotSdxlCompatible: return "ArtifactNotSdxlCompatible"; + case LiteWalletSyncExecutionReadinessIssue::ArtifactSymbolsMissing: return "ArtifactSymbolsMissing"; + case LiteWalletSyncExecutionReadinessIssue::ArtifactStringOwnershipUnverified: return "ArtifactStringOwnershipUnverified"; + case LiteWalletSyncExecutionReadinessIssue::ArtifactShutdownUnavailable: return "ArtifactShutdownUnavailable"; + case LiteWalletSyncExecutionReadinessIssue::BackendNotLinked: return "BackendNotLinked"; + case LiteWalletSyncExecutionReadinessIssue::BridgeUnavailable: return "BridgeUnavailable"; + case LiteWalletSyncExecutionReadinessIssue::IntegrationRejected: return "IntegrationRejected"; + case LiteWalletSyncExecutionReadinessIssue::IntegrationUnsafe: return "IntegrationUnsafe"; + case LiteWalletSyncExecutionReadinessIssue::IntegrationFeedNotReady: return "IntegrationFeedNotReady"; + case LiteWalletSyncExecutionReadinessIssue::WorkerQueueOwnerMissing: return "WorkerQueueOwnerMissing"; + case LiteWalletSyncExecutionReadinessIssue::SyncLoopOwnerMissing: return "SyncLoopOwnerMissing"; + case LiteWalletSyncExecutionReadinessIssue::StartSyncExecutionMissing: return "StartSyncExecutionMissing"; + case LiteWalletSyncExecutionReadinessIssue::SyncStatusExecutionMissing: return "SyncStatusExecutionMissing"; + case LiteWalletSyncExecutionReadinessIssue::CancellationPathMissing: return "CancellationPathMissing"; + case LiteWalletSyncExecutionReadinessIssue::CancellationPending: return "CancellationPending"; + case LiteWalletSyncExecutionReadinessIssue::ShutdownPathMissing: return "ShutdownPathMissing"; + case LiteWalletSyncExecutionReadinessIssue::ShutdownPending: return "ShutdownPending"; + case LiteWalletSyncExecutionReadinessIssue::RetryPolicyMissing: return "RetryPolicyMissing"; + case LiteWalletSyncExecutionReadinessIssue::RetryLimitReached: return "RetryLimitReached"; + case LiteWalletSyncExecutionReadinessIssue::UserVisibleStatusMissing: return "UserVisibleStatusMissing"; + case LiteWalletSyncExecutionReadinessIssue::RecoveryClearMissing: return "RecoveryClearMissing"; + case LiteWalletSyncExecutionReadinessIssue::RecoveryRescanMissing: return "RecoveryRescanMissing"; + case LiteWalletSyncExecutionReadinessIssue::RecoveryRestartMissing: return "RecoveryRestartMissing"; + case LiteWalletSyncExecutionReadinessIssue::RecoveryUserAttentionMissing: return "RecoveryUserAttentionMissing"; + } + return "Unknown"; +} + +LiteWalletSyncExecutionReadinessResult evaluateLiteWalletSyncExecutionReadiness( + const LiteWalletSyncExecutionReadinessInput& input, + LiteWalletSyncExecutionReadinessOptions options) +{ + LiteWalletSyncExecutionReadinessResult result; + result.capabilities = input.capabilities; + result.backendStatus = input.backend.status; + copyIntegrationSummary(result, input.integrationReport); + + if (options.requireLiteBuild && !isLiteBuild(input.capabilities)) { + return stoppedResult( + std::move(result), + LiteWalletSyncExecutionReadinessStatus::WaitingForLiteBuild, + LiteWalletSyncExecutionReadinessIssue::FullNodeBuild, + "lite sync execution readiness requires a lite build"); + } + result.liteBuildAccepted = true; + + if (options.requireLiteBackendCapability && !supportsLiteBackend(input.capabilities)) { + return stoppedResult( + std::move(result), + LiteWalletSyncExecutionReadinessStatus::WaitingForBackendLink, + LiteWalletSyncExecutionReadinessIssue::LiteBackendCapabilityMissing, + "lite backend capability is not available"); + } + + if (options.requireValidatedArtifact) { + if (!input.artifact.pathConfigured || input.artifact.artifactPath.empty()) { + return stoppedResult( + std::move(result), + LiteWalletSyncExecutionReadinessStatus::WaitingForArtifact, + LiteWalletSyncExecutionReadinessIssue::ArtifactPathMissing, + "SDXL-compatible lite backend artifact path is not configured"); + } + if (!input.artifact.exists) { + return stoppedResult( + std::move(result), + LiteWalletSyncExecutionReadinessStatus::WaitingForArtifact, + LiteWalletSyncExecutionReadinessIssue::ArtifactMissing, + "SDXL-compatible lite backend artifact does not exist"); + } + if (!input.artifact.readable) { + return stoppedResult( + std::move(result), + LiteWalletSyncExecutionReadinessStatus::WaitingForArtifact, + LiteWalletSyncExecutionReadinessIssue::ArtifactUnreadable, + "SDXL-compatible lite backend artifact is not readable"); + } + if (!input.artifact.sdxlCompatible) { + return stoppedResult( + std::move(result), + LiteWalletSyncExecutionReadinessStatus::WaitingForArtifact, + LiteWalletSyncExecutionReadinessIssue::ArtifactNotSdxlCompatible, + "lite backend artifact has not been validated as SDXL-compatible"); + } + if (!coreArtifactSymbolsReady(input.artifact.symbols)) { + return stoppedResult( + std::move(result), + LiteWalletSyncExecutionReadinessStatus::WaitingForArtifact, + LiteWalletSyncExecutionReadinessIssue::ArtifactSymbolsMissing, + "lite backend artifact is missing required SDXL lifecycle or execute symbols"); + } + if (!input.artifact.symbols.freeString) { + return stoppedResult( + std::move(result), + LiteWalletSyncExecutionReadinessStatus::WaitingForArtifact, + LiteWalletSyncExecutionReadinessIssue::ArtifactStringOwnershipUnverified, + "lite backend artifact string ownership cleanup is not validated"); + } + if (!input.artifact.symbols.shutdown) { + return stoppedResult( + std::move(result), + LiteWalletSyncExecutionReadinessStatus::WaitingForArtifact, + LiteWalletSyncExecutionReadinessIssue::ArtifactShutdownUnavailable, + "lite backend artifact shutdown symbol is not validated"); + } + } + result.artifactAccepted = true; + + if (options.requireLinkedBackend && !input.backend.linked) { + return stoppedResult( + std::move(result), + LiteWalletSyncExecutionReadinessStatus::WaitingForBackendLink, + LiteWalletSyncExecutionReadinessIssue::BackendNotLinked, + backendMessageOrDefault(input.backend.status, "lite backend is not linked")); + } + result.backendLinkedAccepted = true; + + if (options.requireBridgeAvailable && !input.backend.bridgeAvailable) { + const auto message = !input.backend.bridgeUnavailableReason.empty() + ? input.backend.bridgeUnavailableReason + : backendMessageOrDefault(input.backend.status, "lite client bridge is unavailable"); + return stoppedResult( + std::move(result), + LiteWalletSyncExecutionReadinessStatus::WaitingForBridge, + LiteWalletSyncExecutionReadinessIssue::BridgeUnavailable, + message); + } + result.bridgeAccepted = true; + + if (integrationReportIsUnsafe(input.integrationReport)) { + return stoppedResult( + std::move(result), + LiteWalletSyncExecutionReadinessStatus::UnsafePlan, + LiteWalletSyncExecutionReadinessIssue::IntegrationUnsafe, + "lite sync/app-refresh integration report is not a no-network dry-run report"); + } + + if (result.recoveryRequired) { + return evaluateRecoveryReadiness(std::move(result), input.recovery, options); + } + + if (result.cancellationRequired || input.cancellation.cancellationRequested) { + result.cancellationRequired = true; + if (!input.cancellation.cancellationPathReady) { + return stoppedResult( + std::move(result), + LiteWalletSyncExecutionReadinessStatus::WaitingForCancellation, + LiteWalletSyncExecutionReadinessIssue::CancellationPathMissing, + "lite sync cancellation path must be ready before sync execution"); + } + if (!input.cancellation.cancellationComplete) { + return stoppedResult( + std::move(result), + LiteWalletSyncExecutionReadinessStatus::WaitingForCancellation, + LiteWalletSyncExecutionReadinessIssue::CancellationPending, + "lite sync cancellation must complete before sync execution"); + } + } + + if (!input.integrationReport.ok) { + return stoppedResult( + std::move(result), + LiteWalletSyncExecutionReadinessStatus::WaitingForIntegration, + LiteWalletSyncExecutionReadinessIssue::IntegrationRejected, + input.integrationReport.error.empty() + ? "lite sync/app-refresh integration report is not successful" + : input.integrationReport.error); + } + + if (options.requireIntegrationFeedReady && !input.integrationReport.futureWorkerQueueFeedReady) { + return stoppedResult( + std::move(result), + LiteWalletSyncExecutionReadinessStatus::WaitingForIntegration, + LiteWalletSyncExecutionReadinessIssue::IntegrationFeedNotReady, + "lite sync/app-refresh integration report is not ready to feed future work"); + } + result.integrationAccepted = true; + + if (options.requireWorkerQueueOwner && !input.ownership.workerQueueOwnerReady) { + return stoppedResult( + std::move(result), + LiteWalletSyncExecutionReadinessStatus::WaitingForExecutionOwner, + LiteWalletSyncExecutionReadinessIssue::WorkerQueueOwnerMissing, + "lite sync execution requires explicit worker queue ownership"); + } + result.workerQueueOwnerAccepted = true; + + if (options.requireSyncLoopOwner && !input.ownership.syncLoopOwnerReady) { + return stoppedResult( + std::move(result), + LiteWalletSyncExecutionReadinessStatus::WaitingForExecutionOwner, + LiteWalletSyncExecutionReadinessIssue::SyncLoopOwnerMissing, + "lite sync execution requires explicit sync loop ownership"); + } + result.syncLoopOwnerAccepted = true; + + if (options.requireStartSyncExecution && !input.ownership.startSyncExecutionReady) { + return stoppedResult( + std::move(result), + LiteWalletSyncExecutionReadinessStatus::WaitingForExecutionOwner, + LiteWalletSyncExecutionReadinessIssue::StartSyncExecutionMissing, + "lite sync start execution path is not ready"); + } + result.startSyncExecutionReady = true; + + if (options.requireSyncStatusPolling && !input.ownership.syncStatusPollingReady) { + return stoppedResult( + std::move(result), + LiteWalletSyncExecutionReadinessStatus::WaitingForExecutionOwner, + LiteWalletSyncExecutionReadinessIssue::SyncStatusExecutionMissing, + "lite syncstatus polling execution path is not ready"); + } + result.syncStatusPollingReady = true; + + if (options.requireCancellationPath && !input.cancellation.cancellationPathReady) { + return stoppedResult( + std::move(result), + LiteWalletSyncExecutionReadinessStatus::WaitingForCancellation, + LiteWalletSyncExecutionReadinessIssue::CancellationPathMissing, + "lite sync cancellation path must be ready before sync execution"); + } + result.cancellationReady = true; + + if (options.requireShutdownHook && !input.shutdown.shutdownHookReady) { + return stoppedResult( + std::move(result), + LiteWalletSyncExecutionReadinessStatus::WaitingForShutdown, + LiteWalletSyncExecutionReadinessIssue::ShutdownPathMissing, + "lite sync shutdown hook must be ready before sync execution"); + } + if (input.shutdown.shutdownRequested && !input.shutdown.shutdownComplete) { + result.shutdownRequired = true; + return stoppedResult( + std::move(result), + LiteWalletSyncExecutionReadinessStatus::WaitingForShutdown, + LiteWalletSyncExecutionReadinessIssue::ShutdownPending, + "lite sync shutdown must complete before new sync execution"); + } + result.shutdownReady = true; + + if (options.requireRetryPolicy && !input.retry.retryPolicyReady) { + return stoppedResult( + std::move(result), + LiteWalletSyncExecutionReadinessStatus::WaitingForRetry, + LiteWalletSyncExecutionReadinessIssue::RetryPolicyMissing, + "lite sync retry policy must be ready before sync execution"); + } + result.retryReady = true; + + if (options.requireUserVisibleStatus && !input.ownership.userVisibleStatusReady) { + return stoppedResult( + std::move(result), + LiteWalletSyncExecutionReadinessStatus::WaitingForRetry, + LiteWalletSyncExecutionReadinessIssue::UserVisibleStatusMissing, + "lite sync execution requires user-visible status reporting"); + } + result.userVisibleStatusReady = true; + + if (input.retry.retryRequested) { + result.retryRequired = true; + if (input.retry.maxAttempts > 0 && input.retry.attempt >= input.retry.maxAttempts) { + return stoppedResult( + std::move(result), + LiteWalletSyncExecutionReadinessStatus::WaitingForRetry, + LiteWalletSyncExecutionReadinessIssue::RetryLimitReached, + "lite sync retry limit has been reached"); + } + } + + result.ok = true; + result.status = LiteWalletSyncExecutionReadinessStatus::ReadyToEnableSyncExecution; + result.syncExecutionCouldStart = true; + result.syncStatusPollingCouldStart = true; + result.executionWouldUseBridge = true; + result.enablementPlan.readyToEnable = true; + result.enablementPlan.startSyncExecutionEnabled = true; + result.enablementPlan.syncStatusPollingEnabled = true; + return result; +} + +LiteWalletSyncExecutionReadinessPlanner::LiteWalletSyncExecutionReadinessPlanner( + LiteWalletSyncExecutionReadinessOptions options) + : options_(options) +{ +} + +LiteWalletSyncExecutionReadinessResult LiteWalletSyncExecutionReadinessPlanner::evaluate( + const LiteWalletSyncExecutionReadinessInput& input) const +{ + return evaluateLiteWalletSyncExecutionReadiness(input, options_); +} + +} // namespace dragonx::wallet \ No newline at end of file diff --git a/src/wallet/lite_wallet_sync_execution_readiness.h b/src/wallet/lite_wallet_sync_execution_readiness.h new file mode 100644 index 0000000..4a2312e --- /dev/null +++ b/src/wallet/lite_wallet_sync_execution_readiness.h @@ -0,0 +1,238 @@ +#pragma once + +#include "lite_wallet_sync_app_refresh_integration.h" +#include "wallet_capabilities.h" + +#include +#include +#include + +namespace dragonx::wallet { + +enum class LiteWalletSyncExecutionReadinessStatus { + ReadyToEnableSyncExecution, + WaitingForLiteBuild, + WaitingForArtifact, + WaitingForBackendLink, + WaitingForBridge, + WaitingForIntegration, + WaitingForExecutionOwner, + WaitingForCancellation, + WaitingForShutdown, + WaitingForRetry, + WaitingForRecovery, + UnsafePlan, +}; + +enum class LiteWalletSyncExecutionReadinessIssue { + FullNodeBuild, + LiteBackendCapabilityMissing, + ArtifactPathMissing, + ArtifactMissing, + ArtifactUnreadable, + ArtifactNotSdxlCompatible, + ArtifactSymbolsMissing, + ArtifactStringOwnershipUnverified, + ArtifactShutdownUnavailable, + BackendNotLinked, + BridgeUnavailable, + IntegrationRejected, + IntegrationUnsafe, + IntegrationFeedNotReady, + WorkerQueueOwnerMissing, + SyncLoopOwnerMissing, + StartSyncExecutionMissing, + SyncStatusExecutionMissing, + CancellationPathMissing, + CancellationPending, + ShutdownPathMissing, + ShutdownPending, + RetryPolicyMissing, + RetryLimitReached, + UserVisibleStatusMissing, + RecoveryClearMissing, + RecoveryRescanMissing, + RecoveryRestartMissing, + RecoveryUserAttentionMissing, +}; + +struct LiteWalletSdxlArtifactSymbolsInput { + bool walletExists = false; + bool initializeNew = false; + bool initializeNewFromPhrase = false; + bool initializeExisting = false; + bool execute = false; + bool freeString = false; + bool checkServerOnline = false; + bool shutdown = false; +}; + +struct LiteWalletSdxlArtifactInput { + bool pathConfigured = false; + bool exists = false; + bool readable = false; + bool sdxlCompatible = false; + std::string artifactPath; + std::string versionLabel; + LiteWalletSdxlArtifactSymbolsInput symbols; +}; + +struct LiteWalletLinkedBackendReadinessInput { + bool linked = false; + bool bridgeAvailable = false; + WalletBackendStatus status; + std::string bridgeUnavailableReason; +}; + +struct LiteWalletSyncExecutionOwnershipInput { + bool workerQueueOwnerReady = false; + bool syncLoopOwnerReady = false; + bool startSyncExecutionReady = false; + bool syncStatusPollingReady = false; + bool userVisibleStatusReady = false; +}; + +struct LiteWalletSyncExecutionCancellationReadinessInput { + bool cancellationPathReady = false; + bool cancellationRequested = false; + bool cancellationComplete = false; +}; + +struct LiteWalletSyncExecutionShutdownReadinessInput { + bool shutdownHookReady = false; + bool shutdownRequested = false; + bool shutdownComplete = false; +}; + +struct LiteWalletSyncExecutionRetryReadinessInput { + bool retryPolicyReady = false; + bool retryRequested = false; + std::size_t attempt = 0; + std::size_t maxAttempts = 0; +}; + +struct LiteWalletSyncExecutionRecoveryReadinessInput { + bool clearActionReady = false; + bool rescanActionReady = false; + bool restartSyncActionReady = false; + bool userAttentionPathReady = false; +}; + +struct LiteWalletSyncExecutionReadinessInput { + WalletCapabilities capabilities; + LiteWalletSdxlArtifactInput artifact; + LiteWalletLinkedBackendReadinessInput backend; + LiteWalletSyncExecutionOwnershipInput ownership; + LiteWalletSyncExecutionCancellationReadinessInput cancellation; + LiteWalletSyncExecutionShutdownReadinessInput shutdown; + LiteWalletSyncExecutionRetryReadinessInput retry; + LiteWalletSyncExecutionRecoveryReadinessInput recovery; + LiteWalletSyncAppRefreshIntegrationResult integrationReport; +}; + +struct LiteWalletSyncExecutionReadinessOptions { + bool requireLiteBuild = true; + bool requireLiteBackendCapability = true; + bool requireValidatedArtifact = true; + bool requireLinkedBackend = true; + bool requireBridgeAvailable = true; + bool requireIntegrationFeedReady = true; + bool requireWorkerQueueOwner = true; + bool requireSyncLoopOwner = true; + bool requireStartSyncExecution = true; + bool requireSyncStatusPolling = true; + bool requireCancellationPath = true; + bool requireShutdownHook = true; + bool requireRetryPolicy = true; + bool requireUserVisibleStatus = true; + bool requireRecoveryExecutionReadiness = true; +}; + +struct LiteWalletSyncExecutionEnablementPlan { + bool readyToEnable = false; + bool startSyncExecutionEnabled = false; + bool syncStatusPollingEnabled = false; + bool workerQueueEnqueued = false; + std::string startSyncCommand; + std::string syncStatusCommand; + std::string workerQueueLane; + LiteWalletRefreshRouteKind route = LiteWalletRefreshRouteKind::Unavailable; +}; + +struct LiteWalletSyncExecutionReadinessIssueInfo { + LiteWalletSyncExecutionReadinessIssue issue = LiteWalletSyncExecutionReadinessIssue::FullNodeBuild; + std::string message; +}; + +struct LiteWalletSyncExecutionReadinessResult { + bool ok = false; + bool dryRunOnly = true; + bool noNetwork = true; + bool noBridgeCalls = true; + bool noSyncStarted = true; + bool noSyncStatusPolled = true; + bool noWalletPersistence = true; + bool stateMutationAllowed = false; + bool stateMutated = false; + bool walletStateWritten = false; + bool workerQueueEnqueued = false; + + bool liteBuildAccepted = false; + bool artifactAccepted = false; + bool backendLinkedAccepted = false; + bool bridgeAccepted = false; + bool integrationAccepted = false; + bool workerQueueOwnerAccepted = false; + bool syncLoopOwnerAccepted = false; + bool startSyncExecutionReady = false; + bool syncStatusPollingReady = false; + bool cancellationReady = false; + bool shutdownReady = false; + bool retryReady = false; + bool userVisibleStatusReady = false; + bool recoveryExecutionReady = false; + + bool syncExecutionCouldStart = false; + bool syncStatusPollingCouldStart = false; + bool executionWouldUseBridge = false; + bool integrationFeedReady = false; + bool recoveryRequired = false; + bool cancellationRequired = false; + bool shutdownRequired = false; + bool retryRequired = false; + bool futureClearRequired = false; + bool futureRescanRequired = false; + bool futureRestartSyncRequired = false; + bool requiresUserAttention = false; + + LiteWalletSyncExecutionReadinessStatus status = LiteWalletSyncExecutionReadinessStatus::WaitingForLiteBuild; + WalletCapabilities capabilities; + WalletBackendStatus backendStatus; + LiteWalletSyncAppRefreshIntegrationResult integrationReport; + LiteWalletSyncExecutionEnablementPlan enablementPlan; + std::vector issues; + std::string error; +}; + +const char* liteWalletSyncExecutionReadinessStatusName( + LiteWalletSyncExecutionReadinessStatus status); +const char* liteWalletSyncExecutionReadinessIssueName( + LiteWalletSyncExecutionReadinessIssue issue); + +LiteWalletSyncExecutionReadinessResult evaluateLiteWalletSyncExecutionReadiness( + const LiteWalletSyncExecutionReadinessInput& input, + LiteWalletSyncExecutionReadinessOptions options = {}); + +class LiteWalletSyncExecutionReadinessPlanner { +public: + explicit LiteWalletSyncExecutionReadinessPlanner( + LiteWalletSyncExecutionReadinessOptions options = {}); + + LiteWalletSyncExecutionReadinessResult evaluate( + const LiteWalletSyncExecutionReadinessInput& input) const; + +private: + LiteWalletSyncExecutionReadinessOptions options_; +}; + +} // namespace dragonx::wallet \ No newline at end of file diff --git a/src/wallet/wallet_backend.h b/src/wallet/wallet_backend.h new file mode 100644 index 0000000..3214e04 --- /dev/null +++ b/src/wallet/wallet_backend.h @@ -0,0 +1,93 @@ +// DragonX Wallet - ImGui Edition +// Copyright 2024-2026 The Hush Developers +// Released under the GPLv3 + +#pragma once + +#include "wallet_capabilities.h" + +#include +#include +#include +#include + +namespace dragonx { +namespace wallet { + +enum class WalletBackendState { + Unavailable, + Disconnected, + Connecting, + Syncing, + Ready, + Error +}; + +struct WalletBackendStatus { + WalletBackendState state = WalletBackendState::Unavailable; + std::string message; + std::optional walletHeight; + std::optional chainHeight; + double syncProgress = 0.0; +}; + +struct WalletBackendResult { + bool ok = false; + std::string error; +}; + +struct WalletOpenRequest { + std::string walletPath; + std::string serverUrl; + bool restoreFromSeed = false; +}; + +struct WalletSendRequest { + std::string fromAddress; + std::string toAddress; + double amount = 0.0; + double fee = 0.0; + std::string memo; +}; + +struct WalletSendResult { + bool accepted = false; + std::string txid; + std::string error; +}; + +class WalletBackend { +public: + virtual ~WalletBackend() = default; + + virtual WalletBackendKind kind() const = 0; + virtual WalletCapabilities capabilities() const = 0; + virtual WalletBackendStatus status() const = 0; +}; + +class FullNodeWalletBackend : public WalletBackend { +public: + ~FullNodeWalletBackend() override = default; +}; + +class LiteWalletBackend : public WalletBackend { +public: + ~LiteWalletBackend() override = default; + + virtual WalletBackendResult setServer(const std::string& serverUrl) = 0; + virtual WalletBackendResult openWallet(const WalletOpenRequest& request) = 0; + virtual WalletBackendResult startSync() = 0; + virtual WalletBackendResult cancelSync() = 0; + virtual WalletSendResult sendTransaction(const WalletSendRequest& request) = 0; +}; + +class WalletBackendRouter { +public: + virtual ~WalletBackendRouter() = default; + + virtual WalletBackend& activeBackend() = 0; + virtual const WalletBackend& activeBackend() const = 0; +}; + +} // namespace wallet +} // namespace dragonx \ No newline at end of file diff --git a/src/wallet/wallet_capabilities.h b/src/wallet/wallet_capabilities.h new file mode 100644 index 0000000..9bda755 --- /dev/null +++ b/src/wallet/wallet_capabilities.h @@ -0,0 +1,179 @@ +// DragonX Wallet - ImGui Edition +// Copyright 2024-2026 The Hush Developers +// Released under the GPLv3 + +#pragma once + +#ifndef DRAGONX_LITE_BUILD +#define DRAGONX_LITE_BUILD 0 +#endif + +#ifndef DRAGONX_ENABLE_EMBEDDED_DAEMON +#define DRAGONX_ENABLE_EMBEDDED_DAEMON 1 +#endif + +#ifndef DRAGONX_ENABLE_LITE_BACKEND +#define DRAGONX_ENABLE_LITE_BACKEND 0 +#endif + +namespace dragonx { +namespace wallet { + +enum class WalletBuildKind { + FullNode, + Lite +}; + +enum class WalletBackendKind { + FullNodeRpc, + LiteClient +}; + +enum class WalletUiSurface { + Overview, + Send, + Receive, + History, + Mining, + Market, + Console, + Peers, + Explorer, + Settings, + BootstrapDownload, + SetupWizard, + NodeSettings +}; + +struct WalletCapabilities { + WalletBuildKind buildKind = WalletBuildKind::FullNode; + WalletBackendKind backendKind = WalletBackendKind::FullNodeRpc; + bool fullNodeRpcAvailable = true; + bool embeddedDaemonAvailable = true; + bool fullNodePagesAvailable = true; + bool fullNodeLifecycleActionsAvailable = true; + bool soloMiningAvailable = true; + bool poolMiningAvailable = true; + bool liteBackendAvailable = false; + bool lightwalletdNetworkAvailable = false; + bool liteWalletLifecycleAvailable = false; + bool liteWalletSyncAvailable = false; + bool liteWalletSendAvailable = false; +}; + +constexpr bool isLiteBuild(WalletBuildKind buildKind) +{ + return buildKind == WalletBuildKind::Lite; +} + +constexpr bool isLiteBuild(const WalletCapabilities& capabilities) +{ + return isLiteBuild(capabilities.buildKind); +} + +constexpr bool isFullNodeBuild(WalletBuildKind buildKind) +{ + return buildKind == WalletBuildKind::FullNode; +} + +constexpr WalletCapabilities makeWalletCapabilities( + WalletBuildKind buildKind, + bool embeddedDaemonCompiled, + bool liteBackendLinked) +{ + const bool liteBuild = isLiteBuild(buildKind); + const bool fullNodeBuild = !liteBuild; + const bool liteBackendAvailable = liteBuild && liteBackendLinked; + + return WalletCapabilities{ + buildKind, + liteBuild ? WalletBackendKind::LiteClient : WalletBackendKind::FullNodeRpc, + fullNodeBuild, + fullNodeBuild && embeddedDaemonCompiled, + fullNodeBuild, + fullNodeBuild, + fullNodeBuild, + true, + liteBackendAvailable, + liteBackendAvailable, + liteBackendAvailable, + liteBackendAvailable, + liteBackendAvailable + }; +} + +constexpr WalletBuildKind currentWalletBuildKind() +{ + return DRAGONX_LITE_BUILD ? WalletBuildKind::Lite : WalletBuildKind::FullNode; +} + +constexpr WalletCapabilities currentWalletCapabilities() +{ + return makeWalletCapabilities( + currentWalletBuildKind(), + DRAGONX_ENABLE_EMBEDDED_DAEMON != 0, + DRAGONX_ENABLE_LITE_BACKEND != 0); +} + +constexpr bool supportsEmbeddedDaemon(const WalletCapabilities& capabilities) +{ + return capabilities.embeddedDaemonAvailable; +} + +constexpr bool supportsFullNodeLifecycleActions(const WalletCapabilities& capabilities) +{ + return capabilities.fullNodeLifecycleActionsAvailable; +} + +constexpr bool supportsSoloMining(const WalletCapabilities& capabilities) +{ + return capabilities.soloMiningAvailable; +} + +constexpr bool supportsPoolMining(const WalletCapabilities& capabilities) +{ + return capabilities.poolMiningAvailable; +} + +constexpr bool supportsLiteBackend(const WalletCapabilities& capabilities) +{ + return capabilities.liteBackendAvailable; +} + +constexpr bool supportsWalletDataBackend(const WalletCapabilities& capabilities) +{ + return capabilities.fullNodeRpcAvailable || capabilities.liteWalletSyncAvailable; +} + +constexpr bool isUiSurfaceAvailable(const WalletCapabilities& capabilities, + WalletUiSurface surface) +{ + switch (surface) { + case WalletUiSurface::Console: + case WalletUiSurface::Peers: + case WalletUiSurface::Explorer: + return capabilities.fullNodePagesAvailable; + case WalletUiSurface::BootstrapDownload: + case WalletUiSurface::SetupWizard: + case WalletUiSurface::NodeSettings: + return capabilities.fullNodeLifecycleActionsAvailable; + default: + return true; + } +} + +constexpr bool uiSurfaceNeedsWalletData(WalletUiSurface surface) +{ + switch (surface) { + case WalletUiSurface::Overview: + case WalletUiSurface::Send: + case WalletUiSurface::Receive: + case WalletUiSurface::History: + return true; + default: + return false; + } +} + +} // namespace wallet +} // namespace dragonx \ No newline at end of file diff --git a/tests/fixtures/hushchat/CAPTURE_MANIFEST.md b/tests/fixtures/hushchat/CAPTURE_MANIFEST.md new file mode 100644 index 0000000..0094a0c --- /dev/null +++ b/tests/fixtures/hushchat/CAPTURE_MANIFEST.md @@ -0,0 +1,27 @@ +# HushChat Capture Manifest + +The capture manifest is a redacted provenance file for a staged directory of real, disposable, non-sensitive SilentDragonXLite HushChat vectors. It does not replace fixture validation; it records that the staged directory was handled under the safety rules required before the Batch 11 strict replacement dry run. + +Copy `templates/capture-manifest.template.json` into the staged fixture directory as `capture-manifest.json`, then change `status` to `staged` and each category `status` to `ready`. Keep the file limited to provenance, handling flags, category filenames, and the dry-run command. + +Validate only the manifest metadata with: + +```sh +./build/bin/HushChatFixtureCheck --validate-capture-manifest /path/to/staged/hushchat-fixtures +``` + +The validator accepts a directory containing `capture-manifest.json` or a direct manifest file path. It prints only a redacted report with schema status, category coverage, handling-flag counts, basenames, and error names. + +The manifest must include: +- schema `dragonx.hushchat.capture-manifest.v1` +- status `staged` +- a redacted manifest id +- staged fixture directory name +- dry-run command containing `HushChatFixtureCheck --replacement-dry-run` +- provenance fields for source client, source client version or commit, capture date, network, and capture method +- all required handling flags set to `true` +- exactly one entry for each required fixture category + +The manifest must not include passphrases, plaintext, memo contents, private keys, wallet files, ciphertext byte dumps, stored chat key fields, public-key fields, secretstream headers, derived keys, session keys, or any fixture object. The manifest validator rejects known prohibited field names, but it is still a metadata guard rather than a secret scanner. + +After the manifest validates, run the strict replacement dry run against the same staged directory. Pending checked-in fixtures must not be replaced until both commands succeed. \ No newline at end of file diff --git a/tests/fixtures/hushchat/IMPORT_CHECKLIST.md b/tests/fixtures/hushchat/IMPORT_CHECKLIST.md new file mode 100644 index 0000000..ddbd2fc --- /dev/null +++ b/tests/fixtures/hushchat/IMPORT_CHECKLIST.md @@ -0,0 +1,40 @@ +# HushChat Fixture Import Checklist + +This checklist is for replacing the pending placeholders with real, non-sensitive SilentDragonXLite compatibility vectors. + +Do not commit passphrases, plaintext, memo contents from real wallets, private keys, wallet files, or arbitrary ciphertext dumps. Use only disposable test wallets and non-sensitive test messages. The checked-in ready files must contain only the schema fields required by the loader. + +Required categories: +- `incoming_memo`: received encrypted Memo vector, expected `ClientRx` +- `outgoing_memo`: outgoing-history encrypted Memo vector, expected `ServerTx` +- `seed_public_key_projection`: vector proving the SDXL UTF-8-hex seed projection matches the recorded local public key +- `corrupted_auth_failure`: structurally valid Memo vector reserved for future authentication-failure verification +- `cont_exclusion`: contact request vector that remains excluded from encrypted Memo decrypt preparation + +Capture rules: +- Use disposable SilentDragonXLite wallets only. +- Use a fixed non-sensitive test phrase and record only its hash if a plaintext expectation is needed. +- Do not store decrypted message text in fixture files. +- Do not include private keys, viewing keys, spending keys, wallet seed phrases, or wallet database contents. +- Keep the top-level `schema` value as `dragonx.hushchat.compat-fixture.v1`. +- Change `status` from `pending` to `ready` only when the fixture has the full `fixture` object documented in the protocol spec. +- Preserve one fixture file per required category. +- For every ready non-`Cont` vector, the stored SDXL chat key string must project to the declared local public key using SDXL's first-32-UTF-8-bytes seed behavior. +- The projection check records only byte lengths and match status; it must not write passphrases, plaintext, derived secret keys, memo contents, or ciphertext bytes. +- A ready `corrupted_auth_failure` vector must be structurally valid through the same loader, verifier, and projection checks, then marked as requiring a future secretstream authentication failure. +- The corrupted-auth marker is not a decrypt result and is not an authentication result. +- Run the strict replacement dry-run report against a staged directory before copying any ready files over the checked-in pending placeholders. +- The dry-run report must remain redacted; it may contain category names, basenames, status/error names, boolean flags, and counts only. +- Add `capture-manifest.json` to the staged directory from `templates/capture-manifest.template.json` and validate it before strict replacement dry-run checks. +- The capture manifest records provenance, handling flags, category filenames, and dry-run instructions only; it must not contain fixture objects or sensitive fields. + +Verification flow: + +```sh +./build/bin/HushChatFixtureCheck --allow-pending tests/fixtures/hushchat +./build/bin/HushChatFixtureCheck --validate-capture-manifest /path/to/staged/hushchat-fixtures +./build/bin/HushChatFixtureCheck --replacement-dry-run /path/to/staged/hushchat-fixtures +./build/bin/HushChatFixtureCheck tests/fixtures/hushchat +``` + +The first command is for the current scaffold state and allows pending files. The manifest command validates only redacted staged-directory metadata. The dry-run command is strict, refuses `--allow-pending`, performs no file replacement, and must fail until the staged directory contains all five real ready vectors with no pending, malformed, mismatched, projection-failed, auth-not-ready, or Cont-not-excluded entries. The final command is the post-copy strict check on the checked-in fixture directory; it must report `future_auth_required=1` and `auth_structural_ready=1`. A ready import is acceptable only when the manifest command and both strict fixture commands exit successfully. \ No newline at end of file diff --git a/tests/fixtures/hushchat/README.md b/tests/fixtures/hushchat/README.md new file mode 100644 index 0000000..0038815 --- /dev/null +++ b/tests/fixtures/hushchat/README.md @@ -0,0 +1,31 @@ +# HushChat Compatibility Fixtures + +This directory contains the checked-in fixture-file schema for non-sensitive HushChat compatibility vectors. + +The current files are intentionally marked `pending`. They define the exact vector categories and required fields without pretending that real SilentDragonXLite compatibility data has been captured yet. + +Use the developer checker after building: + +```sh +./build/bin/HushChatFixtureCheck --allow-pending tests/fixtures/hushchat +``` + +The command above is expected to pass while files are still pending. Before replacing pending placeholders with real `ready` vectors, run the same command without `--allow-pending`; it exits successfully only when all five required categories are supplied exactly once, pass the fixture loader/import checklist, satisfy the seed/public-key projection verifier, and mark the corrupted-auth vector as structurally ready for a future authentication-failure check. + +For a strict replacement dry run against a staged directory of real vectors, use: + +```sh +./build/bin/HushChatFixtureCheck --replacement-dry-run /path/to/staged/hushchat-fixtures +``` + +The dry-run mode refuses pending vectors and prints only a redacted replacement report with categories, basenames, status/error names, boolean flags, and aggregate counts. It does not copy files or print key material, memo contents, plaintext, ciphertext bytes, or hashes. + +Before running the strict replacement dry run on real staged vectors, add a redacted capture manifest and validate it: + +```sh +./build/bin/HushChatFixtureCheck --validate-capture-manifest /path/to/staged/hushchat-fixtures +``` + +The manifest template lives at `templates/capture-manifest.template.json`. See `CAPTURE_MANIFEST.md` for the metadata rules. + +See `IMPORT_CHECKLIST.md` for the capture rules. diff --git a/tests/fixtures/hushchat/cont-exclusion.pending.json b/tests/fixtures/hushchat/cont-exclusion.pending.json new file mode 100644 index 0000000..ba2f55a --- /dev/null +++ b/tests/fixtures/hushchat/cont-exclusion.pending.json @@ -0,0 +1,7 @@ +{ + "schema": "dragonx.hushchat.compat-fixture.v1", + "status": "pending", + "kind": "cont_exclusion", + "id": "sdxl-cont-exclusion", + "pending_reason": "Needs a non-sensitive Cont fixture proving contact requests remain outside encrypted Memo decrypt handling." +} \ No newline at end of file diff --git a/tests/fixtures/hushchat/corrupted-auth-failure.pending.json b/tests/fixtures/hushchat/corrupted-auth-failure.pending.json new file mode 100644 index 0000000..74c2331 --- /dev/null +++ b/tests/fixtures/hushchat/corrupted-auth-failure.pending.json @@ -0,0 +1,7 @@ +{ + "schema": "dragonx.hushchat.compat-fixture.v1", + "status": "pending", + "kind": "corrupted_auth_failure", + "id": "sdxl-corrupted-auth-failure", + "pending_reason": "Needs a non-sensitive Memo vector that passes structural Batch 1-6 validation but is expected to fail future secretstream authentication." +} \ No newline at end of file diff --git a/tests/fixtures/hushchat/incoming-memo.pending.json b/tests/fixtures/hushchat/incoming-memo.pending.json new file mode 100644 index 0000000..e301c2c --- /dev/null +++ b/tests/fixtures/hushchat/incoming-memo.pending.json @@ -0,0 +1,7 @@ +{ + "schema": "dragonx.hushchat.compat-fixture.v1", + "status": "pending", + "kind": "incoming_memo", + "id": "sdxl-incoming-memo", + "pending_reason": "Needs a non-sensitive incoming Memo vector captured from SilentDragonXLite with stored chat key hex, public keys, header memo, ciphertext memo, expected role, byte lengths, and plaintext hash only." +} \ No newline at end of file diff --git a/tests/fixtures/hushchat/outgoing-memo.pending.json b/tests/fixtures/hushchat/outgoing-memo.pending.json new file mode 100644 index 0000000..7059693 --- /dev/null +++ b/tests/fixtures/hushchat/outgoing-memo.pending.json @@ -0,0 +1,7 @@ +{ + "schema": "dragonx.hushchat.compat-fixture.v1", + "status": "pending", + "kind": "outgoing_memo", + "id": "sdxl-outgoing-memo", + "pending_reason": "Needs a non-sensitive outgoing-history Memo vector captured from SilentDragonXLite with stored chat key hex, local and peer public keys, header memo, ciphertext memo, expected server_tx role, byte lengths, and plaintext hash only." +} \ No newline at end of file diff --git a/tests/fixtures/hushchat/seed-public-key-projection.pending.json b/tests/fixtures/hushchat/seed-public-key-projection.pending.json new file mode 100644 index 0000000..c24b45a --- /dev/null +++ b/tests/fixtures/hushchat/seed-public-key-projection.pending.json @@ -0,0 +1,7 @@ +{ + "schema": "dragonx.hushchat.compat-fixture.v1", + "status": "pending", + "kind": "seed_public_key_projection", + "id": "sdxl-seed-public-key-projection", + "pending_reason": "Needs a non-sensitive vector proving the SilentDragonXLite UTF-8-hex seed projection produces the observed local public key without storing the original passphrase or plaintext." +} \ No newline at end of file diff --git a/tests/fixtures/hushchat/templates/capture-manifest.template.json b/tests/fixtures/hushchat/templates/capture-manifest.template.json new file mode 100644 index 0000000..ba47866 --- /dev/null +++ b/tests/fixtures/hushchat/templates/capture-manifest.template.json @@ -0,0 +1,54 @@ +{ + "schema": "dragonx.hushchat.capture-manifest.v1", + "status": "template", + "id": "replace-with-redacted-capture-manifest-id", + "fixture_directory": "replace-with-staged-fixture-directory", + "dry_run_command": "./build/bin/HushChatFixtureCheck --replacement-dry-run replace-with-staged-fixture-directory", + "provenance": { + "source_client": "SilentDragonXLite", + "source_client_version": "replace-with-release-or-commit", + "capture_date": "YYYY-MM-DD", + "network": "replace-with-disposable-test-network", + "capture_method": "replace-with-redacted-capture-procedure-name" + }, + "handling": { + "disposable_wallets_only": true, + "non_sensitive_vectors_only": true, + "no_passphrases": true, + "no_plaintext": true, + "no_memo_contents": true, + "no_private_keys": true, + "no_wallet_files": true, + "no_ciphertext_byte_dumps": true, + "no_derived_keys": true, + "no_session_keys": true, + "redacted_report_only": true + }, + "categories": [ + { + "kind": "incoming_memo", + "staged_filename": "incoming-memo.ready.json", + "status": "template" + }, + { + "kind": "outgoing_memo", + "staged_filename": "outgoing-memo.ready.json", + "status": "template" + }, + { + "kind": "seed_public_key_projection", + "staged_filename": "seed-public-key-projection.ready.json", + "status": "template" + }, + { + "kind": "corrupted_auth_failure", + "staged_filename": "corrupted-auth-failure.ready.json", + "status": "template" + }, + { + "kind": "cont_exclusion", + "staged_filename": "cont-exclusion.ready.json", + "status": "template" + } + ] +} \ No newline at end of file diff --git a/tests/fixtures/lite/release_package_manifest.json b/tests/fixtures/lite/release_package_manifest.json new file mode 100644 index 0000000..9da19bb --- /dev/null +++ b/tests/fixtures/lite/release_package_manifest.json @@ -0,0 +1,60 @@ +{ + "schema": "dragonx.lite.release-package-manifest.v1", + "source": "generated-package-manifest-fixture", + "generated": true, + "packages": [ + { + "name": "ObsidianDragon-full-linux-fixture", + "build_kind": "full-node", + "format": "linux-zip", + "pool_mining_supported": true, + "solo_mining_available": true, + "full_node_lifecycle_actions_available": true, + "expect": { + "dragonxd": true, + "dragonx_cli": true, + "dragonx_tx": true, + "sapling_params": true, + "asmap": true, + "xmrig_when_available": true + }, + "assets": [ + { "kind": "app-binary", "path": "ObsidianDragon", "present": true, "executable": true }, + { "kind": "dragonxd", "path": "usr/bin/dragonxd", "present": true, "executable": true }, + { "kind": "dragonx-cli", "path": "usr/bin/dragonx-cli", "present": true, "executable": true }, + { "kind": "dragonx-tx", "path": "usr/bin/dragonx-tx", "present": true, "executable": true }, + { "kind": "sapling-spend.params", "path": "usr/bin/sapling-spend.params", "present": true, "executable": false }, + { "kind": "sapling-output.params", "path": "usr/bin/sapling-output.params", "present": true, "executable": false }, + { "kind": "asmap.dat", "path": "usr/bin/asmap.dat", "present": true, "executable": false }, + { "kind": "xmrig", "path": "usr/bin/xmrig", "present": true, "executable": true }, + { "kind": "resources", "path": "usr/share/ObsidianDragon/res", "present": true, "executable": false } + ] + }, + { + "name": "ObsidianDragonLite-linux-fixture", + "build_kind": "lite", + "format": "linux-zip", + "pool_mining_supported": true, + "solo_mining_available": false, + "full_node_lifecycle_actions_available": false, + "assets": [ + { "kind": "app-binary", "path": "ObsidianDragonLite", "present": true, "executable": true }, + { "kind": "xmrig", "path": "xmrig", "present": true, "executable": true }, + { "kind": "resources", "path": "res", "present": true, "executable": false } + ] + }, + { + "name": "ObsidianDragonLite-windows-fixture", + "build_kind": "lite", + "format": "windows-zip", + "pool_mining_supported": true, + "solo_mining_available": false, + "full_node_lifecycle_actions_available": false, + "assets": [ + { "kind": "app-binary", "path": "ObsidianDragonLite.exe", "present": true, "executable": true }, + { "kind": "other", "path": "tools/xmrig.exe", "present": true, "executable": true }, + { "kind": "resources", "path": "res", "present": true, "executable": false } + ] + } + ] +} \ No newline at end of file diff --git a/tests/fixtures/lite/result_parsers.json b/tests/fixtures/lite/result_parsers.json new file mode 100644 index 0000000..30bf040 --- /dev/null +++ b/tests/fixtures/lite/result_parsers.json @@ -0,0 +1,107 @@ +{ + "info": { + "chain_name": "dragonx", + "version": "0.1.0", + "vendor": "SilentDragonXLite", + "latest_block_height": 250001, + "difficulty": 42, + "longestchain": 250003, + "notarized": 249990 + }, + "height_object": { + "height": 250004 + }, + "height_number": 250005, + "balance": { + "tbalance": 125000000, + "zbalance": 230000000, + "unconfirmed": 5000000, + "verified_zbalance": 180000000, + "spendable_zbalance": 170000000 + }, + "addresses": { + "z_addresses": [ + "zs1parserfixture0000000000000000000000000000000000000000000000000000", + "zs1parserfixture1111111111111111111111111111111111111111111111111111" + ], + "t_addresses": [ + "RParserFixtureTransparentAddress0000000000001" + ] + }, + "notes": { + "unspent_notes": [ + { + "address": "zs1parserfixture0000000000000000000000000000000000000000000000000000", + "created_in_block": 249900, + "created_in_txid": "note-txid-1", + "value": 100000000, + "spent": false, + "unconfirmed_spent": false + } + ], + "utxos": [ + { + "address": "RParserFixtureTransparentAddress0000000000001", + "created_in_block": 249901, + "created_in_txid": "utxo-txid-1", + "value": 25000000, + "spent": false, + "unconfirmed_spent": true + } + ], + "pending_notes": [ + { + "address": "zs1parserfixture1111111111111111111111111111111111111111111111111111", + "created_in_block": 0, + "created_in_txid": "pending-note-txid-1", + "value": 30000000, + "spent": false, + "unconfirmed_spent": false + } + ], + "pending_utxos": [ + { + "address": "RParserFixtureTransparentAddress0000000000001", + "created_in_block": 0, + "created_in_txid": "pending-utxo-txid-1", + "value": 12000000, + "spent": false, + "unconfirmed_spent": false + } + ] + }, + "list": [ + { + "txid": "sent-txid-1", + "datetime": 1710000000, + "block_height": 249950, + "unconfirmed": false, + "outgoing_metadata": [ + { + "address": "zs1recipientfixture0000000000000000000000000000000000000000000000", + "value": 75000000, + "memo": "outgoing memo" + }, + { + "address": "RRecipientTransparentFixture000000000000001", + "value": 5000000, + "memo": "transparent memo" + } + ] + }, + { + "txid": "receive-txid-1", + "datetime": 1710001000, + "block_height": 0, + "unconfirmed": true, + "address": "zs1parserfixture1111111111111111111111111111111111111111111111111111", + "amount": 42000000, + "memo": "incoming memo", + "position": 2 + } + ], + "syncstatus": { + "synced_blocks": 125002, + "total_blocks": 250004 + } +} \ No newline at end of file diff --git a/tools/hushchat_fixture_check.cpp b/tools/hushchat_fixture_check.cpp new file mode 100644 index 0000000..5202a35 --- /dev/null +++ b/tools/hushchat_fixture_check.cpp @@ -0,0 +1,227 @@ +#include "chat/chat_protocol.h" + +#include +#include +#include +#include +#include + +namespace fs = std::filesystem; + +namespace { + +using dragonx::chat::HushChatCompatibilityFixtureImportCandidate; +using dragonx::chat::HushChatCompatibilityFixtureKind; + +std::string baseName(const std::string& path) +{ + return fs::path(path).filename().string(); +} + +std::vector jsonFilesInDirectory(const fs::path& directory) +{ + std::vector paths; + if (!fs::exists(directory) || !fs::is_directory(directory)) return paths; + + for (const auto& entry : fs::directory_iterator(directory)) { + if (!entry.is_regular_file()) continue; + if (entry.path().extension() != ".json") continue; + paths.push_back(entry.path().string()); + } + std::sort(paths.begin(), paths.end()); + return paths; +} + +HushChatCompatibilityFixtureKind expectedKindFromPath(const std::string& path) +{ + const std::string name = baseName(path); + if (name.find("outgoing") != std::string::npos) return HushChatCompatibilityFixtureKind::OutgoingMemo; + if (name.find("seed") != std::string::npos) return HushChatCompatibilityFixtureKind::SeedPublicKeyProjection; + if (name.find("corrupted") != std::string::npos) return HushChatCompatibilityFixtureKind::CorruptedAuthFailure; + if (name.find("cont") != std::string::npos) return HushChatCompatibilityFixtureKind::ContactExclusion; + return HushChatCompatibilityFixtureKind::IncomingMemo; +} + +void printUsage(const char* program) +{ + std::cerr << "Usage: " << program + << " [--allow-pending] [--replacement-dry-run] [--validate-capture-manifest]" + << " ...\n"; +} + +const char* boolText(bool value) +{ + return value ? "1" : "0"; +} + +void printReplacementDryRun(const dragonx::chat::HushChatCompatibilityFixtureReplacementDryRunResult& dryRun) +{ + std::cout << "HushChat fixture replacement dry run: " + << (dryRun.ok ? "Ready" : "Refused") << "\n"; + std::cout << "error=" << dryRun.error_name + << " dry_run_only=" << boolText(dryRun.dry_run_only) + << " redacted=" << boolText(dryRun.redacted_report) + << " would_replace=" << boolText(dryRun.would_replace) + << " replacement_refused=" << boolText(dryRun.replacement_refused) << "\n"; + std::cout << "required=" << dryRun.required_count + << " supplied=" << dryRun.supplied_count + << " missing=" << dryRun.missing_count + << " verified=" << dryRun.verified_count + << " seed_projected=" << dryRun.seed_projection_verified_count + << " future_auth_required=" << dryRun.future_auth_failure_required_count + << " auth_structural_ready=" << dryRun.auth_failure_structural_ready_count + << " cont_excluded=" << dryRun.excluded_count + << " pending=" << dryRun.pending_count + << " rejected=" << dryRun.rejected_count << "\n"; + + for (const auto& item : dryRun.report_items) { + std::cout << dragonx::chat::hushChatCompatibilityFixtureKindName(item.expected_kind) + << " decision=" << (item.replacement_eligible ? "ready" : "refused") + << " error=" << item.error_name + << " supplied=" << boolText(item.supplied) + << " pending=" << boolText(item.pending) + << " seed_projected=" << boolText(item.seed_projection_verified) + << " future_auth_required=" << boolText(item.future_auth_failure_required) + << " auth_structural_ready=" << boolText(item.structurally_ready_for_future_auth_check) + << " cont_excluded=" << boolText(item.cont_excluded) + << " decrypted=" << boolText(item.decrypted) + << " authenticated=" << boolText(item.authenticated); + if (item.supplied) std::cout << " file=" << baseName(item.path); + std::cout << "\n"; + } +} + +std::string captureManifestPathFromInput(const std::string& input) +{ + fs::path path(input); + if (fs::exists(path) && fs::is_directory(path)) return (path / "capture-manifest.json").string(); + return input; +} + +void printCaptureManifestValidation(const dragonx::chat::HushChatCaptureManifestValidationResult& validation) +{ + std::cout << "HushChat capture manifest: " << (validation.ok ? "Ready" : "Refused") << "\n"; + std::cout << "error=" << validation.error_name + << " redacted=" << boolText(validation.redacted_report) + << " provenance_only=" << boolText(validation.validates_provenance_only) + << " no_sensitive_material=" << boolText(validation.no_sensitive_material_declared) + << " dry_run_instruction=" << boolText(validation.has_dry_run_command); + if (!validation.manifest_path.empty()) std::cout << " manifest=" << baseName(validation.manifest_path); + if (!validation.fixture_directory.empty()) std::cout << " fixture_dir=" << baseName(validation.fixture_directory); + std::cout << "\n"; + std::cout << "required=" << validation.required_count + << " declared=" << validation.declared_count + << " missing=" << validation.missing_count + << " duplicate=" << validation.duplicate_count + << " handling_flags=" << validation.handling_flag_count + << " prohibited=" << validation.prohibited_field_count << "\n"; + + for (const auto& category : validation.categories) { + std::cout << dragonx::chat::hushChatCompatibilityFixtureKindName(category.kind) + << " declared=" << boolText(category.declared); + if (!category.staged_filename.empty()) std::cout << " file=" << baseName(category.staged_filename); + std::cout << "\n"; + } +} + +} // namespace + +int main(int argc, char** argv) +{ + bool allowPending = false; + bool replacementDryRun = false; + bool validateCaptureManifest = false; + std::vector inputPaths; + + for (int index = 1; index < argc; ++index) { + const std::string arg = argv[index]; + if (arg == "--allow-pending") { + allowPending = true; + } else if (arg == "--replacement-dry-run") { + replacementDryRun = true; + } else if (arg == "--validate-capture-manifest") { + validateCaptureManifest = true; + } else if (arg == "--help" || arg == "-h") { + printUsage(argv[0]); + return 0; + } else { + inputPaths.push_back(arg); + } + } + + if (inputPaths.empty()) { + printUsage(argv[0]); + return 2; + } + + if (validateCaptureManifest && (allowPending || replacementDryRun)) { + std::cerr << "Capture manifest validation is separate from fixture and replacement checks.\n"; + return 2; + } + if (replacementDryRun && allowPending) { + std::cerr << "Replacement dry run is strict; remove --allow-pending.\n"; + return 2; + } + + if (validateCaptureManifest) { + bool allValid = true; + for (const auto& input : inputPaths) { + const auto validation = dragonx::chat::loadHushChatCaptureManifestFile( + captureManifestPathFromInput(input), + true); + printCaptureManifestValidation(validation); + if (!validation.ok) allValid = false; + } + return allValid ? 0 : 1; + } + + std::vector paths; + for (const auto& input : inputPaths) { + fs::path path(input); + if (fs::exists(path) && fs::is_directory(path)) { + auto directoryFiles = jsonFilesInDirectory(path); + paths.insert(paths.end(), directoryFiles.begin(), directoryFiles.end()); + } else { + paths.push_back(input); + } + } + + std::vector candidates; + candidates.reserve(paths.size()); + for (const auto& path : paths) { + candidates.push_back(HushChatCompatibilityFixtureImportCandidate{expectedKindFromPath(path), path}); + } + + if (replacementDryRun) { + const auto dryRun = dragonx::chat::inspectHushChatCompatibilityFixtureReplacementDryRun(candidates, true); + printReplacementDryRun(dryRun); + return dryRun.ok ? 0 : 1; + } + + const auto checklist = dragonx::chat::inspectHushChatCompatibilityFixtureImportChecklist(candidates, true); + std::cout << "HushChat fixture import checklist: " << checklist.error_name << "\n"; + std::cout << "required=" << checklist.required_count + << " supplied=" << checklist.supplied_count + << " missing=" << checklist.missing_count + << " verified=" << checklist.verified_count + << " seed_projected=" << checklist.seed_projection_verified_count + << " future_auth_required=" << checklist.future_auth_failure_required_count + << " auth_structural_ready=" << checklist.auth_failure_structural_ready_count + << " cont_excluded=" << checklist.excluded_count + << " pending=" << checklist.pending_count + << " rejected=" << checklist.rejected_count << "\n"; + + for (const auto& item : checklist.items) { + std::cout << dragonx::chat::hushChatCompatibilityFixtureKindName(item.expected_kind) + << " " << item.error_name; + if (item.future_auth_failure_required) std::cout << " FutureAuthFailureRequired"; + if (item.structurally_ready_for_future_auth_check) std::cout << " StructurallyReadyForFutureAuthCheck"; + if (item.supplied) std::cout << " " << baseName(item.path); + std::cout << "\n"; + } + + if (checklist.replacement_ready) return 0; + if (allowPending && checklist.supplied_count == checklist.required_count && + checklist.missing_count == 0 && checklist.pending_count > 0 && checklist.rejected_count == 0) return 0; + return 1; +} \ No newline at end of file