shape-vm 0.3.0

//! PHF-based method registry for Array and DataTable methods
//!
//! This module provides compile-time perfect hash function (PHF) maps for fast O(1) method
//! lookup. The PHF approach is:
//! - Zero runtime overhead: hash computed at compile time
//! - Faster than large match statements (O(1) vs O(n))
//! - Self-documenting: all methods visible in one place
//! - Easy to maintain: add method = one line in phf_map + implementation
//!
//! ## ABI: kinded `&[KindedSlot]` carrier slice (ADR-006 §2.7.9 / Q11)
//!
//! Handlers take an `args: &[KindedSlot]` carrier slice and return
//! `Result<KindedSlot, VMError>`. `args[0]` is the receiver, `args[1..]`
//! are the call arguments. The dispatch shell `op_call_method` in
//! `crates/shape-vm/src/executor/objects/mod.rs` constructs the slice
//! from popped stack args (kind sourced from the §2.7.7 stack
//! parallel-`Vec<NativeKind>` track — no fabrication), and pushes the
//! returned `KindedSlot` onto the stack via `push_kinded`.
//!
//! Bodies dispatch on `args[i].kind` per §2.7.6 / Q8 heterogeneous-kind
//! body pattern, going through `args[i].slot.as_heap_value()` +
//! `HeapValue` match for heap arms (preserves ADR-005 §1
//! single-discriminator). The pre-§2.7.9 kind-blind ABI
//! (`args: &mut [u64]` + `Result<u64, VMError>`) is deleted; see
//! ADR-006 §2.7.9 for the architectural ruling and the W-series
//! defection-attractor family that ABI sat in.

use crate::executor::VirtualMachine;
use phf::{phf_map, phf_set};
use shape_runtime::context::ExecutionContext;
use shape_value::{KindedSlot, VMError};

/// Method handler ABI — kinded carrier slice in, kinded result out
/// (ADR-006 §2.7.9 / Q11).
///
/// - `vm`: Mutable VM instance.
/// - `args`: `args[0]` = receiver, `args[1..]` = arguments, all
///   `KindedSlot` carriers (per §2.7.1 case 4 dispatch-slice form).
///   **Borrow-only** (`&[..]`, not `&mut [..]`): the dispatch shell
///   owns each `KindedSlot`'s share for the call duration and
///   releases it via the carrier's `Drop` (which dispatches to
///   `drop_with_kind` keyed on `kind`). Handlers borrow each entry.
/// - `ctx`: Optional execution context.
/// - Returns: `Result<KindedSlot, VMError>` — the result carrier.
///   The dispatch shell takes ownership of the returned `KindedSlot`'s
///   share, pushes it onto the stack via `push_kinded`, and skips the
///   carrier-drop via `mem::forget` to balance refcounts.
pub type MethodFnV2 = fn(
    &mut VirtualMachine,
    args: &[KindedSlot],
    ctx: Option<&mut ExecutionContext>,
) -> Result<KindedSlot, VMError>;

/// Method handler stored in PHF maps.
pub type MethodHandler = MethodFnV2;

// ═══════════════════════════════════════════════════════════════════════════
// `&mut self` opt-in registries (ADR-006 §2.7.27 / Item 4 ruling, 2026-05-12)
// ═══════════════════════════════════════════════════════════════════════════
//
// Methods that mutate the receiver Arc (i.e. call `Arc::make_mut` on the
// receiver and return a possibly-new Arc) opt in by name in the per-kind
// `MUT_SELF_*` `phf::Set` below. The compiler reads these to decide whether
// to emit a write-back to the receiver's binding slot after `CallMethod`
// (see `compile_expr_method_call`'s mutation-writeback path). The runtime
// dispatch shell does NOT consult these — write-back is purely a compile-
// time concern (the dispatch shell already pops the receiver, so the
// source-binding identity is lost at the runtime layer).
//
// **Interior-mutability primitives (`Mutex` / `Atomic` / `Lazy` / `Channel`)
// are NOT in these sets.** Their mutating methods (`Mutex.set`,
// `Atomic.store`, `Lazy.get`, `Channel.send` / `close`, etc.) preserve the
// receiver's Arc identity — the mutation happens through `RefCell` /
// `AtomicI64` / `OnceCell` / channel-buffer inside the carrier. No
// write-back is required and `let m = Mutex(0); m.set(5)` stays valid (the
// binding itself is immutable; what changes is the shared interior).

/// HashSet methods that opt into `&mut self` semantics.
pub static MUT_SELF_HASHSET_METHODS: phf::Set<&'static str> = phf_set! {
    "add",
    "delete",
};

/// HashMap methods that opt into `&mut self` semantics.
pub static MUT_SELF_HASHMAP_METHODS: phf::Set<&'static str> = phf_set! {
    "set",
    "delete",
    "merge",
};

/// Array methods that opt into `&mut self` semantics.
///
/// `push` already writes back via the bespoke `ArrayPushLocal` /
/// typed-array push opcodes for identifier receivers (see
/// `compile_expr_method_call`); listed here so the generic fallback
/// path also writes back when the bespoke path isn't taken.
///
/// **NOT listed:** `pop`. Pop's return value is the popped element
/// (`Option<T>`), not the mutated array — generic-writeback semantics
/// would corrupt the binding by writing the element bits into the
/// array slot. The pre-ruling `pop` behaviour (mutation visible only
/// when the user does `arr = arr.pop()` and discards the popped
/// element) is preserved; a future amendment can add a tuple-return
/// ABI for pop-shaped methods.
pub static MUT_SELF_ARRAY_METHODS: phf::Set<&'static str> = phf_set! {
    "push",
};

/// Deque methods that opt into `&mut self` semantics.
///
/// Same return-value rule as `MUT_SELF_ARRAY_METHODS`: only listed when
/// the handler returns the (mutated) receiver Arc. `popBack` /
/// `popFront` return the popped element, so they stay off the writeback
/// set (deferred to a future tuple-return ABI).
pub static MUT_SELF_DEQUE_METHODS: phf::Set<&'static str> = phf_set! {
    "pushBack",
    "pushFront",
};

/// PriorityQueue methods that opt into `&mut self` semantics.
///
/// `pop` returns the popped element, not the mutated queue — see
/// `MUT_SELF_ARRAY_METHODS` for the return-value rule.
pub static MUT_SELF_PRIORITY_QUEUE_METHODS: phf::Set<&'static str> = phf_set! {
    "push",
};

/// TypedArray<i64> / TypedArray<f64> methods that opt into `&mut self`.
///
/// Post-W16.2-J.1 (2026-05-22), `push` / `set` for numeric v2-raw
/// TypedArrays dispatch through `ARRAY_METHODS` (kind-generic
/// `array_basic::handle_push_v2` / `handle_set_v2`); the per-kind
/// `TYPED_INT_ARRAY_METHODS` / `TYPED_NUMBER_ARRAY_METHODS` PHF maps were
/// deleted. The shared mut-self set remains for the compiler's
/// write-back gate, which is liberal across container kinds. `pop` is
/// excluded per the same return-value rule as `MUT_SELF_ARRAY_METHODS`.
pub static MUT_SELF_TYPED_ARRAY_METHODS: phf::Set<&'static str> = phf_set! {
    "push",
    "set",
};

/// Returns `true` if `method` is a name registered as `&mut self` for ANY
/// container/collection receiver class.
///
/// This is the compiler-side liberal classifier: when the receiver type
/// is unknown at compile time, the compiler may still emit a write-back
/// for any name that's known to mutate on some container kind. The
/// write-back is harmless when the actual receiver kind turns out to be
/// pure (the handler returns the same Arc identity, the StoreLocal
/// re-stores the same bits — net effect: no-op modulo refcount churn).
///
/// Used by `compile_expr_method_call`'s writeback emission gate.
pub fn is_mut_self_method_name(method: &str) -> bool {
    MUT_SELF_HASHSET_METHODS.contains(method)
        || MUT_SELF_HASHMAP_METHODS.contains(method)
        || MUT_SELF_ARRAY_METHODS.contains(method)
        || MUT_SELF_DEQUE_METHODS.contains(method)
        || MUT_SELF_PRIORITY_QUEUE_METHODS.contains(method)
        || MUT_SELF_TYPED_ARRAY_METHODS.contains(method)
}

// ═══════════════════════════════════════════════════════════════════════════
// Tuple-return `&mut self` opt-in registries (ADR-006 §2.7.27 amendment,
// W17-pop-mutation, 2026-05-12)
// ═══════════════════════════════════════════════════════════════════════════
//
// Pop-shaped methods extract an element from a collection AND mutate the
// collection's structure. The conceptual dispatch signature is
// `(&mut self) -> (Option<T>, Self)` — the user-facing return is the popped
// element (`Option<T>`); the new container Arc is published as a side
// effect on the VM stack and the compiler emits a post-CallMethod
// `Swap; Store*(receiver)` to write it back to the binding slot (r-value
// receivers get `Swap; Pop` for silent drop, mirroring §2.7.27's r-value
// silent-drop rule for self-returning mutators).
//
// The runtime `MethodFnV2` ABI is unchanged — the handler still returns
// `Result<KindedSlot, VMError>`. The convention is: a tuple-return handler
// `vm.push_kinded(new_self_bits, new_self_kind)` before returning the
// popped element. The dispatch shell pushes the returned popped element on
// top, so the post-call stack is `[..., NewSelf, popped_element]`. The
// compiler emits the post-CallMethod opcode pair that consumes `NewSelf`
// per the receiver-rooting rule.
//
// Hard rule (binding, per W17-pop-mutation dispatch text §"Forbidden
// patterns"): tuple-return is used ONLY for methods that satisfy BOTH
// (a) canonical-extraction-from-collection AND (b) structural-mutation-
// of-collection. Forbidden examples: `find` (no structural mutation),
// `entry_or_default` (returns reference-into-collection — wrong shape),
// `peek_first` (no mutation), `iter().next()` (iteration cursor mutation,
// not container mutation).

/// Array methods that opt into the tuple-return `&mut self` ABI variant.
///
/// `pop` extracts the last element and mutates the array — the handler
/// returns `Option<T>` (the popped element) and side-channel-publishes
/// the new `Arc<TypedArrayData>` to the VM stack before returning. The
/// compiler emits `Swap; Store*(receiver)` after `CallMethod` to write
/// back; r-value receivers get `Swap; Pop` (silent drop, mirror of
/// §2.7.27 self-return r-value rule).
pub static MUT_SELF_TUPLE_RETURN_ARRAY_METHODS: phf::Set<&'static str> = phf_set! {
    "pop",
};

/// Deque methods that opt into the tuple-return `&mut self` ABI variant.
///
/// `popBack` / `popFront` extract an end element and mutate the deque.
/// Same shape as `MUT_SELF_TUPLE_RETURN_ARRAY_METHODS`.
pub static MUT_SELF_TUPLE_RETURN_DEQUE_METHODS: phf::Set<&'static str> = phf_set! {
    "popBack",
    "popFront",
};

/// PriorityQueue methods that opt into the tuple-return `&mut self` ABI
/// variant.
///
/// `pop` extracts the minimum priority and mutates the heap. Same shape
/// as `MUT_SELF_TUPLE_RETURN_ARRAY_METHODS`.
pub static MUT_SELF_TUPLE_RETURN_PRIORITY_QUEUE_METHODS: phf::Set<&'static str> = phf_set! {
    "pop",
};

/// HashMap methods that opt into the tuple-return `&mut self` ABI variant.
///
/// `remove(k)` returns the popped value (`Option<V>`) and mutates the map.
/// The pre-existing `delete(k)` method keeps the self-returning shape used
/// by `stdlib-src/core/set.shape::remove` (which wraps `s.delete(item)`
/// and returns the new set) — adding `remove` as a parallel method
/// preserves the self-return contract while exposing the canonical
/// pop-shape ABI for callers that want `Option<V>`.
pub static MUT_SELF_TUPLE_RETURN_HASHMAP_METHODS: phf::Set<&'static str> = phf_set! {
    "remove",
};

/// Returns `true` if `method` is a name registered as tuple-return
/// `&mut self` for ANY container/collection receiver class.
///
/// Mirror of `is_mut_self_method_name` for the tuple-return ABI variant.
/// Used by `compile_expr_method_call`'s post-CallMethod writeback gate
/// to choose between (a) self-return `Dup; Store*` shape (existing
/// W17-mutation-writeback), (b) tuple-return `Swap; Store*` / `Swap; Pop`
/// shape (this amendment).
pub fn is_mut_self_tuple_return_method_name(method: &str) -> bool {
    MUT_SELF_TUPLE_RETURN_ARRAY_METHODS.contains(method)
        || MUT_SELF_TUPLE_RETURN_DEQUE_METHODS.contains(method)
        || MUT_SELF_TUPLE_RETURN_PRIORITY_QUEUE_METHODS.contains(method)
        || MUT_SELF_TUPLE_RETURN_HASHMAP_METHODS.contains(method)
}

/// PHF registry for Array methods (47 methods total)
///
/// **Categories:**
/// - Higher-order functions: map, filter, reduce, forEach, find, findIndex, some, every, sort, groupBy, flatMap
/// - Basic operations: len, length, first, last, reverse, slice, concat, take, drop, skip
/// - Search methods: indexOf, includes
/// - Transform methods: join, flatten, unique, distinct, distinctBy
/// - Aggregation methods: sum, avg, min, max, count
/// - SQL-like query: where, select, orderBy, thenBy, takeWhile, skipWhile, single, any, all
/// - Join operations: innerJoin, leftJoin, crossJoin
/// - Set operations: union, intersect, except
pub static ARRAY_METHODS: phf::Map<&'static str, MethodHandler> = phf_map! {
    // Higher-order — Native (closure-based, handler manages VM callbacks)
    "map" => crate::executor::objects::array_transform::handle_map_v2,
    "filter" => crate::executor::objects::array_transform::handle_filter_v2,
    "reduce" => crate::executor::objects::array_aggregation::handle_reduce_v2,
    "fold" => crate::executor::objects::array_aggregation::handle_reduce_v2,
    "forEach" => crate::executor::objects::array_query::handle_for_each_v2,
    "find" => crate::executor::objects::array_query::handle_find_v2,
    "findIndex" => crate::executor::objects::array_query::handle_find_index_v2,
    "some" => crate::executor::objects::array_query::handle_some_v2,
    "every" => crate::executor::objects::array_query::handle_every_v2,
    "sort" => crate::executor::objects::array_transform::handle_sort_v2,
    "groupBy" => crate::executor::objects::array_transform::handle_group_by_v2,
    "flatMap" => crate::executor::objects::array_transform::handle_flat_map_v2,

    // Basic operations — Native
    // WS-8 (2026-05-22): `len` / `length` / `isEmpty` / `first` / `last` are
    // KIND-GENERIC header handlers (one handler per method dispatches on the
    // `TypedArray<T>` element-type byte). Works uniformly for every element
    // kind — bool / string / int / number / decimal / TypedObject / sized
    // ints / Char — without per-kind PHF entries.
    "len" => crate::executor::objects::array_basic::handle_len_v2,
    "length" => crate::executor::objects::array_basic::handle_len_v2,
    "isEmpty" => crate::executor::objects::array_basic::handle_is_empty_v2,
    "first" => crate::executor::objects::array_basic::handle_first_v2,
    "last" => crate::executor::objects::array_basic::handle_last_v2,
    "reverse" => crate::executor::objects::array_basic::handle_reverse_v2,
    "push" => crate::executor::objects::array_basic::handle_push_v2,
    "pop" => crate::executor::objects::array_basic::handle_pop_v2,
    "zip" => crate::executor::objects::array_basic::handle_zip_v2,
    // W16.2-J.0 (2026-05-22): `get` / `set` are kind-generic handlers
    // delegating to `v2_array_detect::read_element` / `write_element`.
    // Pre-W16.2-J.0 their only host was the per-kind PHF registries
    // (TYPED_INT_ARRAY_METHODS / TYPED_NUMBER_ARRAY_METHODS); W16.2-J.1
    // (2026-05-22) deleted those PHFs and routed numeric `V2ElemType`
    // arms straight to ARRAY_METHODS — these entries are now the
    // canonical (and only) host for `get` / `set`.
    "get" => crate::executor::objects::array_basic::handle_get_v2,
    "set" => crate::executor::objects::array_basic::handle_set_v2,
    "slice" => crate::executor::objects::array_transform::handle_slice_v2,
    "concat" => crate::executor::objects::array_transform::handle_concat_v2,
    "take" => crate::executor::objects::array_transform::handle_take_v2,
    "drop" => crate::executor::objects::array_transform::handle_drop_v2,
    "skip" => crate::executor::objects::array_transform::handle_skip_v2,

    // Search — Native
    "indexOf" => crate::executor::objects::array_query::handle_index_of_v2,
    "includes" => crate::executor::objects::array_query::handle_includes_v2,

    // Transform — Native
    "join" => crate::executor::objects::array_sort::handle_join_str_v2,
    "flatten" => crate::executor::objects::array_transform::handle_flatten_v2,
    "unique" => crate::executor::objects::array_sets::handle_unique_v2,
    "distinct" => crate::executor::objects::array_sets::handle_distinct_v2,
    "distinctBy" => crate::executor::objects::array_sets::handle_distinct_by_v2,

    // Aggregation — Native
    "sum" => crate::executor::objects::array_aggregation::handle_sum_v2,
    "avg" => crate::executor::objects::array_aggregation::handle_avg_v2,
    "min" => crate::executor::objects::array_aggregation::handle_min_v2,
    "max" => crate::executor::objects::array_aggregation::handle_max_v2,
    "count" => crate::executor::objects::array_aggregation::handle_count_v2,

    // SQL-like query — Native
    "where" => crate::executor::objects::array_query::handle_where_v2,
    "select" => crate::executor::objects::array_query::handle_select_v2,
    "orderBy" => crate::executor::objects::array_sort::handle_order_by_v2,
    "thenBy" => crate::executor::objects::array_sort::handle_then_by_v2,
    "takeWhile" => crate::executor::objects::array_query::handle_take_while_v2,
    "skipWhile" => crate::executor::objects::array_query::handle_skip_while_v2,
    "single" => crate::executor::objects::array_query::handle_single_v2,
    "any" => crate::executor::objects::array_query::handle_any_v2,
    "all" => crate::executor::objects::array_query::handle_all_v2,

    // Join operations — Native
    "innerJoin" => crate::executor::objects::array_joins::handle_inner_join_v2,
    "leftJoin" => crate::executor::objects::array_joins::handle_left_join_v2,
    "crossJoin" => crate::executor::objects::array_joins::handle_cross_join_v2,

    // Set operations — Native
    "union" => crate::executor::objects::array_sets::handle_union_v2,
    "intersect" => crate::executor::objects::array_sets::handle_intersect_v2,
    "except" => crate::executor::objects::array_sets::handle_except_v2,

    // Clone — Native
    "clone" => crate::executor::objects::array_basic::handle_clone_v2,

    // Iterator — still Legacy (waiting for iterator agent)
    "iter" => crate::executor::objects::iterator_methods::handle_array_iter,
};

/// PHF registry for DataTable methods (24 methods)
///
/// **Core operations:**
/// - len, columns, column, slice, head, tail, first, last, select
///
/// **Compute operations:**
/// - sum, mean, min, max, sort
///
/// **Query operations (Phase 4):**
/// - filter, orderBy, group_by, groupBy, aggregate, count, describe, forEach
pub static DATATABLE_METHODS: phf::Map<&'static str, MethodHandler> = phf_map! {
    // Core
    "origin" => crate::executor::objects::datatable_methods::handle_origin,
    "len" => crate::executor::objects::datatable_methods::handle_len,
    "length" => crate::executor::objects::datatable_methods::handle_len,
    "columns" => crate::executor::objects::datatable_methods::handle_columns,
    "column" => crate::executor::objects::datatable_methods::handle_column,
    "slice" => crate::executor::objects::datatable_methods::handle_slice,
    "head" => crate::executor::objects::datatable_methods::handle_head,
    "tail" => crate::executor::objects::datatable_methods::handle_tail,
    "first" => crate::executor::objects::datatable_methods::handle_first,
    "last" => crate::executor::objects::datatable_methods::handle_last,
    "select" => crate::executor::objects::datatable_methods::handle_select,
    "toMat" => crate::executor::objects::datatable_methods::handle_to_mat,
    "to_mat" => crate::executor::objects::datatable_methods::handle_to_mat,

    // Row/column iteration
    "rows" => crate::executor::objects::datatable_methods::handle_rows,
    "columnsRef" => crate::executor::objects::datatable_methods::handle_columns_ref,

    // Compute
    "sum" => crate::executor::objects::datatable_methods::handle_sum,
    "mean" => crate::executor::objects::datatable_methods::handle_mean,
    "min" => crate::executor::objects::datatable_methods::handle_min,
    "max" => crate::executor::objects::datatable_methods::handle_max,
    "sort" => crate::executor::objects::datatable_methods::handle_sort,

    // Query (Phase 4)
    "filter" => crate::executor::objects::datatable_methods::handle_filter,
    "orderBy" => crate::executor::objects::datatable_methods::handle_order_by,
    "group_by" => crate::executor::objects::datatable_methods::handle_group_by,
    "groupBy" => crate::executor::objects::datatable_methods::handle_group_by,
    "aggregate" => crate::executor::objects::datatable_methods::handle_aggregate,
    "count" => crate::executor::objects::datatable_methods::handle_count,
    "describe" => crate::executor::objects::datatable_methods::handle_describe,
    "forEach" => crate::executor::objects::datatable_methods::handle_for_each,
    "map" => crate::executor::objects::datatable_methods::handle_map,
    "index_by" => crate::executor::objects::datatable_methods::handle_index_by,
    "indexBy" => crate::executor::objects::datatable_methods::handle_index_by,

    // Queryable interface (consistent with DbTable)
    "limit" => crate::executor::objects::datatable_methods::handle_limit,
    "execute" => crate::executor::objects::datatable_methods::handle_execute,

    // Joins
    "innerJoin" => crate::executor::objects::datatable_methods::handle_inner_join,
    "leftJoin" => crate::executor::objects::datatable_methods::handle_left_join,

    // Simulation
    "simulate" => crate::executor::objects::datatable_methods::handle_simulate,

    // SIMD-backed methods
    "correlation" => crate::executor::objects::datatable_methods::handle_correlation,
    "covariance" => crate::executor::objects::datatable_methods::handle_covariance,
    "rolling_sum" => crate::executor::objects::datatable_methods::handle_rolling_sum,
    "rollingSum" => crate::executor::objects::datatable_methods::handle_rolling_sum,
    "rolling_mean" => crate::executor::objects::datatable_methods::handle_rolling_mean,
    "rollingMean" => crate::executor::objects::datatable_methods::handle_rolling_mean,
    "rolling_std" => crate::executor::objects::datatable_methods::handle_rolling_std,
    "rollingStd" => crate::executor::objects::datatable_methods::handle_rolling_std,
    "diff" => crate::executor::objects::datatable_methods::handle_diff,
    "pct_change" => crate::executor::objects::datatable_methods::handle_pct_change,
    "pctChange" => crate::executor::objects::datatable_methods::handle_pct_change,
    "forward_fill" => crate::executor::objects::datatable_methods::handle_forward_fill,
    "forwardFill" => crate::executor::objects::datatable_methods::handle_forward_fill,
};

// (W15-column, 2026-05-10) `COLUMN_METHODS` PHF deleted per ADR-006
// §2.7.21 / Q22. There is no surviving `HeapKind::Column`: the kinded
// equivalent of the deleted `HeapValue::ColumnRef` payload is a
// `HeapKind::TableView` slot carrying a `TableViewData::ColumnRef
// { schema_id, table, col_id }` projection (see
// `crates/shape-value/src/heap_value.rs`). The PHF previously routed
// to 11 `NotImplemented(SURFACE)` stubs and was unreachable in
// practice — no dispatch shell classified a receiver kind into
// `COLUMN_METHODS`. Column-shaped APIs (aggregation across a single
// table column) belong on `TableView::ColumnRef` and live in
// `crates/shape-vm/src/executor/objects/datatable_methods/`.

/// PHF registry for HashMap methods (18 methods)
///
/// **Core:** get, set, has, delete, keys, values, entries, len, length, isEmpty
/// **Higher-order:** map, filter, forEach, reduce, groupBy
/// **Convenience:** merge, getOrDefault, toArray
pub static HASHMAP_METHODS: phf::Map<&'static str, MethodHandler> = phf_map! {
    // Non-closure methods — MethodFnV2
    "get" => crate::executor::objects::hashmap_methods::v2_get,
    "set" => crate::executor::objects::hashmap_methods::v2_set,
    "has" => crate::executor::objects::hashmap_methods::v2_has,
    // Criterion F (2026-05-22): `.includes(key)` is the user-binding for
    // direct key membership; aliases `has` to standardize the
    // membership-naming surface with Array/Set. `.contains` is
    // intentionally NOT present on HashMap.
    "includes" => crate::executor::objects::hashmap_methods::v2_has,
    "delete" => crate::executor::objects::hashmap_methods::v2_delete,
    // ADR-006 §2.7.27 amendment (W17-pop-mutation, 2026-05-12):
    // `remove(k)` is the canonical pop-shape sibling of `delete(k)` —
    // returns `Option<V>` (the removed value) instead of the (new) map.
    "remove" => crate::executor::objects::hashmap_methods::v2_remove,
    "keys" => crate::executor::objects::hashmap_methods::v2_keys,
    "values" => crate::executor::objects::hashmap_methods::v2_values,
    "entries" => crate::executor::objects::hashmap_methods::v2_entries,
    "len" => crate::executor::objects::hashmap_methods::v2_len,
    "length" => crate::executor::objects::hashmap_methods::v2_len,
    "isEmpty" => crate::executor::objects::hashmap_methods::v2_is_empty,
    "merge" => crate::executor::objects::hashmap_methods::v2_merge,
    "getOrDefault" => crate::executor::objects::hashmap_methods::v2_get_or_default,
    "toArray" => crate::executor::objects::hashmap_methods::v2_to_array,
    // Closure-based — v2 native
    "map" => crate::executor::objects::hashmap_methods::v2_map,
    "filter" => crate::executor::objects::hashmap_methods::v2_filter,
    "forEach" => crate::executor::objects::hashmap_methods::v2_for_each,
    "reduce" => crate::executor::objects::hashmap_methods::v2_reduce,
    "groupBy" => crate::executor::objects::hashmap_methods::v2_group_by,

    // Iterator
    "iter" => crate::executor::objects::hashmap_methods::v2_iter,
};

/// PHF registry for Set methods (criterion F: `size` removed, `includes`
/// added 2026-05-22).
///
/// **Core:** add, has, includes, delete, len, length, isEmpty, toArray
/// **Higher-order:** forEach, map, filter
/// **Set operations:** union, intersection, difference
///
/// Membership-naming standardization (criterion F): `.includes(item)` is
/// the user-binding for direct membership across Array/Set/HashMap;
/// `.has(key)` is preserved on Set/HashMap for the key-lookup-shape API.
/// `.contains()` is intentionally NOT present on Set — it is reserved
/// for semantic-substring/range-inclusion shapes (String, Range).
pub static SET_METHODS: phf::Map<&'static str, MethodHandler> = phf_map! {
    "add" => crate::executor::objects::set_methods::v2_add,
    "delete" => crate::executor::objects::set_methods::v2_delete,
    // Read-only — MethodFnV2
    "has" => crate::executor::objects::set_methods::v2_has,
    "includes" => crate::executor::objects::set_methods::v2_has,
    "len" => crate::executor::objects::set_methods::v2_size,
    "length" => crate::executor::objects::set_methods::v2_size,
    "isEmpty" => crate::executor::objects::set_methods::v2_is_empty,
    "toArray" => crate::executor::objects::set_methods::v2_to_array,
    "union" => crate::executor::objects::set_methods::v2_union,
    "intersection" => crate::executor::objects::set_methods::v2_intersection,
    "difference" => crate::executor::objects::set_methods::v2_difference,
    // Closure-based — v2 native
    "forEach" => crate::executor::objects::set_methods::v2_for_each,
    "map" => crate::executor::objects::set_methods::v2_map,
    "filter" => crate::executor::objects::set_methods::v2_filter,
};

/// PHF registry for Deque methods
///
/// **Mutation:** pushBack, pushFront, popBack, popFront
/// **Access:** peekBack, peekFront, get
/// **Info:** size, len, length, isEmpty
/// **Conversion:** toArray
pub static DEQUE_METHODS: phf::Map<&'static str, MethodHandler> = phf_map! {
    "pushBack" => crate::executor::objects::deque_methods::v2_push_back,
    "pushFront" => crate::executor::objects::deque_methods::v2_push_front,
    "popBack" => crate::executor::objects::deque_methods::v2_pop_back,
    "popFront" => crate::executor::objects::deque_methods::v2_pop_front,
    // Read-only — MethodFnV2
    "peekBack" => crate::executor::objects::deque_methods::v2_peek_back,
    "peekFront" => crate::executor::objects::deque_methods::v2_peek_front,
    "size" => crate::executor::objects::deque_methods::v2_size,
    "len" => crate::executor::objects::deque_methods::v2_size,
    "length" => crate::executor::objects::deque_methods::v2_size,
    "isEmpty" => crate::executor::objects::deque_methods::v2_is_empty,
    "toArray" => crate::executor::objects::deque_methods::v2_to_array,
    "get" => crate::executor::objects::deque_methods::v2_get,
};

/// PHF registry for PriorityQueue methods
///
/// **Mutation:** push, pop
/// **Access:** peek
/// **Info:** size, len, length, isEmpty
/// **Conversion:** toArray, toSortedArray
pub static PRIORITY_QUEUE_METHODS: phf::Map<&'static str, MethodHandler> = phf_map! {
    "push" => crate::executor::objects::priority_queue_methods::v2_push,
    "pop" => crate::executor::objects::priority_queue_methods::v2_pop,
    // Read-only — MethodFnV2
    "peek" => crate::executor::objects::priority_queue_methods::v2_peek,
    "size" => crate::executor::objects::priority_queue_methods::v2_size,
    "len" => crate::executor::objects::priority_queue_methods::v2_size,
    "length" => crate::executor::objects::priority_queue_methods::v2_size,
    "isEmpty" => crate::executor::objects::priority_queue_methods::v2_is_empty,
    "toArray" => crate::executor::objects::priority_queue_methods::v2_to_array,
    "toSortedArray" => crate::executor::objects::priority_queue_methods::v2_to_sorted_array,
};

/// PHF registry for DateTime methods (30 methods)
///
/// **Categories:**
/// - Component access: year, month, day, hour, minute, second, millisecond, microsecond
/// - Day info: day_of_week, day_of_year, week_of_year, is_weekday, is_weekend
/// - Formatting: format, iso8601, rfc2822, unix_timestamp
/// - Timezone: to_utc, to_timezone, to_local, timezone, offset
/// - Arithmetic: add_days, add_hours, add_minutes, add_seconds, add_months
/// - Comparison: is_before, is_after, is_same_day
pub static DATETIME_METHODS: phf::Map<&'static str, MethodHandler> = phf_map! {
    // Component access — Native
    "year" => crate::executor::objects::datetime_methods::v2_year,
    "month" => crate::executor::objects::datetime_methods::v2_month,
    "day" => crate::executor::objects::datetime_methods::v2_day,
    "hour" => crate::executor::objects::datetime_methods::v2_hour,
    "minute" => crate::executor::objects::datetime_methods::v2_minute,
    "second" => crate::executor::objects::datetime_methods::v2_second,
    "millisecond" => crate::executor::objects::datetime_methods::v2_millisecond,
    "microsecond" => crate::executor::objects::datetime_methods::v2_microsecond,

    // Day info — Native
    "day_of_week" => crate::executor::objects::datetime_methods::v2_day_of_week,
    "day_of_year" => crate::executor::objects::datetime_methods::v2_day_of_year,
    "week_of_year" => crate::executor::objects::datetime_methods::v2_week_of_year,
    "is_weekday" => crate::executor::objects::datetime_methods::v2_is_weekday,
    "is_weekend" => crate::executor::objects::datetime_methods::v2_is_weekend,

    // Formatting — Native
    "format" => crate::executor::objects::datetime_methods::v2_format,
    "iso8601" => crate::executor::objects::datetime_methods::v2_iso8601,
    "rfc2822" => crate::executor::objects::datetime_methods::v2_rfc2822,
    "unix_timestamp" => crate::executor::objects::datetime_methods::v2_unix_timestamp,
    "to_unix_millis" => crate::executor::objects::datetime_methods::v2_to_unix_millis,

    // Timezone — Native
    "to_utc" => crate::executor::objects::datetime_methods::v2_to_utc,
    "to_timezone" => crate::executor::objects::datetime_methods::v2_to_timezone,
    "to_local" => crate::executor::objects::datetime_methods::v2_to_local,
    "timezone" => crate::executor::objects::datetime_methods::v2_timezone,
    "offset" => crate::executor::objects::datetime_methods::v2_offset,

    // Operator-trait arithmetic — Native
    "add" => crate::executor::objects::datetime_methods::v2_add,
    "sub" => crate::executor::objects::datetime_methods::v2_sub,

    // Arithmetic — Native
    "add_days" => crate::executor::objects::datetime_methods::v2_add_days,
    "add_hours" => crate::executor::objects::datetime_methods::v2_add_hours,
    "add_minutes" => crate::executor::objects::datetime_methods::v2_add_minutes,
    "add_seconds" => crate::executor::objects::datetime_methods::v2_add_seconds,
    "add_months" => crate::executor::objects::datetime_methods::v2_add_months,

    // Comparison — Native
    "is_before" => crate::executor::objects::datetime_methods::v2_is_before,
    "is_after" => crate::executor::objects::datetime_methods::v2_is_after,
    "is_same_day" => crate::executor::objects::datetime_methods::v2_is_same_day,

    // Diff — Native
    "diff" => crate::executor::objects::datetime_methods::v2_diff,
};

/// PHF registry for TimeSpan (Duration) methods.
///
/// **Operator-trait:** add, sub
pub static TIMESPAN_METHODS: phf::Map<&'static str, MethodHandler> = phf_map! {
    "add" => crate::executor::objects::datetime_methods::v2_timespan_add,
    "sub" => crate::executor::objects::datetime_methods::v2_timespan_sub,
};

/// PHF registry for Instant methods (6 methods)
///
/// **Timing:** elapsed, elapsed_ms, elapsed_us, elapsed_ns, duration_since
/// **Formatting:** to_string
pub static INSTANT_METHODS: phf::Map<&'static str, MethodHandler> = phf_map! {
    "elapsed" => crate::executor::objects::instant_methods::v2_elapsed,
    "elapsed_ms" => crate::executor::objects::instant_methods::v2_elapsed_ms,
    "elapsed_us" => crate::executor::objects::instant_methods::v2_elapsed_us,
    "elapsed_ns" => crate::executor::objects::instant_methods::v2_elapsed_ns,
    "duration_since" => crate::executor::objects::instant_methods::v2_duration_since,
    "to_string" => crate::executor::objects::instant_methods::v2_to_string,
};

/// PHF registry for Iterator methods (15 methods)
///
/// **Lazy transforms:** map, filter, take, skip, flatMap, enumerate, chain
/// **Terminal operations:** collect, toArray, forEach, reduce, count, any, all, find
pub static ITERATOR_METHODS: phf::Map<&'static str, MethodHandler> = phf_map! {
    // Lazy transforms (return new Iterator)
    "map" => crate::executor::objects::iterator_methods::handle_map,
    "filter" => crate::executor::objects::iterator_methods::handle_filter,
    "take" => crate::executor::objects::iterator_methods::handle_take,
    "skip" => crate::executor::objects::iterator_methods::handle_skip,
    "flatMap" => crate::executor::objects::iterator_methods::handle_flat_map,
    "enumerate" => crate::executor::objects::iterator_methods::handle_enumerate,
    "chain" => crate::executor::objects::iterator_methods::handle_chain,

    // Terminal operations (consume the iterator)
    "collect" => crate::executor::objects::iterator_methods::handle_collect,
    "toArray" => crate::executor::objects::iterator_methods::handle_collect,
    "forEach" => crate::executor::objects::iterator_methods::handle_for_each,
    "reduce" => crate::executor::objects::iterator_methods::handle_reduce,
    "count" => crate::executor::objects::iterator_methods::handle_count,
    "any" => crate::executor::objects::iterator_methods::handle_any,
    "all" => crate::executor::objects::iterator_methods::handle_all,
    "find" => crate::executor::objects::iterator_methods::handle_find,
};

/// PHF registry for Matrix methods (18 methods)
///
/// **Linear algebra:** transpose, inverse, det, determinant, trace
/// **Shape/access:** shape, reshape, row, col, diag, flatten
/// **Higher-order:** map
/// **Aggregation:** sum, min, max, mean, rowSum, colSum
pub static MATRIX_METHODS: phf::Map<&'static str, MethodHandler> = phf_map! {
    // Linear algebra — MethodFnV2
    "transpose" => crate::executor::objects::matrix_methods::v2_transpose,
    "inverse" => crate::executor::objects::matrix_methods::v2_inverse,
    "det" => crate::executor::objects::matrix_methods::v2_determinant,
    "determinant" => crate::executor::objects::matrix_methods::v2_determinant,
    "trace" => crate::executor::objects::matrix_methods::v2_trace,

    // Shape and access — MethodFnV2
    "shape" => crate::executor::objects::matrix_methods::v2_shape,
    "reshape" => crate::executor::objects::matrix_methods::v2_reshape,
    "row" => crate::executor::objects::matrix_methods::v2_row,
    "col" => crate::executor::objects::matrix_methods::v2_col,
    "diag" => crate::executor::objects::matrix_methods::v2_diag,
    "flatten" => crate::executor::objects::matrix_methods::v2_flatten,

    // Higher-order — stays Legacy (closure-based)
    "map" => crate::executor::objects::matrix_methods::handle_map,

    // Aggregation — MethodFnV2
    "sum" => crate::executor::objects::matrix_methods::v2_sum,
    "min" => crate::executor::objects::matrix_methods::v2_min,
    "max" => crate::executor::objects::matrix_methods::v2_max,
    "mean" => crate::executor::objects::matrix_methods::v2_mean,
    "rowSum" => crate::executor::objects::matrix_methods::v2_row_sum,
    "colSum" => crate::executor::objects::matrix_methods::v2_col_sum,
};

/// PHF registry for IndexedTable-specific methods (2 methods)
///
/// These methods require an IndexedTable (table with designated index column).
/// Inherited DataTable methods are dispatched via DATATABLE_METHODS fallback.
///
/// **Query:** between, resample
pub static INDEXED_TABLE_METHODS: phf::Map<&'static str, MethodHandler> = phf_map! {
    "between" => crate::executor::objects::indexed_table_methods::handle_between,
    "resample" => crate::executor::objects::indexed_table_methods::handle_resample,
};

/// PHF registry for Vec<number> (FloatArray) methods
///
/// **Aggregations:** sum, avg, mean, min, max, std, variance
/// **Numeric:** dot, norm, normalize, cumsum, diff, abs, sqrt, ln, exp
/// **Standard:** len, length, map, filter, reduce, fold, forEach, find, some, every, toArray
pub static FLOAT_ARRAY_METHODS: phf::Map<&'static str, MethodHandler> = phf_map! {
    // Aggregations — MethodFnV2 (v2 typed array + v1 fallback)
    "sum" => crate::executor::objects::typed_array_methods::v2_float_sum,
    "avg" => crate::executor::objects::typed_array_methods::v2_float_avg,
    "mean" => crate::executor::objects::typed_array_methods::v2_float_avg,
    "min" => crate::executor::objects::typed_array_methods::v2_float_min,
    "max" => crate::executor::objects::typed_array_methods::v2_float_max,
    "std" => crate::executor::objects::typed_array_methods::v2_float_std,
    "variance" => crate::executor::objects::typed_array_methods::v2_float_variance,
    "dot" => crate::executor::objects::typed_array_methods::v2_float_dot,
    "norm" => crate::executor::objects::typed_array_methods::v2_float_norm,
    "len" => crate::executor::objects::typed_array_methods::v2_len,
    "length" => crate::executor::objects::typed_array_methods::v2_len,
    // Transforms — MethodFnV2 (native v2, no legacy delegation)
    "normalize" => crate::executor::objects::typed_array_methods::handle_float_normalize,
    "cumsum" => crate::executor::objects::typed_array_methods::handle_float_cumsum,
    "diff" => crate::executor::objects::typed_array_methods::handle_float_diff,
    "abs" => crate::executor::objects::typed_array_methods::handle_float_abs,
    "sqrt" => crate::executor::objects::typed_array_methods::handle_float_sqrt,
    "ln" => crate::executor::objects::typed_array_methods::handle_float_ln,
    "exp" => crate::executor::objects::typed_array_methods::handle_float_exp,
    "map" => crate::executor::objects::typed_array_methods::handle_float_map,
    "filter" => crate::executor::objects::typed_array_methods::handle_float_filter,
    "reduce" => crate::executor::objects::typed_array_methods::handle_float_reduce,
    "fold" => crate::executor::objects::typed_array_methods::handle_float_reduce,
    "forEach" => crate::executor::objects::typed_array_methods::handle_float_for_each,
    "find" => crate::executor::objects::typed_array_methods::handle_float_find,
    "some" => crate::executor::objects::typed_array_methods::handle_float_some,
    "every" => crate::executor::objects::typed_array_methods::handle_float_every,
    "toArray" => crate::executor::objects::typed_array_methods::handle_float_to_array,
};

/// PHF registry for Vec<int> (IntArray) methods
///
/// **Aggregations:** sum, avg, mean, min, max
/// **Numeric:** abs
/// **Standard:** len, length, map, filter, reduce, fold, forEach, find, some, every, toArray
pub static INT_ARRAY_METHODS: phf::Map<&'static str, MethodHandler> = phf_map! {
    // Aggregations — MethodFnV2 (v2 typed array + v1 fallback)
    "sum" => crate::executor::objects::typed_array_methods::v2_int_sum,
    "avg" => crate::executor::objects::typed_array_methods::v2_int_avg,
    "mean" => crate::executor::objects::typed_array_methods::v2_int_avg,
    "min" => crate::executor::objects::typed_array_methods::v2_int_min,
    "max" => crate::executor::objects::typed_array_methods::v2_int_max,
    "len" => crate::executor::objects::typed_array_methods::v2_len,
    "length" => crate::executor::objects::typed_array_methods::v2_len,
    // Transforms — MethodFnV2 (native v2, no legacy delegation)
    "abs" => crate::executor::objects::typed_array_methods::handle_int_abs,
    "map" => crate::executor::objects::typed_array_methods::handle_int_map,
    "filter" => crate::executor::objects::typed_array_methods::handle_int_filter,
    "reduce" => crate::executor::objects::typed_array_methods::handle_int_reduce,
    "fold" => crate::executor::objects::typed_array_methods::handle_int_reduce,
    "forEach" => crate::executor::objects::typed_array_methods::handle_int_for_each,
    "find" => crate::executor::objects::typed_array_methods::handle_int_find,
    "some" => crate::executor::objects::typed_array_methods::handle_int_some,
    "every" => crate::executor::objects::typed_array_methods::handle_int_every,
    "toArray" => crate::executor::objects::typed_array_methods::handle_int_to_array,
};

// W16.2-J.1 (2026-05-22): `TYPED_INT_ARRAY_METHODS` + `TYPED_NUMBER_ARRAY_METHODS`
// PHF registries DELETED — they were per-kind duplicates of the kind-generic
// `array_aggregation::handle_{sum,avg,min,max}_v2` / `array_basic::handle_{push,
// pop,first,last,get,set,len,is_empty,reverse,zip,clone}_v2` handlers that
// W16.2-J.0 (commit `fbe86020`) migrated to kind-generic bodies delegating to
// `v2_array_detect::{sum,avg,min,max,push,pop,read,write}_element(s)`
// primitives. The dispatcher in `objects/mod.rs::typed_array_method_registry`
// now routes every `V2ElemType::{I64,I32,I8,U8,I16,U16,U32,F64,F32}` arm
// straight to `ARRAY_METHODS`, which contains those same kind-generic entries.
//
// Handler module files `typed_int_array_methods.rs` + `typed_number_array_methods.rs`
// (667 LoC combined) deleted alongside the maps. CLAUDE.md Forbidden Patterns
// Refusal #10 binding: no half-retire ("preserve PHF for one kind"), no
// rename. Per-kind PHF retirement is a complete deletion.

/// PHF registry for Vec<bool> (BoolArray) methods
///
/// **Standard:** len, length, isEmpty, first, last, toArray
/// **Query:** any, all, count
///
/// WS-8 (2026-05-22): `len` / `length` / `isEmpty` / `first` / `last` route
/// to the kind-generic `array_basic::handle_*_v2` header handlers — these
/// dispatch on the `TypedArray<T>` element-type byte and work for every
/// element kind including bool. The pre-WS-8 `typed_array_methods::v2_len`
/// surface-and-stop stub (ckpt-3) is retired for these methods. `count` /
/// `any` / `all` / `toArray` remain on the closure-callback / aggregation
/// path tracked by the W17 typed-carrier-monomorphization workstream.
pub static BOOL_ARRAY_METHODS: phf::Map<&'static str, MethodHandler> = phf_map! {
    // Kind-generic header handlers (WS-8)
    "len" => crate::executor::objects::array_basic::handle_len_v2,
    "length" => crate::executor::objects::array_basic::handle_len_v2,
    "isEmpty" => crate::executor::objects::array_basic::handle_is_empty_v2,
    "first" => crate::executor::objects::array_basic::handle_first_v2,
    "last" => crate::executor::objects::array_basic::handle_last_v2,
    // Closure-callback / aggregation residuals (W17 territory)
    "count" => crate::executor::objects::typed_array_methods::v2_bool_count,
    "any" => crate::executor::objects::typed_array_methods::v2_bool_any,
    "all" => crate::executor::objects::typed_array_methods::v2_bool_all,
    // MethodFnV2 (native v2, no legacy delegation)
    "toArray" => crate::executor::objects::typed_array_methods::handle_bool_to_array,
};

// ═══════════════════════════════════════════════════════════════════════════
// Concurrency primitives — compiler-builtin interior mutability types
// ═══════════════════════════════════════════════════════════════════════════

/// Mutex<T> methods: lock, try_lock, set, get
///
/// `get` is the read-accessor for the wrapped value (the surface-level
/// `m.value` property-access form requires GetProp dispatch on heap
/// receivers — out of scope for W17-concurrency; the method form is the
/// equivalent accessor user code calls). ADR-006 §2.7.25.
pub static MUTEX_METHODS: phf::Map<&'static str, MethodHandler> = phf_map! {
    "lock" => crate::executor::objects::concurrency_methods::v2_mutex_lock,
    "try_lock" => crate::executor::objects::concurrency_methods::v2_mutex_try_lock,
    "set" => crate::executor::objects::concurrency_methods::v2_mutex_set,
    "get" => crate::executor::objects::concurrency_methods::v2_mutex_get,
};

/// Atomic<T> methods: load, store, fetch_add, fetch_sub, compare_exchange
pub static ATOMIC_METHODS: phf::Map<&'static str, MethodHandler> = phf_map! {
    "load" => crate::executor::objects::concurrency_methods::v2_atomic_load,
    "store" => crate::executor::objects::concurrency_methods::v2_atomic_store,
    "fetch_add" => crate::executor::objects::concurrency_methods::v2_atomic_fetch_add,
    "fetch_sub" => crate::executor::objects::concurrency_methods::v2_atomic_fetch_sub,
    "compare_exchange" => crate::executor::objects::concurrency_methods::v2_atomic_compare_exchange,
};

/// Lazy<T> methods: get, is_initialized
pub static LAZY_METHODS: phf::Map<&'static str, MethodHandler> = phf_map! {
    "get" => crate::executor::objects::concurrency_methods::v2_lazy_get,
    "is_initialized" => crate::executor::objects::concurrency_methods::v2_lazy_is_initialized,
};

/// Channel methods: send, recv, try_recv, close, is_closed, is_sender
pub static CHANNEL_METHODS: phf::Map<&'static str, MethodHandler> = phf_map! {
    "send" => crate::executor::objects::channel_methods::v2_channel_send,
    "recv" => crate::executor::objects::channel_methods::v2_channel_recv,
    "try_recv" => crate::executor::objects::channel_methods::v2_channel_try_recv,
    "close" => crate::executor::objects::channel_methods::v2_channel_close,
    "is_closed" => crate::executor::objects::channel_methods::v2_channel_is_closed,
    "is_sender" => crate::executor::objects::channel_methods::v2_channel_is_sender,
};

/// PHF registry for Number/Int methods (simple numeric operations).
///
/// **Rounding:** floor, ceil, round
/// **Arithmetic:** abs, sign
/// **Conversion:** toInt, to_int, toNumber, to_number
/// **Predicates:** isNaN, is_nan, isFinite, is_finite
///
/// Pre-§2.7.9 note: methods that historically lived outside this map
/// because they needed multi-arg or string-return shapes are now
/// uniform under the kinded `&[KindedSlot]` carrier ABI. `toFixed`,
/// `to_fixed`, `toString`, `to_string`, `clamp` are entered alongside
/// the rest.
pub static NUMBER_METHODS: phf::Map<&'static str, MethodHandler> = phf_map! {
    "floor" => crate::executor::objects::number_methods::number_floor_v2,
    "ceil" => crate::executor::objects::number_methods::number_ceil_v2,
    "round" => crate::executor::objects::number_methods::number_round_v2,
    "abs" => crate::executor::objects::number_methods::number_abs_v2,
    "sign" => crate::executor::objects::number_methods::number_sign_v2,
    "toInt" => crate::executor::objects::number_methods::number_to_int_v2,
    "to_int" => crate::executor::objects::number_methods::number_to_int_v2,
    "toNumber" => crate::executor::objects::number_methods::number_to_number_v2,
    "to_number" => crate::executor::objects::number_methods::number_to_number_v2,
    "isNaN" => crate::executor::objects::number_methods::number_is_nan_v2,
    "is_nan" => crate::executor::objects::number_methods::number_is_nan_v2,
    "isFinite" => crate::executor::objects::number_methods::number_is_finite_v2,
    "is_finite" => crate::executor::objects::number_methods::number_is_finite_v2,
    "toFixed" => crate::executor::objects::number_methods::number_to_fixed_v2,
    "to_fixed" => crate::executor::objects::number_methods::number_to_fixed_v2,
    "toString" => crate::executor::objects::number_methods::number_to_string_v2,
    "to_string" => crate::executor::objects::number_methods::number_to_string_v2,
    "clamp" => crate::executor::objects::number_methods::number_clamp_v2,
};

/// PHF registry for String methods (v2 native handlers)
///
/// **Categories:**
/// - Info: len, length
/// - Case: toUpperCase, to_upper_case, toLowerCase, to_lower_case
/// - Whitespace: trim, trimStart, trim_start, trimEnd, trim_end
/// - Search: contains, indexOf, index_of, startsWith, starts_with, endsWith, ends_with
/// - Transform: reverse, repeat, charAt, char_at, substring, replace, split, join
/// - Padding: padStart, pad_start, padEnd, pad_end
/// - Predicates: isDigit, is_digit, isAlpha, is_alpha, isAscii, is_ascii
/// - Conversion: toString, to_string, toInt, to_int, toNumber, to_number, toFloat, to_float
/// - Unicode: codePointAt, code_point_at, graphemeLen, grapheme_len
///
/// **Not included (fall through to legacy):** iter, graphemes, normalize
pub static STRING_METHODS: phf::Map<&'static str, MethodHandler> = phf_map! {
    // Info
    "len" => crate::executor::objects::string_methods::v2_string_len,
    "length" => crate::executor::objects::string_methods::v2_string_len,

    // Case
    "toUpperCase" => crate::executor::objects::string_methods::v2_string_to_upper,
    "to_upper_case" => crate::executor::objects::string_methods::v2_string_to_upper,
    "toLowerCase" => crate::executor::objects::string_methods::v2_string_to_lower,
    "to_lower_case" => crate::executor::objects::string_methods::v2_string_to_lower,

    // Whitespace
    "trim" => crate::executor::objects::string_methods::v2_string_trim,
    "trimStart" => crate::executor::objects::string_methods::v2_string_trim_start,
    "trim_start" => crate::executor::objects::string_methods::v2_string_trim_start,
    "trimEnd" => crate::executor::objects::string_methods::v2_string_trim_end,
    "trim_end" => crate::executor::objects::string_methods::v2_string_trim_end,

    // Conversion / identity
    "toString" => crate::executor::objects::string_methods::v2_string_to_string,
    "to_string" => crate::executor::objects::string_methods::v2_string_to_string,

    // Search
    "startsWith" => crate::executor::objects::string_methods::v2_string_starts_with,
    "starts_with" => crate::executor::objects::string_methods::v2_string_starts_with,
    "endsWith" => crate::executor::objects::string_methods::v2_string_ends_with,
    "ends_with" => crate::executor::objects::string_methods::v2_string_ends_with,
    "contains" => crate::executor::objects::string_methods::v2_string_contains,
    "indexOf" => crate::executor::objects::string_methods::v2_string_index_of,
    "index_of" => crate::executor::objects::string_methods::v2_string_index_of,

    // Transform
    "repeat" => crate::executor::objects::string_methods::v2_string_repeat,
    "charAt" => crate::executor::objects::string_methods::v2_string_char_at,
    "char_at" => crate::executor::objects::string_methods::v2_string_char_at,
    "reverse" => crate::executor::objects::string_methods::v2_string_reverse,
    "split" => crate::executor::objects::string_methods::v2_string_split,
    "replace" => crate::executor::objects::string_methods::v2_string_replace,
    "substring" => crate::executor::objects::string_methods::v2_string_substring,
    "join" => crate::executor::objects::string_methods::v2_string_join,

    // Padding
    "padStart" => crate::executor::objects::string_methods::v2_string_pad_start,
    "pad_start" => crate::executor::objects::string_methods::v2_string_pad_start,
    "padEnd" => crate::executor::objects::string_methods::v2_string_pad_end,
    "pad_end" => crate::executor::objects::string_methods::v2_string_pad_end,

    // Predicates
    "isDigit" => crate::executor::objects::string_methods::v2_string_is_digit,
    "is_digit" => crate::executor::objects::string_methods::v2_string_is_digit,
    "isAlpha" => crate::executor::objects::string_methods::v2_string_is_alpha,
    "is_alpha" => crate::executor::objects::string_methods::v2_string_is_alpha,
    "isAscii" => crate::executor::objects::string_methods::v2_string_is_ascii,
    "is_ascii" => crate::executor::objects::string_methods::v2_string_is_ascii,

    // Numeric conversion
    "toInt" => crate::executor::objects::string_methods::v2_string_to_int,
    "to_int" => crate::executor::objects::string_methods::v2_string_to_int,
    "toNumber" => crate::executor::objects::string_methods::v2_string_to_number,
    "to_number" => crate::executor::objects::string_methods::v2_string_to_number,
    "toFloat" => crate::executor::objects::string_methods::v2_string_to_number,
    "to_float" => crate::executor::objects::string_methods::v2_string_to_number,

    // Unicode
    "codePointAt" => crate::executor::objects::string_methods::v2_string_code_point_at,
    "code_point_at" => crate::executor::objects::string_methods::v2_string_code_point_at,
    "graphemeLen" => crate::executor::objects::string_methods::v2_string_grapheme_len,
    "grapheme_len" => crate::executor::objects::string_methods::v2_string_grapheme_len,
    "graphemes" => crate::executor::objects::string_methods::v2_string_graphemes,
    "normalize" => crate::executor::objects::string_methods::v2_string_normalize,
    "iter" => crate::executor::objects::string_methods::v2_string_iter,
};

/// PHF registry for Bool methods
pub static BOOL_METHODS: phf::Map<&'static str, MethodHandler> = phf_map! {
    "toString" => crate::executor::objects::number_methods::bool_to_string_v2,
    "to_string" => crate::executor::objects::number_methods::bool_to_string_v2,
};

/// PHF registry for Char methods (11 methods)
///
/// **Predicates:** is_alphabetic, is_numeric, is_alphanumeric, is_whitespace, is_uppercase, is_lowercase, is_ascii
/// **Transform:** to_uppercase, to_lowercase
/// **Conversion:** to_string, toString
pub static CHAR_METHODS: phf::Map<&'static str, MethodHandler> = phf_map! {
    "is_alphabetic" => crate::executor::objects::number_methods::char_is_alphabetic_v2,
    "isAlphabetic" => crate::executor::objects::number_methods::char_is_alphabetic_v2,
    "is_numeric" => crate::executor::objects::number_methods::char_is_numeric_v2,
    "isNumeric" => crate::executor::objects::number_methods::char_is_numeric_v2,
    "is_alphanumeric" => crate::executor::objects::number_methods::char_is_alphanumeric_v2,
    "isAlphanumeric" => crate::executor::objects::number_methods::char_is_alphanumeric_v2,
    "is_whitespace" => crate::executor::objects::number_methods::char_is_whitespace_v2,
    "isWhitespace" => crate::executor::objects::number_methods::char_is_whitespace_v2,
    "is_uppercase" => crate::executor::objects::number_methods::char_is_uppercase_v2,
    "isUppercase" => crate::executor::objects::number_methods::char_is_uppercase_v2,
    "is_lowercase" => crate::executor::objects::number_methods::char_is_lowercase_v2,
    "isLowercase" => crate::executor::objects::number_methods::char_is_lowercase_v2,
    "is_ascii" => crate::executor::objects::number_methods::char_is_ascii_v2,
    "isAscii" => crate::executor::objects::number_methods::char_is_ascii_v2,
    "to_uppercase" => crate::executor::objects::number_methods::char_to_uppercase_v2,
    "toUppercase" => crate::executor::objects::number_methods::char_to_uppercase_v2,
    "to_lowercase" => crate::executor::objects::number_methods::char_to_lowercase_v2,
    "toLowercase" => crate::executor::objects::number_methods::char_to_lowercase_v2,
    "to_string" => crate::executor::objects::number_methods::char_to_string_v2,
    "toString" => crate::executor::objects::number_methods::char_to_string_v2,
};

/// PHF registry for Content methods
///
/// **Style:** bold, italic, underline, dim, fg, bg
/// **Table/Chart:** border, max_rows, maxRows, series, title, x_label, xLabel, y_label, yLabel
/// **Conversion:** toString
pub static CONTENT_METHODS: phf::Map<&'static str, MethodHandler> = phf_map! {
    "bold" => crate::executor::objects::content_methods::v2_content_bold,
    "italic" => crate::executor::objects::content_methods::v2_content_italic,
    "underline" => crate::executor::objects::content_methods::v2_content_underline,
    "dim" => crate::executor::objects::content_methods::v2_content_dim,
    "fg" => crate::executor::objects::content_methods::v2_content_fg,
    "bg" => crate::executor::objects::content_methods::v2_content_bg,
    "toString" => crate::executor::objects::content_methods::v2_content_to_string,
    "border" => crate::executor::objects::content_methods::v2_content_border,
    "max_rows" => crate::executor::objects::content_methods::v2_content_max_rows,
    "maxRows" => crate::executor::objects::content_methods::v2_content_max_rows_camel,
    "series" => crate::executor::objects::content_methods::v2_content_series,
    "title" => crate::executor::objects::content_methods::v2_content_title,
    "x_label" => crate::executor::objects::content_methods::v2_content_x_label,
    "xLabel" => crate::executor::objects::content_methods::v2_content_x_label_camel,
    "y_label" => crate::executor::objects::content_methods::v2_content_y_label,
    "yLabel" => crate::executor::objects::content_methods::v2_content_y_label_camel,
    // W18.5 builder methods (R8 W4, 2026-05-24 — supervisor D4): per-type
    // builder chain ergonomics for `Table::new()` / `Code::new()` /
    // `KeyValue::new()`. The receiver kind is always
    // `Ptr(HeapKind::Content)` and each method clones + mutates a single
    // field on the underlying `ContentNode` variant, returning a fresh
    // Content slot. `.build()` is identity (no typed Table → content
    // projection per "shortest path" supervisor D4 disposition).
    "headers" => crate::executor::objects::content_methods::v2_content_headers,
    "row" => crate::executor::objects::content_methods::v2_content_row,
    "language" => crate::executor::objects::content_methods::v2_content_language,
    "source" => crate::executor::objects::content_methods::v2_content_source,
    "pair" => crate::executor::objects::content_methods::v2_content_pair,
    "build" => crate::executor::objects::content_methods::v2_content_build,
};

/// PHF registry for Range methods (W15-range, ADR-006 §2.7.23 / Q24).
///
/// **Conversion:** iter, toArray
/// **Bound test:** contains
/// **Accessors:** start, end, step, length, size, len, isEmpty
pub static RANGE_METHODS: phf::Map<&'static str, MethodHandler> = phf_map! {
    "iter" => crate::executor::objects::range_methods::range_iter,
    "toArray" => crate::executor::objects::range_methods::range_to_array,
    "contains" => crate::executor::objects::range_methods::range_contains,
    "start" => crate::executor::objects::range_methods::range_start,
    "end" => crate::executor::objects::range_methods::range_end,
    "step" => crate::executor::objects::range_methods::range_step,
    "length" => crate::executor::objects::range_methods::range_length,
    "size" => crate::executor::objects::range_methods::range_length,
    "len" => crate::executor::objects::range_methods::range_length,
    "isEmpty" => crate::executor::objects::range_methods::range_is_empty,
};