%{
  implemented: [
    %{
      name: "*",
      description: "Multiplication",
      binding: :variadic,
      category: :core,
      dispatch: :env,
      signatures: ["(* x y ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "*",
      divergences: nil
    },
    %{
      name: "*'",
      description: "Arbitrary precision multiplication alias",
      binding: :collect,
      category: :core,
      dispatch: :env,
      signatures: ["(*' x y ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: "Alias for `*`; BEAM integers are already arbitrary precision.",
      see_also: ["*"],
      clojure_var: "*'",
      divergences: nil
    },
    %{
      name: "+",
      description: "Addition",
      binding: :variadic,
      category: :core,
      dispatch: :env,
      signatures: ["(+ x y ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "+",
      divergences: nil
    },
    %{
      name: "+'",
      description: "Arbitrary precision addition alias",
      binding: :collect,
      category: :core,
      dispatch: :env,
      signatures: ["(+' x y ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: "Alias for `+`; BEAM integers are already arbitrary precision.",
      see_also: ["+"],
      clojure_var: "+'",
      divergences: nil
    },
    %{
      name: "-",
      description: "Subtraction",
      binding: :variadic,
      category: :core,
      dispatch: :env,
      signatures: ["(- x y ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "-",
      divergences: nil
    },
    %{
      name: "-'",
      description: "Arbitrary precision subtraction alias",
      binding: :collect,
      category: :core,
      dispatch: :env,
      signatures: ["(-' x y ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: "Alias for `-`; BEAM integers are already arbitrary precision.",
      see_also: ["-"],
      clojure_var: "-'",
      divergences: nil
    },
    %{
      name: ".getTime",
      description: "Return Unix timestamp in milliseconds (**DateTime only**)",
      binding: :normal,
      category: :interop,
      dispatch: :env,
      signatures: ["(.getTime date)"],
      since: nil,
      section: "Interop",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: ".getTime",
      divergences: nil
    },
    %{
      name: ".toEpochDay",
      description: "Return LocalDate epoch-day integer",
      binding: :normal,
      category: :interop,
      dispatch: :env,
      signatures: ["(.toEpochDay local-date)"],
      since: nil,
      section: "Interop",
      ptc_extension?: false,
      examples: [],
      notes: "Works on LocalDate values returned by `LocalDate/parse`.",
      see_also: ["LocalDate/parse", ".plusDays", ".minusDays"],
      clojure_var: ".toEpochDay",
      divergences: nil
    },
    %{
      name: ".plusDays",
      description: "Add days to a LocalDate",
      binding: :normal,
      category: :interop,
      dispatch: :env,
      signatures: ["(.plusDays local-date n)"],
      since: nil,
      section: "Interop",
      ptc_extension?: false,
      examples: [],
      notes: "Works on LocalDate values returned by `LocalDate/parse`; `n` must be an integer.",
      see_also: ["LocalDate/parse", ".minusDays", ".toEpochDay"],
      clojure_var: ".plusDays",
      divergences: nil
    },
    %{
      name: ".minusDays",
      description: "Subtract days from a LocalDate",
      binding: :normal,
      category: :interop,
      dispatch: :env,
      signatures: ["(.minusDays local-date n)"],
      since: nil,
      section: "Interop",
      ptc_extension?: false,
      examples: [],
      notes: "Works on LocalDate values returned by `LocalDate/parse`; `n` must be an integer.",
      see_also: ["LocalDate/parse", ".plusDays", ".toEpochDay"],
      clojure_var: ".minusDays",
      divergences: nil
    },
    %{
      name: ".toMillis",
      description: "Return duration length in milliseconds",
      binding: :normal,
      category: :interop,
      dispatch: :env,
      signatures: ["(.toMillis duration)"],
      since: nil,
      section: "Interop",
      ptc_extension?: false,
      examples: [],
      notes: "Works on Duration values returned by `Duration/between`.",
      see_also: ["Duration/between", ".toDays"],
      clojure_var: ".toMillis",
      divergences: nil
    },
    %{
      name: ".toDays",
      description: "Return duration length in whole days",
      binding: :normal,
      category: :interop,
      dispatch: :env,
      signatures: ["(.toDays duration)"],
      since: nil,
      section: "Interop",
      ptc_extension?: false,
      examples: [],
      notes:
        "Works on Duration values returned by `Duration/between`; partial days truncate toward zero.",
      see_also: ["Duration/between", ".toMillis"],
      clojure_var: ".toDays",
      divergences: nil
    },
    %{
      name: ".contains",
      description: "Returns true if string contains substring",
      binding: :normal,
      category: :interop,
      dispatch: :env,
      signatures: ["(.contains s substr)"],
      since: nil,
      section: "Interop",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: ".contains",
      divergences: nil
    },
    %{
      name: ".indexOf",
      description: "Index of first occurrence starting from position",
      binding: :multi_arity,
      category: :interop,
      dispatch: :env,
      signatures: ["(.indexOf s substr)", "(.indexOf s substr from)"],
      since: nil,
      section: "Interop",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: ".indexOf",
      divergences: nil
    },
    %{
      name: ".lastIndexOf",
      description: "Index of last occurrence, or -1 if not found",
      binding: :normal,
      category: :interop,
      dispatch: :env,
      signatures: ["(.lastIndexOf s substr)"],
      since: nil,
      section: "Interop",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: ".lastIndexOf",
      divergences: nil
    },
    %{
      name: ".toLowerCase",
      description: "Convert string to lower case",
      binding: :normal,
      category: :interop,
      dispatch: :env,
      signatures: ["(.toLowerCase s)"],
      since: nil,
      section: "Interop",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: ".toLowerCase",
      divergences: nil
    },
    %{
      name: ".length",
      description: "Return the grapheme count of a string",
      binding: :normal,
      category: :interop,
      dispatch: :env,
      signatures: ["(.length s)"],
      since: nil,
      section: "Interop",
      ptc_extension?: false,
      examples: [],
      notes:
        "Returns grapheme count (not byte length), matching `count` on a string and `.indexOf` index semantics.",
      see_also: ["count"],
      clojure_var: ".length",
      divergences: nil
    },
    %{
      name: ".substring",
      description: "Extract a substring by grapheme index",
      binding: :multi_arity,
      category: :interop,
      dispatch: :env,
      signatures: ["(.substring s start)", "(.substring s start end)"],
      since: nil,
      section: "Interop",
      ptc_extension?: false,
      examples: [],
      notes:
        "Indices are grapheme-based (not byte offsets). Two-arg form returns graphemes in [start, end). Raises on out-of-range indices (matches Java's StringIndexOutOfBoundsException): start < 0, start > length, end > length, or start > end. Notably, (.substring s -1) raises rather than silently returning the last grapheme — important when chaining .indexOf, which returns -1 on miss.",
      see_also: [".indexOf", ".length"],
      clojure_var: ".substring",
      divergences: nil
    },
    %{
      name: ".toUpperCase",
      description: "Convert string to upper case",
      binding: :normal,
      category: :interop,
      dispatch: :env,
      signatures: ["(.toUpperCase s)"],
      since: nil,
      section: "Interop",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: ".toUpperCase",
      divergences: nil
    },
    %{
      name: ".startsWith",
      description: "Returns true if string starts with prefix",
      binding: :normal,
      category: :interop,
      dispatch: :env,
      signatures: ["(.startsWith s prefix)"],
      since: nil,
      section: "Interop",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: ".startsWith",
      divergences: nil
    },
    %{
      name: ".endsWith",
      description: "Returns true if string ends with suffix",
      binding: :normal,
      category: :interop,
      dispatch: :env,
      signatures: ["(.endsWith s suffix)"],
      since: nil,
      section: "Interop",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: ".endsWith",
      divergences: nil
    },
    %{
      name: ".isBefore",
      description: "Returns true if date/datetime comes strictly before another (same-type only)",
      binding: :normal,
      category: :interop,
      dispatch: :env,
      signatures: ["(.isBefore a b)"],
      since: nil,
      section: "Interop",
      ptc_extension?: false,
      examples: [],
      notes: "Works on both LocalDate and DateTime. Mixed types raise an error.",
      see_also: [".isAfter"],
      clojure_var: ".isBefore",
      divergences: nil
    },
    %{
      name: ".isAfter",
      description: "Returns true if date/datetime comes strictly after another (same-type only)",
      binding: :normal,
      category: :interop,
      dispatch: :env,
      signatures: ["(.isAfter a b)"],
      since: nil,
      section: "Interop",
      ptc_extension?: false,
      examples: [],
      notes: "Works on both LocalDate and DateTime. Mixed types raise an error.",
      see_also: [".isBefore"],
      clojure_var: ".isAfter",
      divergences: nil
    },
    %{
      name: "/",
      description: "Division (always returns float)",
      binding: :variadic_nonempty,
      category: :core,
      dispatch: :env,
      signatures: ["(/ x y)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "/",
      divergences: nil
    },
    %{
      name: "<",
      description: "Less than",
      binding: :collect,
      category: :core,
      dispatch: :env,
      signatures: ["(< x)", "(< x y & more)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "<",
      divergences: nil
    },
    %{
      name: "<=",
      description: "Less or equal",
      binding: :collect,
      category: :core,
      dispatch: :env,
      signatures: ["(<= x)", "(<= x y & more)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "<=",
      divergences: nil
    },
    %{
      name: "=",
      description: "Equality",
      binding: :collect,
      category: :core,
      dispatch: :env,
      signatures: ["(= x)", "(= x y & more)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "=",
      divergences: nil
    },
    %{
      name: "==",
      description: "Type-independent numeric equality",
      binding: :collect,
      category: :core,
      dispatch: :env,
      signatures: ["(== x)", "(== x y & more)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: "Alias for PTC-Lisp `=` numeric equality.",
      see_also: ["="],
      clojure_var: "==",
      divergences:
        "DIV-10: Clojure's == throws ClassCastException for non-numeric arguments; PTC-Lisp accepts any type and returns true/false (consistent with no-exception design)."
    },
    %{
      name: ">",
      description: "Greater than",
      binding: :collect,
      category: :core,
      dispatch: :env,
      signatures: ["(> x)", "(> x y & more)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: ">",
      divergences: nil
    },
    %{
      name: ">=",
      description: "Greater or equal",
      binding: :collect,
      category: :core,
      dispatch: :env,
      signatures: ["(>= x)", "(>= x y & more)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: ">=",
      divergences: nil
    },
    %{
      name: "NEGATIVE_INFINITY",
      description: "Negative infinity constant (Double/NEGATIVE_INFINITY)",
      binding: :constant,
      category: :interop,
      dispatch: :env,
      signatures: ["NEGATIVE_INFINITY"],
      since: nil,
      section: "Interop",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "NEGATIVE_INFINITY",
      divergences: nil
    },
    %{
      name: "NaN",
      description: "Not-a-Number constant (Double/NaN)",
      binding: :constant,
      category: :interop,
      dispatch: :env,
      signatures: ["NaN"],
      since: nil,
      section: "Interop",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "NaN",
      divergences: nil
    },
    %{
      name: "NaN?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(NaN? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "NaN?",
      divergences: nil
    },
    %{
      name: "POSITIVE_INFINITY",
      description: "Positive infinity constant (Double/POSITIVE_INFINITY)",
      binding: :constant,
      category: :interop,
      dispatch: :env,
      signatures: ["POSITIVE_INFINITY"],
      since: nil,
      section: "Interop",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "POSITIVE_INFINITY",
      divergences: nil
    },
    %{
      name: "abs",
      description: "Absolute value",
      binding: :normal,
      category: :math,
      dispatch: :env,
      signatures: ["(abs x)"],
      since: nil,
      section: "Math Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "abs",
      divergences: nil
    },
    %{
      name: "apply",
      description: "Applies function `f` to the argument sequence `coll`",
      binding: :special,
      category: :core,
      dispatch: :env,
      signatures: ["(apply f coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "apply",
      divergences: nil
    },
    %{
      name: "assoc",
      description: "Add/update key",
      binding: :collect,
      category: :core,
      dispatch: :env,
      signatures: ["(assoc m key val)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "assoc",
      divergences: nil
    },
    %{
      name: "assoc-in",
      description: "Add/update nested",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(assoc-in m path val)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "assoc-in",
      divergences: nil
    },
    %{
      name: "associative?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(associative? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "associative?",
      divergences: nil
    },
    %{
      name: "avg",
      description: "Average of numbers",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(avg coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: true,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "avg",
      divergences: nil
    },
    %{
      name: "avg-by",
      description: "Average field values",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(avg-by key coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: true,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "avg-by",
      divergences: nil
    },
    %{
      name: "bit-and",
      description: "Bitwise AND of integers",
      binding: :collect,
      category: :math,
      dispatch: :env,
      signatures: ["(bit-and x & more)"],
      since: nil,
      section: "Math Functions",
      ptc_extension?: false,
      examples: [],
      notes: "Integers only — raises a type error on non-integer arguments.",
      see_also: ["bit-or", "bit-xor", "bit-and-not"],
      clojure_var: "bit-and",
      divergences: nil
    },
    %{
      name: "bit-and-not",
      description: "Bitwise AND of `x` with the complement of each subsequent argument",
      binding: :collect,
      category: :math,
      dispatch: :env,
      signatures: ["(bit-and-not x & more)"],
      since: nil,
      section: "Math Functions",
      ptc_extension?: false,
      examples: [],
      notes: "Integers only — raises a type error on non-integer arguments.",
      see_also: ["bit-and", "bit-not"],
      clojure_var: "bit-and-not",
      divergences: nil
    },
    %{
      name: "bit-clear",
      description: "Clear bit `n` of `x` (set it to 0)",
      binding: :normal,
      category: :math,
      dispatch: :env,
      signatures: ["(bit-clear x n)"],
      since: nil,
      section: "Math Functions",
      ptc_extension?: false,
      examples: [],
      notes: "Integers only; `n` must be a non-negative integer.",
      see_also: ["bit-set", "bit-flip", "bit-test"],
      clojure_var: "bit-clear",
      divergences: nil
    },
    %{
      name: "bit-flip",
      description: "Flip bit `n` of `x`",
      binding: :normal,
      category: :math,
      dispatch: :env,
      signatures: ["(bit-flip x n)"],
      since: nil,
      section: "Math Functions",
      ptc_extension?: false,
      examples: [],
      notes: "Integers only; `n` must be a non-negative integer.",
      see_also: ["bit-set", "bit-clear", "bit-test"],
      clojure_var: "bit-flip",
      divergences: nil
    },
    %{
      name: "bit-not",
      description: "Bitwise complement (two's complement) of an integer",
      binding: :normal,
      category: :math,
      dispatch: :env,
      signatures: ["(bit-not x)"],
      since: nil,
      section: "Math Functions",
      ptc_extension?: false,
      examples: [],
      notes: "Integers only — raises a type error on non-integer arguments.",
      see_also: ["bit-and", "bit-or", "bit-xor"],
      clojure_var: "bit-not",
      divergences: nil
    },
    %{
      name: "bit-or",
      description: "Bitwise OR of integers",
      binding: :collect,
      category: :math,
      dispatch: :env,
      signatures: ["(bit-or x & more)"],
      since: nil,
      section: "Math Functions",
      ptc_extension?: false,
      examples: [],
      notes: "Integers only — raises a type error on non-integer arguments.",
      see_also: ["bit-and", "bit-xor", "bit-and-not"],
      clojure_var: "bit-or",
      divergences: nil
    },
    %{
      name: "bit-set",
      description: "Set bit `n` of `x` to 1",
      binding: :normal,
      category: :math,
      dispatch: :env,
      signatures: ["(bit-set x n)"],
      since: nil,
      section: "Math Functions",
      ptc_extension?: false,
      examples: [],
      notes: "Integers only; `n` must be a non-negative integer.",
      see_also: ["bit-clear", "bit-flip", "bit-test"],
      clojure_var: "bit-set",
      divergences: nil
    },
    %{
      name: "bit-shift-left",
      description: "Shift `x` left by `n` bits",
      binding: :normal,
      category: :math,
      dispatch: :env,
      signatures: ["(bit-shift-left x n)"],
      since: nil,
      section: "Math Functions",
      ptc_extension?: false,
      examples: [],
      notes:
        "Integers only; `n` must be a non-negative integer. Unlike Clojure/JVM, BEAM integers are arbitrary-precision: the shift amount is not taken modulo 64 and the result can grow without bound.",
      see_also: ["bit-shift-right"],
      clojure_var: "bit-shift-left",
      divergences: nil
    },
    %{
      name: "bit-shift-right",
      description: "Arithmetic shift `x` right by `n` bits (sign-extending)",
      binding: :normal,
      category: :math,
      dispatch: :env,
      signatures: ["(bit-shift-right x n)"],
      since: nil,
      section: "Math Functions",
      ptc_extension?: false,
      examples: [],
      notes:
        "Integers only; `n` must be a non-negative integer. Unlike Clojure/JVM, BEAM integers are arbitrary-precision: the shift amount is not taken modulo 64. `unsigned-bit-shift-right` is not provided because it has no defined meaning without a fixed integer width.",
      see_also: ["bit-shift-left"],
      clojure_var: "bit-shift-right",
      divergences: nil
    },
    %{
      name: "bit-test",
      description: "Return true if bit `n` of `x` is set",
      binding: :normal,
      category: :math,
      dispatch: :env,
      signatures: ["(bit-test x n)"],
      since: nil,
      section: "Math Functions",
      ptc_extension?: false,
      examples: [],
      notes: "Integers only; `n` must be a non-negative integer.",
      see_also: ["bit-set", "bit-clear", "bit-flip"],
      clojure_var: "bit-test",
      divergences: nil
    },
    %{
      name: "bit-xor",
      description: "Bitwise exclusive OR of integers",
      binding: :collect,
      category: :math,
      dispatch: :env,
      signatures: ["(bit-xor x & more)"],
      since: nil,
      section: "Math Functions",
      ptc_extension?: false,
      examples: [],
      notes: "Integers only — raises a type error on non-integer arguments.",
      see_also: ["bit-and", "bit-or", "bit-and-not"],
      clojure_var: "bit-xor",
      divergences: nil
    },
    %{
      name: "boolean",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(boolean ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "boolean",
      divergences: nil
    },
    %{
      name: "boolean?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(boolean? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "boolean?",
      divergences: nil
    },
    %{
      name: "butlast",
      description: "All but last (empty list if none)",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(butlast coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "butlast",
      divergences: nil
    },
    %{
      name: "ceil",
      description: "Round toward +∞",
      binding: :normal,
      category: :math,
      dispatch: :env,
      signatures: ["(ceil x)"],
      since: nil,
      section: "Math Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "ceil",
      divergences: nil
    },
    %{
      name: "char?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(char? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "char?",
      divergences: nil
    },
    %{
      name: "coll?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(coll? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "coll?",
      divergences: nil
    },
    %{
      name: "combinations",
      description: "Generate all n-combinations",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(combinations coll n)"],
      since: nil,
      section: "Core",
      ptc_extension?: true,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "combinations",
      divergences: nil
    },
    %{
      name: "comp",
      description: "Returns a function composing fns right-to-left; `(comp)` returns `identity`",
      binding: :collect,
      category: :core,
      dispatch: :env,
      signatures: ["(comp f1 f2 ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "comp",
      divergences: nil
    },
    %{
      name: "compare",
      description:
        "Numeric comparison: `-1` if `x < y`, `0` if `x == y`, `1` if `x > y`. Only supports numbers in PTC-Lisp.",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(compare x y)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "compare",
      divergences: nil
    },
    %{
      name: "complement",
      description: "Returns a function with the opposite truth value (always boolean)",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(complement f)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "complement",
      divergences: nil
    },
    %{
      name: "concat",
      description: "Join collections",
      binding: :variadic,
      category: :core,
      dispatch: :env,
      signatures: ["(concat coll1 coll2 ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "concat",
      divergences: nil
    },
    %{
      name: "conj",
      description: "Add elements to collection",
      binding: :variadic_nonempty,
      category: :core,
      dispatch: :env,
      signatures: ["(conj coll x ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "conj",
      divergences: nil
    },
    %{
      name: "cons",
      description: "Prepend item to sequence",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(cons x seq)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "cons",
      divergences: nil
    },
    %{
      name: "list",
      description:
        "Create a vector from arguments — alias for `vector` (PTC-Lisp is vector-first)",
      binding: :collect,
      category: :core,
      dispatch: :env,
      signatures: ["(list & args)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: ["vector", "vec"],
      clojure_var: "list",
      divergences:
        "Returns a vector, not a Clojure list — PTC-Lisp has no separate list type. See docs/clojure-conformance-gaps.md."
    },
    %{
      name: "constantly",
      description: "Returns a function that always returns `x`, ignoring its arguments",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(constantly x)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "constantly",
      divergences: nil
    },
    %{
      name: "contains?",
      description: "True if key/element exists (maps, sets, lists)",
      binding: :normal,
      category: :set,
      dispatch: :env,
      signatures: ["(contains? coll key)"],
      since: nil,
      section: "Set Operations",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "contains?",
      divergences: nil
    },
    %{
      name: "count",
      description: "Number of items",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(count coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "count",
      divergences: nil
    },
    %{
      name: "counted?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(counted? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "counted?",
      divergences: nil
    },
    %{
      name: "currentTimeMillis",
      description: "Return current time in milliseconds since epoch",
      binding: :normal,
      category: :interop,
      dispatch: :env,
      signatures: ["(System/currentTimeMillis)"],
      since: nil,
      section: "Interop",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "currentTimeMillis",
      divergences: nil
    },
    %{
      name: "Duration/between",
      description: "Return a Duration between two DateTime instants",
      binding: :normal,
      category: :interop,
      dispatch: :env,
      signatures: [
        "(Duration/between start-instant end-instant)",
        "(java.time.Duration/between start-instant end-instant)"
      ],
      since: nil,
      section: "Interop",
      ptc_extension?: false,
      examples: [],
      notes:
        "Requires DateTime values, such as results from `Instant/parse`; LocalDate values are intentionally rejected.",
      see_also: ["Instant/parse", ".toMillis", ".toDays"],
      clojure_var: "Duration/between",
      divergences: nil
    },
    %{
      name: "dec",
      description: "Subtract 1",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(dec x)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "dec",
      divergences: nil
    },
    %{
      name: "dec'",
      description: "Arbitrary precision decrement alias",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(dec' x)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: "Alias for `dec`; BEAM integers are already arbitrary precision.",
      see_also: ["dec"],
      clojure_var: "dec'",
      divergences: nil
    },
    %{
      name: "decimal?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(decimal? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "decimal?",
      divergences:
        "DIV-20: always returns false; BEAM has no BigDecimal type. See docs/clojure-conformance-gaps.md."
    },
    %{
      name: "dedupe",
      description: "Remove consecutive duplicates",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(dedupe coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "dedupe",
      divergences: nil
    },
    %{
      name: "difference",
      description: "Returns the difference of one or more sets",
      binding: :variadic_nonempty,
      category: :set,
      dispatch: :env,
      signatures: ["(clojure.set/difference & sets)"],
      since: nil,
      section: "Set Operations",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "difference",
      divergences: nil
    },
    %{
      name: "disj",
      description: "Remove elements from set",
      binding: :variadic_nonempty,
      category: :set,
      dispatch: :env,
      signatures: ["(disj set x ...)"],
      since: nil,
      section: "Set Operations",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "disj",
      divergences: nil
    },
    %{
      name: "dissoc",
      description: "Remove key",
      binding: :collect,
      category: :core,
      dispatch: :env,
      signatures: ["(dissoc m key)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "dissoc",
      divergences: nil
    },
    %{
      name: "distinct",
      description: "Remove duplicates",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(distinct coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "distinct",
      divergences: nil
    },
    %{
      name: "distinct-by",
      description: "Items with unique field values",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(distinct-by key coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: true,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "distinct-by",
      divergences: nil
    },
    %{
      name: "distinct?",
      description: "True if all arguments are distinct",
      binding: :collect,
      category: :core,
      dispatch: :env,
      signatures: ["(distinct? x y ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "distinct?",
      divergences: nil
    },
    %{
      name: "double",
      description: "Type coercion (to float)",
      binding: :normal,
      category: :math,
      dispatch: :env,
      signatures: ["(double x)"],
      since: nil,
      section: "Math Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "double",
      divergences: nil
    },
    %{
      name: "double?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(double? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "double?",
      divergences: nil
    },
    %{
      name: "blank?",
      description: "True if nil, empty, or only whitespace",
      binding: :normal,
      category: :string,
      dispatch: :env,
      signatures: ["(blank? s)"],
      since: nil,
      section: "String Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "blank?",
      divergences: nil
    },
    %{
      name: "downcase",
      description: "",
      binding: :normal,
      category: :string,
      dispatch: :env,
      signatures: ["(downcase ...)"],
      since: nil,
      section: "String Functions",
      ptc_extension?: true,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "downcase",
      divergences: nil
    },
    %{
      name: "drop",
      description: "Skip first n items",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(drop n coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "drop",
      divergences: nil
    },
    %{
      name: "nthnext",
      description: "Drop n items and return seq or nil",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(nthnext coll n)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: "Equivalent to `(seq (drop n coll))`.",
      see_also: ["drop", "seq"],
      clojure_var: "nthnext",
      divergences: nil
    },
    %{
      name: "nthrest",
      description: "Drop n items",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(nthrest coll n)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: "Alias for `drop`.",
      see_also: ["drop"],
      clojure_var: "nthrest",
      divergences: nil
    },
    %{
      name: "drop-last",
      description: "",
      binding: :multi_arity,
      category: :core,
      dispatch: :env,
      signatures: ["(drop-last coll)", "(drop-last n coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "drop-last",
      divergences: nil
    },
    %{
      name: "drop-while",
      description: "Drop while pred is true",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(drop-while pred coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "drop-while",
      divergences: nil
    },
    %{
      name: "empty",
      description: "Return empty collection of same type",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(empty coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "empty",
      divergences: nil
    },
    %{
      name: "empty?",
      description: "True if empty or nil",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(empty? coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "empty?",
      divergences: nil
    },
    %{
      name: "ends-with?",
      description: "Check if string ends with suffix",
      binding: :normal,
      category: :string,
      dispatch: :env,
      signatures: ["(ends-with? s suffix)"],
      since: nil,
      section: "String Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "ends-with?",
      divergences: nil
    },
    %{
      name: "entries",
      description: "Get all `[key value]` pairs as a list",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(entries m)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "entries",
      divergences: nil
    },
    %{
      name: "even?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(even? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "even?",
      divergences:
        "GAP-S08: accepts whole-number floats (returns true/false) instead of raising IllegalArgumentException. Non-whole floats and non-numbers return false. See docs/clojure-conformance-gaps.md."
    },
    %{
      name: "every-pred",
      description: "Returns a predicate true when all preds are satisfied (always boolean)",
      binding: :collect,
      category: :core,
      dispatch: :env,
      signatures: ["(every-pred p1 p2 ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "every-pred",
      divergences: nil
    },
    %{
      name: "every?",
      description: "True if all have truthy `:key`",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(every? :key coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "every?",
      divergences: nil
    },
    %{
      name: "extract",
      description: "Extract capture group n (0 = full match)",
      binding: :multi_arity,
      category: :string,
      dispatch: :env,
      signatures: ["(extract pattern s)", "(extract pattern s n)"],
      since: nil,
      section: "String Functions",
      ptc_extension?: true,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "extract",
      divergences: nil
    },
    %{
      name: "extract-int",
      description: "Extract group n, parse as int, return default on failure",
      binding: :multi_arity,
      category: :string,
      dispatch: :env,
      signatures: [
        "(extract-int pattern s)",
        "(extract-int pattern s n)",
        "(extract-int pattern s n default)"
      ],
      since: nil,
      section: "String Functions",
      ptc_extension?: true,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "extract-int",
      divergences: nil
    },
    %{
      name: "false?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(false? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "false?",
      divergences: nil
    },
    %{
      name: "ffirst",
      description: "First of first",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(ffirst coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "ffirst",
      divergences: nil
    },
    %{
      name: "filter",
      description: "Keep items where pred is truthy",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(filter pred coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "filter",
      divergences: nil
    },
    %{
      name: "filterv",
      description: "Same as filter (vectors are the default)",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(filterv pred coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "filterv",
      divergences: nil
    },
    %{
      name: "find",
      description: "First item where pred is truthy, or nil",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(find pred coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "find",
      divergences: nil
    },
    %{
      name: "first",
      description: "First item or nil",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(first coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "first",
      divergences: nil
    },
    %{
      name: "flatten",
      description: "Flatten nested collections",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(flatten coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "flatten",
      divergences: nil
    },
    %{
      name: "float",
      description: "Alias for double (Clojure compat)",
      binding: :normal,
      category: :math,
      dispatch: :env,
      signatures: ["(float x)"],
      since: nil,
      section: "Math Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "float",
      divergences: nil
    },
    %{
      name: "float?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(float? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "float?",
      divergences: nil
    },
    %{
      name: "floor",
      description: "Round toward -∞",
      binding: :normal,
      category: :math,
      dispatch: :env,
      signatures: ["(floor x)"],
      since: nil,
      section: "Math Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "floor",
      divergences: nil
    },
    %{
      name: "fn?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(fn? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "fn?",
      divergences: nil
    },
    %{
      name: "fnext",
      description: "First of next",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(fnext coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "fnext",
      divergences: nil
    },
    %{
      name: "fnil",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(fnil ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "fnil",
      divergences: nil
    },
    %{
      name: "format",
      description: "Java-style format string",
      binding: :collect,
      category: :string,
      dispatch: :env,
      signatures: ["(format fmt-string & args)"],
      since: nil,
      section: "String Functions",
      ptc_extension?: true,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "format",
      divergences:
        "DIV-21: renders nil as \"\" (not \"null\"), consistent with (str nil) → \"\". See docs/clojure-conformance-gaps.md."
    },
    %{
      name: "frequencies",
      description: "Count occurrences of each item",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(frequencies coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "frequencies",
      divergences: nil
    },
    %{
      name: "get",
      description: "Get with default",
      binding: :multi_arity,
      category: :core,
      dispatch: :env,
      signatures: ["(get m key)", "(get m key default)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "get",
      divergences: nil
    },
    %{
      name: "get-in",
      description: "Get nested with default",
      binding: :multi_arity,
      category: :core,
      dispatch: :env,
      signatures: ["(get-in m path)", "(get-in m path default)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "get-in",
      divergences: nil
    },
    %{
      name: "group-by",
      description: "Group items by key",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(group-by keyfn coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "group-by",
      divergences: nil
    },
    %{
      name: "identity",
      description: "Returns argument unchanged",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(identity x)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "identity",
      divergences: nil
    },
    %{
      name: "ifn?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(ifn? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "ifn?",
      divergences: nil
    },
    %{
      name: "inc",
      description: "Add 1",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(inc x)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "inc",
      divergences: nil
    },
    %{
      name: "inc'",
      description: "Arbitrary precision increment alias",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(inc' x)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: "Alias for `inc`; BEAM integers are already arbitrary precision.",
      see_also: ["inc"],
      clojure_var: "inc'",
      divergences: nil
    },
    %{
      name: "includes?",
      description: "Check if string contains substring",
      binding: :normal,
      category: :string,
      dispatch: :env,
      signatures: ["(includes? s substring)"],
      since: nil,
      section: "String Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "includes?",
      divergences: nil
    },
    %{
      name: "index-of",
      description: "Index of first occurrence from position",
      binding: :multi_arity,
      category: :string,
      dispatch: :env,
      signatures: ["(index-of s value)", "(index-of s value from-index)"],
      since: nil,
      section: "String Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "index-of",
      divergences: nil
    },
    %{
      name: "indexed?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(indexed? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "indexed?",
      divergences: nil
    },
    %{
      name: "infinite?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(infinite? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "infinite?",
      divergences: nil
    },
    %{
      name: "int",
      description: "Type coercion (to integer)",
      binding: :normal,
      category: :math,
      dispatch: :env,
      signatures: ["(int x)"],
      since: nil,
      section: "Math Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "int",
      divergences: nil
    },
    %{
      name: "int?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(int? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "int?",
      divergences: nil
    },
    %{
      name: "integer?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(integer? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "integer?",
      divergences: nil
    },
    %{
      name: "interleave",
      description: "Interleave collections",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(interleave c1 c2)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "interleave",
      divergences: nil
    },
    %{
      name: "interpose",
      description: "Insert separator between elements",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(interpose sep coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "interpose",
      divergences: nil
    },
    %{
      name: "intersection",
      description: "Returns the intersection of one or more sets",
      binding: :variadic_nonempty,
      category: :set,
      dispatch: :env,
      signatures: ["(clojure.set/intersection & sets)"],
      since: nil,
      section: "Set Operations",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "intersection",
      divergences: nil
    },
    %{
      name: "into",
      description: "Pour from into to",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(into to from)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "into",
      divergences: nil
    },
    %{
      name: "java.util.Date.",
      description:
        "Construct DateTime: no-arg returns current UTC, integer is Unix seconds/ms, string is ISO-8601 (offset optional, treated as UTC if absent) or RFC-2822, existing DateTime/NaiveDateTime/Date passes through",
      binding: :multi_arity,
      category: :interop,
      dispatch: :env,
      signatures: [
        "(java.util.Date.)",
        "(java.util.Date. millis-or-string)",
        "(java.util.Date. datetime-or-date)"
      ],
      since: nil,
      section: "Interop",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "java.util.Date.",
      divergences: nil
    },
    %{
      name: "join",
      description: "Join collection elements (no separator)",
      binding: :multi_arity,
      category: :string,
      dispatch: :env,
      signatures: ["(join coll)", "(join separator coll)"],
      since: nil,
      section: "String Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "join",
      divergences: nil
    },
    %{
      name: "json/generate-string",
      description: "Encode a value as a JSON string; nil on non-encodable input.",
      binding: :normal,
      category: :json,
      dispatch: :env,
      signatures: ["(json/generate-string v)"],
      since: nil,
      section: "JSON",
      ptc_extension?: false,
      examples: [],
      notes:
        "Pre-validates the value tree before invoking Jason.encode/1. Atoms outside true/false/nil, atom-keyed maps, tuples, PIDs, references, and functions all produce nil rather than being silently coerced.",
      see_also: ["json/parse-string"],
      clojure_var: "cheshire.core/generate-string",
      divergences:
        "DIV-24: returns nil on non-encodable input (atoms outside true/false/nil, atom keys, tuples, PIDs) rather than silently auto-stringifying. See docs/clojure-conformance-gaps.md."
    },
    %{
      name: "json/parse-string",
      description: "Parse a JSON string into a value; nil on failure.",
      binding: :normal,
      category: :json,
      dispatch: :env,
      signatures: ["(json/parse-string s)"],
      since: nil,
      section: "JSON",
      ptc_extension?: false,
      examples: [],
      notes:
        "Map keys decode as strings (no atom keys). Returns nil on invalid JSON, nil input, or non-binary input — never raises (DIV-23).",
      see_also: ["json/generate-string"],
      clojure_var: "cheshire.core/parse-string",
      divergences:
        "DIV-23: returns nil on invalid/non-binary input instead of raising. Safer for LLM-generated code (no try/catch — DIV-10). See docs/clojure-conformance-gaps.md."
    },
    %{
      name: "keep",
      description: "Non-nil results of (f item). false is kept.",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(keep f coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "keep",
      divergences: nil
    },
    %{
      name: "keep-indexed",
      description: "Non-nil results of (f index item). false is kept.",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(keep-indexed f coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "keep-indexed",
      divergences: nil
    },
    %{
      name: "key",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(key ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "key",
      divergences: nil
    },
    %{
      name: "keys",
      description: "Get all keys",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(keys m)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "keys",
      divergences: nil
    },
    %{
      name: "keyword",
      description: "Type coercion (string to keyword)",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(keyword x)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "keyword",
      divergences: nil
    },
    %{
      name: "keyword?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(keyword? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "keyword?",
      divergences: nil
    },
    %{
      name: "last",
      description: "Last item or nil",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(last coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "last",
      divergences: nil
    },
    %{
      name: "last-index-of",
      description: "Index of last occurrence up to position",
      binding: :multi_arity,
      category: :string,
      dispatch: :env,
      signatures: ["(last-index-of s value)", "(last-index-of s value from-index)"],
      since: nil,
      section: "String Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "last-index-of",
      divergences: nil
    },
    %{
      name: "lower-case",
      description: "",
      binding: :normal,
      category: :string,
      dispatch: :env,
      signatures: ["(lower-case ...)"],
      since: nil,
      section: "String Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "lower-case",
      divergences: nil
    },
    %{
      name: "map",
      description: "Apply f to triples",
      binding: :multi_arity,
      category: :core,
      dispatch: :env,
      signatures: ["(map f coll)", "(map f c1 c2)", "(map f c1 c2 c3)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "map",
      divergences: nil
    },
    %{
      name: "map-entry?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(map-entry? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "map-entry?",
      divergences: nil
    },
    %{
      name: "map-indexed",
      description: "Apply f to index and item",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(map-indexed f coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "map-indexed",
      divergences: nil
    },
    %{
      name: "map?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(map? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "map?",
      divergences: nil
    },
    %{
      name: "mapcat",
      description: "Apply f to each item, concatenate results",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(mapcat f coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "mapcat",
      divergences: nil
    },
    %{
      name: "mapv",
      description: "Like map with three collections",
      binding: :multi_arity,
      category: :core,
      dispatch: :env,
      signatures: ["(mapv f coll)", "(mapv f c1 c2)", "(mapv f c1 c2 c3)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "mapv",
      divergences: nil
    },
    %{
      name: "max",
      description: "Maximum value",
      binding: :variadic_nonempty,
      category: :math,
      dispatch: :env,
      signatures: ["(max x y ...)"],
      since: nil,
      section: "Math Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "max",
      divergences: nil
    },
    %{
      name: "max-by",
      description: "Item with maximum field",
      binding: :collect,
      category: :core,
      dispatch: :env,
      signatures: ["(max-by f x)", "(max-by f x y & more)"],
      since: nil,
      section: "Core",
      ptc_extension?: true,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "max-by",
      divergences: nil
    },
    %{
      name: "max-key",
      description: "Return x for which (f x) is greatest",
      binding: :collect,
      category: :core,
      dispatch: :env,
      signatures: ["(max-key f x)", "(max-key f x y & more)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "max-key",
      divergences: nil
    },
    %{
      name: "merge",
      description: "Merge maps (later wins)",
      binding: :collect,
      category: :core,
      dispatch: :env,
      signatures: ["(merge m1 m2 ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "merge",
      divergences: nil
    },
    %{
      name: "merge-with",
      description: "Merge maps with combining function for duplicates",
      binding: :collect,
      category: :core,
      dispatch: :env,
      signatures: ["(merge-with f m1 m2 ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "merge-with",
      divergences: nil
    },
    %{
      name: "min",
      description: "Minimum value",
      binding: :variadic_nonempty,
      category: :math,
      dispatch: :env,
      signatures: ["(min x y ...)"],
      since: nil,
      section: "Math Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "min",
      divergences: nil
    },
    %{
      name: "min-by",
      description: "Item with minimum field",
      binding: :collect,
      category: :core,
      dispatch: :env,
      signatures: ["(min-by f x)", "(min-by f x y & more)"],
      since: nil,
      section: "Core",
      ptc_extension?: true,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "min-by",
      divergences: nil
    },
    %{
      name: "min-key",
      description: "Return x for which (f x) is least",
      binding: :collect,
      category: :core,
      dispatch: :env,
      signatures: ["(min-key f x)", "(min-key f x y & more)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "min-key",
      divergences: nil
    },
    %{
      name: "mod",
      description: "Modulo (floored division, result sign matches divisor)",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(mod x y)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "mod",
      divergences: nil
    },
    %{
      name: "name",
      description: "Returns name string of keyword or string",
      binding: :normal,
      category: :string,
      dispatch: :env,
      signatures: ["(name x)"],
      since: nil,
      section: "String Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "name",
      divergences: nil
    },
    %{
      name: "nat-int?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(nat-int? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "nat-int?",
      divergences: nil
    },
    %{
      name: "neg-int?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(neg-int? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "neg-int?",
      divergences: nil
    },
    %{
      name: "neg?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(neg? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "neg?",
      divergences: nil
    },
    %{
      name: "next",
      description: "All but first (nil if none)",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(next coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "next",
      divergences: nil
    },
    %{
      name: "nfirst",
      description: "Next of first",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(nfirst coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "nfirst",
      divergences: nil
    },
    %{
      name: "nil?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(nil? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "nil?",
      divergences: nil
    },
    %{
      name: "nnext",
      description: "Next of next",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(nnext coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "nnext",
      divergences: nil
    },
    %{
      name: "not",
      description: "Logical NOT",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(not x)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "not",
      divergences: nil
    },
    %{
      name: "not-any?",
      description: "True if none have truthy `:key`",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(not-any? :key coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "not-any?",
      divergences: nil
    },
    %{
      name: "not-empty",
      description: "`coll` if not empty, else `nil`",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(not-empty coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "not-empty",
      divergences: nil
    },
    %{
      name: "not-every?",
      description: "True if not all have truthy `:key`",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(not-every? :key coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "not-every?",
      divergences: nil
    },
    %{
      name: "not=",
      description: "Inequality",
      binding: :collect,
      category: :core,
      dispatch: :env,
      signatures: ["(not= x)", "(not= x y & more)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "not=",
      divergences: nil
    },
    %{
      name: "nth",
      description: "Item at index or nil",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(nth coll idx)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "nth",
      divergences: nil
    },
    %{
      name: "number?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(number? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "number?",
      divergences: nil
    },
    %{
      name: "odd?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(odd? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "odd?",
      divergences:
        "GAP-S08: accepts whole-number floats (returns true/false) instead of raising IllegalArgumentException. Non-whole floats and non-numbers return false. See docs/clojure-conformance-gaps.md."
    },
    %{
      name: "parse",
      description:
        "Parse an ISO-8601 temporal string: `YYYY-MM-DD` → Date, a string with a time component (`...T...`) → DateTime (offsetless treated as UTC)",
      binding: :normal,
      category: :interop,
      dispatch: :env,
      signatures: [
        "(parse iso-string)",
        "(LocalDate/parse date-str)",
        "(java.time.LocalDate/parse date-str)",
        "(java.time.Instant/parse iso-string)",
        "(Instant/parse iso-string)"
      ],
      since: nil,
      section: "Interop",
      ptc_extension?: false,
      examples: [],
      notes:
        "Reachable as the bare `parse` builtin or via the `LocalDate/` and `Instant/` namespaces — all three dispatch on the string shape. `.isBefore`/`.isAfter`/`.getTime` work on both Date and DateTime results.",
      see_also: [".isBefore", ".isAfter", ".getTime", "java.util.Date."],
      clojure_var: "parse",
      divergences:
        "Unlike Java's LocalDate.parse, accepts strings with a time component and returns a DateTime instead of raising — more useful for LLM timestamp comparisons. See docs/java-interop.md."
    },
    %{
      name: "parse-boolean",
      description: "Parse string to boolean",
      binding: :normal,
      category: :string,
      dispatch: :env,
      signatures: ["(parse-boolean s)"],
      since: nil,
      section: "String Functions",
      ptc_extension?: false,
      examples: [
        {~S|(parse-boolean "true")|, "true"},
        {~S|(parse-boolean "false")|, "false"}
      ],
      notes:
        ~S|Returns nil for values other than "true" or "false". Also available as `Boolean/parseBoolean`.|,
      see_also: ["parse-long", "parse-double"],
      clojure_var: "parse-boolean",
      divergences:
        "DIV-18: returns nil on non-string input instead of raising IllegalArgumentException. Safer for LLM-generated code (no try/catch — DIV-10). See docs/clojure-conformance-gaps.md."
    },
    %{
      name: "parse-double",
      description: "",
      binding: :normal,
      category: :string,
      dispatch: :env,
      signatures: ["(parse-double ...)"],
      since: nil,
      section: "String Functions",
      ptc_extension?: false,
      examples: [],
      notes: "Also available as `Double/parseDouble` and `Float/parseFloat`.",
      see_also: [],
      clojure_var: "parse-double",
      divergences:
        "DIV-18: returns nil on non-string input instead of raising IllegalArgumentException. Safer for LLM-generated code (no try/catch — DIV-10). See docs/clojure-conformance-gaps.md."
    },
    %{
      name: "parse-int",
      description: "",
      binding: :normal,
      category: :string,
      dispatch: :env,
      signatures: ["(parse-int ...)"],
      since: nil,
      section: "String Functions",
      ptc_extension?: false,
      examples: [],
      notes:
        "Alias for `parse-long`; Java-shaped aliases are `Integer/parseInt` and `Long/parseLong`.",
      see_also: [],
      clojure_var: "parse-int",
      divergences: nil
    },
    %{
      name: "parse-long",
      description: "",
      binding: :normal,
      category: :string,
      dispatch: :env,
      signatures: ["(parse-long ...)"],
      since: nil,
      section: "String Functions",
      ptc_extension?: false,
      examples: [],
      notes: "Also available as `Integer/parseInt` and `Long/parseLong`.",
      see_also: [],
      clojure_var: "parse-long",
      divergences:
        "DIV-18: returns nil on non-string input instead of raising IllegalArgumentException. Safer for LLM-generated code (no try/catch — DIV-10). See docs/clojure-conformance-gaps.md."
    },
    %{
      name: "partial",
      description: "Returns a function with some arguments pre-filled",
      binding: :collect,
      category: :core,
      dispatch: :env,
      signatures: ["(partial f arg1 ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "partial",
      divergences: nil
    },
    %{
      name: "partition",
      description: "Sliding window with pad collection for incomplete groups",
      binding: :multi_arity,
      category: :core,
      dispatch: :env,
      signatures: ["(partition n coll)", "(partition n step coll)", "(partition n step pad coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "partition",
      divergences: nil
    },
    %{
      name: "partition-all",
      description: "Sliding window chunks (incomplete included)",
      binding: :multi_arity,
      category: :core,
      dispatch: :env,
      signatures: ["(partition-all n coll)", "(partition-all n step coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "partition-all",
      divergences: nil
    },
    %{
      name: "partition-by",
      description: "Partition when f's return value changes",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(partition-by f coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "partition-by",
      divergences: nil
    },
    %{
      name: "peek",
      description: "Return last element without removing",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(peek coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "peek",
      divergences: nil
    },
    %{
      name: "pop",
      description: "Return collection without last element",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(pop coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "pop",
      divergences: nil
    },
    %{
      name: "pos-int?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(pos-int? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "pos-int?",
      divergences: nil
    },
    %{
      name: "pos?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(pos? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "pos?",
      divergences: nil
    },
    %{
      name: "postwalk",
      description: "Transform tree bottom-up (post-order traversal)",
      binding: :normal,
      category: :walk,
      dispatch: :env,
      signatures: ["(postwalk f form)"],
      since: nil,
      section: "Core",
      ptc_extension?: true,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "postwalk",
      divergences: nil
    },
    %{
      name: "pow",
      description: "",
      binding: :normal,
      category: :math,
      dispatch: :env,
      signatures: ["(pow ...)"],
      since: nil,
      section: "Math Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "pow",
      divergences: nil
    },
    %{
      name: "pr-str",
      description:
        "Readable string representation (strings quoted, nil as \"nil\", space-separated)",
      binding: :collect,
      category: :string,
      dispatch: :env,
      signatures: ["(pr-str ...)"],
      since: nil,
      section: "String Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "pr-str",
      divergences: nil
    },
    %{
      name: "prewalk",
      description: "Transform tree top-down (pre-order traversal)",
      binding: :normal,
      category: :walk,
      dispatch: :env,
      signatures: ["(prewalk f form)"],
      since: nil,
      section: "Core",
      ptc_extension?: true,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "prewalk",
      divergences: nil
    },
    %{
      name: "println",
      description: "Prints arguments to the execution trace, separated by spaces. Returns `nil`.",
      binding: :special,
      category: :core,
      dispatch: :env,
      signatures: ["(println ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "println",
      divergences: nil
    },
    %{
      name: "quot",
      description: "Integer division (truncated toward zero)",
      binding: :normal,
      category: :math,
      dispatch: :env,
      signatures: ["(quot x y)"],
      since: nil,
      section: "Math Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "quot",
      divergences: nil
    },
    %{
      name: "range",
      description: "Returns sequence with specific step",
      binding: :multi_arity,
      category: :core,
      dispatch: :env,
      signatures: ["(range end)", "(range start end)", "(range start end step)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "range",
      divergences:
        "DIV-02: zero-arity (range) (infinite lazy seq) is not supported — bounds must be specified. PTC-Lisp has no lazy sequences. See docs/clojure-conformance-gaps.md."
    },
    %{
      name: "ratio?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(ratio? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "ratio?",
      divergences:
        "DIV-20: always returns false; BEAM has no ratio type. See docs/clojure-conformance-gaps.md."
    },
    %{
      name: "rational?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(rational? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "rational?",
      divergences:
        "DIV-20: returns true only for integers (BEAM has no ratio type, so the only BEAM rationals are integers). See docs/clojure-conformance-gaps.md."
    },
    %{
      name: "re-find",
      description: "Returns the first match of `re` in `s`",
      binding: :normal,
      category: :regex,
      dispatch: :env,
      signatures: ["(re-find re s)"],
      since: nil,
      section: "Regex Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "re-find",
      divergences: nil
    },
    %{
      name: "re-matches",
      description: "Returns match if `re` matches the **entire** string `s`",
      binding: :normal,
      category: :regex,
      dispatch: :env,
      signatures: ["(re-matches re s)"],
      since: nil,
      section: "Regex Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "re-matches",
      divergences: nil
    },
    %{
      name: "re-pattern",
      description: "Compile string `s` into an opaque regex object",
      binding: :normal,
      category: :regex,
      dispatch: :env,
      signatures: ["(re-pattern s)"],
      since: nil,
      section: "Regex Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "re-pattern",
      divergences: nil
    },
    %{
      name: "re-seq",
      description: "Returns all matches of `re` in `s` as a list",
      binding: :normal,
      category: :regex,
      dispatch: :env,
      signatures: ["(re-seq re s)"],
      since: nil,
      section: "Regex Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "re-seq",
      divergences: nil
    },
    %{
      name: "re-split",
      description: "Split string `s` by regex pattern `re`",
      binding: :normal,
      category: :regex,
      dispatch: :env,
      signatures: ["(re-split re s)"],
      since: nil,
      section: "Regex Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "re-split",
      divergences: nil
    },
    %{
      name: "reduce",
      description: "Fold collection",
      binding: :multi_arity,
      category: :core,
      dispatch: :env,
      signatures: ["(reduce f coll)", "(reduce f init coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "reduce",
      divergences: nil
    },
    %{
      name: "reduce-kv",
      description: "Reduce map with f receiving (acc, key, val)",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(reduce-kv f init m)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "reduce-kv",
      divergences: nil
    },
    %{
      name: "regex?",
      description: "Returns true if `x` is a regex object",
      binding: :normal,
      category: :regex,
      dispatch: :env,
      signatures: ["(regex? x)"],
      since: nil,
      section: "Regex Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "regex?",
      divergences: nil
    },
    %{
      name: "rem",
      description: "Remainder (truncated division, result sign matches dividend)",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(rem x y)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "rem",
      divergences: nil
    },
    %{
      name: "remove",
      description: "Remove items where pred is truthy",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(remove pred coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "remove",
      divergences: nil
    },
    %{
      name: "replace",
      description: "Replace all occurrences",
      binding: :normal,
      category: :string,
      dispatch: :env,
      signatures: ["(replace s pattern replacement)"],
      since: nil,
      section: "String Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "replace",
      divergences: nil
    },
    %{
      name: "rest",
      description: "All but first (empty list if none)",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(rest coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "rest",
      divergences: nil
    },
    %{
      name: "reverse",
      description: "Reverse order",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(reverse coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "reverse",
      divergences: nil
    },
    %{
      name: "reversible?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(reversible? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "reversible?",
      divergences: nil
    },
    %{
      name: "round",
      description: "Round to nearest integer",
      binding: :normal,
      category: :math,
      dispatch: :env,
      signatures: ["(round x)"],
      since: nil,
      section: "Math Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "round",
      divergences: nil
    },
    %{
      name: "second",
      description: "Second item or nil",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(second coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "second",
      divergences: nil
    },
    %{
      name: "select-keys",
      description: "Pick specific keys",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(select-keys m keys)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "select-keys",
      divergences: nil
    },
    %{
      name: "seq",
      description: "Convert to sequence (nil if empty)",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(seq coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "seq",
      divergences: nil
    },
    %{
      name: "seq?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(seq? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "seq?",
      divergences: nil
    },
    %{
      name: "seqable?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(seqable? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "seqable?",
      divergences: nil
    },
    %{
      name: "sequential?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(sequential? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "sequential?",
      divergences: nil
    },
    %{
      name: "set",
      description: "Convert collection to set",
      binding: :normal,
      category: :set,
      dispatch: :env,
      signatures: ["(set coll)"],
      since: nil,
      section: "Set Operations",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "set",
      divergences: nil
    },
    %{
      name: "hash-set",
      description: "Create set from arguments",
      binding: :collect,
      category: :set,
      dispatch: :env,
      signatures: ["(hash-set & items)"],
      since: nil,
      section: "Set Operations",
      ptc_extension?: false,
      examples: [
        {"(hash-set 1 1 2)", ~S|#{1 2}|}
      ],
      notes: "Constructs a PTC-Lisp set from variadic arguments.",
      see_also: ["set"],
      clojure_var: "hash-set",
      divergences: nil
    },
    %{
      name: "set?",
      description: "Returns true if x is a set",
      binding: :normal,
      category: :set,
      dispatch: :env,
      signatures: ["(set? x)"],
      since: nil,
      section: "Set Operations",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "set?",
      divergences: nil
    },
    %{
      name: "some",
      description: "First truthy `:key` value, or nil",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(some :key coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "some",
      divergences: nil
    },
    %{
      name: "some-fn",
      description: "Returns a function that returns the first truthy result from any fn",
      binding: :collect,
      category: :core,
      dispatch: :env,
      signatures: ["(some-fn f1 f2 ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "some-fn",
      divergences: nil
    },
    %{
      name: "some?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(some? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "some?",
      divergences: nil
    },
    %{
      name: "sort",
      description: "Sort by natural order",
      binding: :multi_arity,
      category: :core,
      dispatch: :env,
      signatures: ["(sort coll)", "(sort comparator coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "sort",
      divergences: nil
    },
    %{
      name: "sort-by",
      description: "Sort with comparator",
      binding: :multi_arity,
      category: :core,
      dispatch: :env,
      signatures: ["(sort-by keyfn coll)", "(sort-by keyfn comparator coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "sort-by",
      divergences: nil
    },
    %{
      name: "sorted?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(sorted? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "sorted?",
      divergences: nil
    },
    %{
      name: "split",
      description: "Split string by separator",
      binding: :normal,
      category: :string,
      dispatch: :env,
      signatures: ["(split s separator)"],
      since: nil,
      section: "String Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "split",
      divergences: nil
    },
    %{
      name: "split-at",
      description: "Split into `[(take n coll) (drop n coll)]`",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(split-at n coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "split-at",
      divergences: nil
    },
    %{
      name: "split-lines",
      description: "Split string into lines (\\n or \\r\\n)",
      binding: :normal,
      category: :string,
      dispatch: :env,
      signatures: ["(split-lines s)"],
      since: nil,
      section: "String Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "split-lines",
      divergences: nil
    },
    %{
      name: "split-with",
      description: "Split into `[(take-while pred coll) (drop-while pred coll)]`",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(split-with pred coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "split-with",
      divergences: nil
    },
    %{
      name: "sqrt",
      description: "",
      binding: :normal,
      category: :math,
      dispatch: :env,
      signatures: ["(sqrt ...)"],
      since: nil,
      section: "Math Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "sqrt",
      divergences: nil
    },
    %{
      name: "starts-with?",
      description: "Check if string starts with prefix",
      binding: :normal,
      category: :string,
      dispatch: :env,
      signatures: ["(starts-with? s prefix)"],
      since: nil,
      section: "String Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "starts-with?",
      divergences: nil
    },
    %{
      name: "str",
      description: "Convert and concatenate to string",
      binding: :collect,
      category: :string,
      dispatch: :env,
      signatures: ["(str ...)"],
      since: nil,
      section: "String Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "str",
      divergences: nil
    },
    %{
      name: "string?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(string? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "string?",
      divergences: nil
    },
    %{
      name: "subs",
      description: "Substring from start to end",
      binding: :multi_arity,
      category: :string,
      dispatch: :env,
      signatures: ["(subs s start)", "(subs s start end)"],
      since: nil,
      section: "String Functions",
      ptc_extension?: false,
      examples: [],
      notes:
        "Negative start returns \"\" (signal value, not whole string). Out-of-bounds end truncates. (subs s 0 100) on a short string returns the full string — the \"first N chars\" idiom is preserved.",
      see_also: [".substring", ".indexOf", "count"],
      clojure_var: "subs",
      divergences:
        "DIV-22: returns signal values (\"\") instead of raising on out-of-range indices. See docs/clojure-conformance-gaps.md."
    },
    %{
      name: "subvec",
      description: "",
      binding: :multi_arity,
      category: :core,
      dispatch: :env,
      signatures: ["(subvec v start)", "(subvec v start end)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "subvec",
      divergences: nil
    },
    %{
      name: "sum",
      description: "Sum of numbers",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(sum coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: true,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "sum",
      divergences: nil
    },
    %{
      name: "sum-by",
      description: "Sum field values",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(sum-by key coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: true,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "sum-by",
      divergences: nil
    },
    %{
      name: "symbol?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(symbol? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "symbol?",
      divergences:
        "DIV-19: always returns false; PTC-Lisp has no symbol type — keywords cover all identifier needs. See docs/clojure-conformance-gaps.md."
    },
    %{
      name: "take",
      description: "First n items",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(take n coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "take",
      divergences: nil
    },
    %{
      name: "take-last",
      description: "Last n items",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(take-last n coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "take-last",
      divergences: nil
    },
    %{
      name: "take-while",
      description: "Take while pred is true",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(take-while pred coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "take-while",
      divergences: nil
    },
    %{
      name: "tree-seq",
      description: "Flatten tree to depth-first sequence",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(tree-seq branch? children root)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "tree-seq",
      divergences: nil
    },
    %{
      name: "trim",
      description: "Remove leading/trailing whitespace",
      binding: :normal,
      category: :string,
      dispatch: :env,
      signatures: ["(trim s)"],
      since: nil,
      section: "String Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "trim",
      divergences: nil
    },
    %{
      name: "trim-newline",
      description: "Remove trailing newline or carriage return characters",
      binding: :normal,
      category: :string,
      dispatch: :env,
      signatures: ["(trim-newline s)"],
      since: nil,
      section: "String Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "trim-newline",
      divergences: nil
    },
    %{
      name: "triml",
      description: "Remove leading whitespace",
      binding: :normal,
      category: :string,
      dispatch: :env,
      signatures: ["(triml s)"],
      since: nil,
      section: "String Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "triml",
      divergences: nil
    },
    %{
      name: "trimr",
      description: "Remove trailing whitespace",
      binding: :normal,
      category: :string,
      dispatch: :env,
      signatures: ["(trimr s)"],
      since: nil,
      section: "String Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "trimr",
      divergences: nil
    },
    %{
      name: "true?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(true? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "true?",
      divergences: nil
    },
    %{
      name: "trunc",
      description: "",
      binding: :normal,
      category: :math,
      dispatch: :env,
      signatures: ["(trunc ...)"],
      since: nil,
      section: "Math Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "trunc",
      divergences: nil
    },
    %{
      name: "type",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(type ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "type",
      divergences: nil
    },
    %{
      name: "union",
      description: "Returns the union of zero or more sets",
      binding: :variadic,
      category: :set,
      dispatch: :env,
      signatures: ["(clojure.set/union & sets)"],
      since: nil,
      section: "Set Operations",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "union",
      divergences: nil
    },
    %{
      name: "upcase",
      description: "",
      binding: :normal,
      category: :string,
      dispatch: :env,
      signatures: ["(upcase ...)"],
      since: nil,
      section: "String Functions",
      ptc_extension?: true,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "upcase",
      divergences: nil
    },
    %{
      name: "update",
      description: "Update with extra args passed to f",
      binding: :collect,
      category: :core,
      dispatch: :env,
      signatures: ["(update m key f & args)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "update",
      divergences: nil
    },
    %{
      name: "update-in",
      description: "Update nested with extra args",
      binding: :collect,
      category: :core,
      dispatch: :env,
      signatures: ["(update-in m path f & args)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "update-in",
      divergences: nil
    },
    %{
      name: "update-keys",
      description: "Apply f to each key (collision: retained value unspecified)",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(update-keys m f)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "update-keys",
      divergences: nil
    },
    %{
      name: "update-vals",
      description: "Apply f to each value (matches Clojure 1.11)",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(update-vals m f)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "update-vals",
      divergences: nil
    },
    %{
      name: "upper-case",
      description: "",
      binding: :normal,
      category: :string,
      dispatch: :env,
      signatures: ["(upper-case ...)"],
      since: nil,
      section: "String Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "upper-case",
      divergences: nil
    },
    %{
      name: "val",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(val ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "val",
      divergences: nil
    },
    %{
      name: "vals",
      description: "Get all values",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(vals m)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "vals",
      divergences: nil
    },
    %{
      name: "vec",
      description: "Convert collection to vector",
      binding: :normal,
      category: :set,
      dispatch: :env,
      signatures: ["(vec coll)"],
      since: nil,
      section: "Set Operations",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "vec",
      divergences: nil
    },
    %{
      name: "vector",
      description: "Create vector from arguments",
      binding: :collect,
      category: :set,
      dispatch: :env,
      signatures: ["(vector & args)"],
      since: nil,
      section: "Set Operations",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "vector",
      divergences: nil
    },
    %{
      name: "hash-map",
      description: "Create map from alternating key-value pairs",
      binding: :collect,
      category: :core,
      dispatch: :env,
      signatures: ["(hash-map & kvs)"],
      since: "0.9.0",
      section: "Core",
      ptc_extension?: false,
      examples: [
        {"(hash-map)", "%{}"},
        {"(hash-map :a 1 :b 2)", "{:a 1, :b 2}"}
      ],
      notes: "Requires an even number of arguments. Equivalent to map literal `{:a 1 :b 2}`.",
      see_also: ["assoc", "zipmap"],
      clojure_var: "hash-map",
      divergences: nil
    },
    %{
      name: "array-map",
      description: "Create map from alternating key-value pairs",
      binding: :collect,
      category: :core,
      dispatch: :env,
      signatures: ["(array-map & kvs)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [
        {"(array-map)", "%{}"},
        {"(array-map :a 1 :b 2)", "{:a 1, :b 2}"}
      ],
      notes:
        "Alias for `hash-map`; PTC-Lisp does not expose Clojure's small-map implementation detail.",
      see_also: ["hash-map"],
      clojure_var: "array-map",
      divergences: nil
    },
    %{
      name: "vector?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(vector? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "vector?",
      divergences: nil
    },
    %{
      name: "walk",
      description: "Generic tree walker - applies inner to children, outer to result",
      binding: :normal,
      category: :walk,
      dispatch: :env,
      signatures: ["(walk inner outer form)"],
      since: nil,
      section: "Core",
      ptc_extension?: true,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "walk",
      divergences: nil
    },
    %{
      name: "zero?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(zero? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "zero?",
      divergences: nil
    },
    %{
      name: "zip",
      description: "Combine into pairs",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(zip c1 c2)"],
      since: nil,
      section: "Core",
      ptc_extension?: true,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "zip",
      divergences: nil
    },
    %{
      name: "zipmap",
      description: "Create map from keys and values seqs",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(zipmap keys vals)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "zipmap",
      divergences: nil
    },
    %{
      name: "->",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(-> ...)"],
      since: nil,
      section: "Threading Macros",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "->",
      divergences: nil
    },
    %{
      name: "->>",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(->> ...)"],
      since: nil,
      section: "Threading Macros",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "->>",
      divergences: nil
    },
    %{
      name: "and",
      description: "Logical AND (short-circuits)",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(and x y ...)"],
      since: nil,
      section: "Control Flow",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "and",
      divergences: nil
    },
    %{
      name: "apropos",
      description: "Search loaded REPL discovery backends",
      binding: nil,
      category: :mcp,
      dispatch: :analyze,
      signatures: ["(apropos query)", "(apropos query opts)"],
      since: nil,
      section: "Discovery",
      ptc_extension?: true,
      examples: [],
      notes: "MCP-backed in aggregator mode; searches loaded discovery backends.",
      see_also: ["dir", "doc", "meta", "mcp/servers"],
      clojure_var: "apropos",
      divergences: nil
    },
    %{
      name: "as->",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(as-> ...)"],
      since: nil,
      section: "Threading Macros",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "as->",
      divergences: nil
    },
    %{
      name: "case",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(case ...)"],
      since: nil,
      section: "Conditionals",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "case",
      divergences: nil
    },
    %{
      name: "comment",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(comment ...)"],
      since: nil,
      section: "Control Flow",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "comment",
      divergences: nil
    },
    %{
      name: "cond",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(cond ...)"],
      since: nil,
      section: "Conditionals",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "cond",
      divergences: nil
    },
    %{
      name: "cond->",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(cond-> ...)"],
      since: nil,
      section: "Threading Macros",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "cond->",
      divergences: nil
    },
    %{
      name: "cond->>",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(cond->> ...)"],
      since: nil,
      section: "Threading Macros",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "cond->>",
      divergences: nil
    },
    %{
      name: "condp",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(condp ...)"],
      since: nil,
      section: "Conditionals",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "condp",
      divergences: nil
    },
    %{
      name: "def",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(def ...)"],
      since: nil,
      section: "Definitions & Bindings",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "def",
      divergences: nil
    },
    %{
      name: "defn",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(defn ...)"],
      since: nil,
      section: "Definitions & Bindings",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "defn",
      divergences:
        "DIV-01: self-recursion is subject to the iteration cap (default 1000, configurable up to 10000). DIV-15: no multi-arity head form ([x] x ([x y] ...)). DIV-16: no :pre/:post conditions. See docs/clojure-conformance-gaps.md."
    },
    %{
      name: "defonce",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(defonce ...)"],
      since: nil,
      section: "Definitions & Bindings",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "defonce",
      divergences: nil
    },
    %{
      name: "dir",
      description: "List members of a REPL discovery reference",
      binding: nil,
      category: :mcp,
      dispatch: :analyze,
      signatures: ["(dir server)", "(dir server opts)"],
      since: nil,
      section: "Discovery",
      ptc_extension?: true,
      examples: [],
      notes: "MCP-backed in aggregator mode; accepts quoted symbols or strings.",
      see_also: ["apropos", "doc", "meta", "mcp/servers"],
      clojure_var: "dir",
      divergences: nil
    },
    %{
      name: "do",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(do ...)"],
      since: nil,
      section: "Control Flow",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "do",
      divergences: nil
    },
    %{
      name: "doc",
      description: "Return human-readable documentation for a REPL discovery reference",
      binding: nil,
      category: :mcp,
      dispatch: :analyze,
      signatures: ["(doc tool-ref)"],
      since: nil,
      section: "Discovery",
      ptc_extension?: true,
      examples: [],
      notes:
        "MCP-backed in aggregator mode; accepts tool refs like 'github/search or \"github/search\".",
      see_also: ["apropos", "dir", "meta"],
      clojure_var: "doc",
      divergences: nil
    },
    %{
      name: "doseq",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(doseq ...)"],
      since: nil,
      section: "Iteration",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "doseq",
      divergences: nil
    },
    %{
      name: "fail",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(fail ...)"],
      since: nil,
      section: "Agent Control",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "fail",
      divergences: nil
    },
    %{
      name: "fn",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(fn ...)"],
      since: nil,
      section: "Definitions & Bindings",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "fn",
      divergences: nil
    },
    %{
      name: "for",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(for ...)"],
      since: nil,
      section: "Iteration",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "for",
      divergences: nil
    },
    %{
      name: "if",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(if ...)"],
      since: nil,
      section: "Conditionals",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "if",
      divergences: nil
    },
    %{
      name: "if-let",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(if-let ...)"],
      since: nil,
      section: "Conditionals",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "if-let",
      divergences:
        "DIV-14: only single-symbol bindings supported, no destructuring. See docs/clojure-conformance-gaps.md."
    },
    %{
      name: "if-not",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(if-not ...)"],
      since: nil,
      section: "Conditionals",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "if-not",
      divergences: nil
    },
    %{
      name: "if-some",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(if-some ...)"],
      since: nil,
      section: "Conditionals",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "if-some",
      divergences: nil
    },
    %{
      name: "juxt",
      description:
        "Returns a function that applies all functions and returns a vector of results",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(juxt f1 f2 ...)"],
      since: nil,
      section: "Functional Tools",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "juxt",
      divergences: nil
    },
    %{
      name: "let",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(let ...)"],
      since: nil,
      section: "Definitions & Bindings",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "let",
      divergences: nil
    },
    %{
      name: "loop",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(loop ...)"],
      since: nil,
      section: "Definitions & Bindings",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "loop",
      divergences:
        "DIV-01: enforces a 1000-iteration default cap (configurable up to 10000) for sandbox safety. See docs/clojure-conformance-gaps.md."
    },
    %{
      name: "meta",
      description: "Return structured metadata for a REPL discovery reference",
      binding: nil,
      category: :mcp,
      dispatch: :analyze,
      signatures: ["(meta tool-ref)"],
      since: nil,
      section: "Discovery",
      ptc_extension?: true,
      examples: [],
      notes:
        "MCP-backed in aggregator mode; accepts tool refs like 'github/search or \"github/search\".",
      see_also: ["doc", "dir", "apropos"],
      clojure_var: "meta",
      divergences: nil
    },
    %{
      name: "mcp/servers",
      description: "List configured upstream MCP servers",
      binding: nil,
      category: :mcp,
      dispatch: :analyze,
      signatures: ["(mcp/servers)"],
      since: nil,
      section: "Discovery",
      ptc_extension?: true,
      examples: [],
      notes:
        "MCP-backed in aggregator mode; returns server names, descriptions, tool counts, and load status.",
      see_also: ["apropos", "dir", "doc", "meta"],
      clojure_var: nil,
      divergences: nil
    },
    %{
      name: "ns-publics",
      description: "Return public vars for a local PTC/Clojure namespace",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(ns-publics namespace)"],
      since: nil,
      section: "Discovery",
      ptc_extension?: false,
      examples: [],
      notes: "Local namespace discovery only; Java classes and MCP servers are not supported.",
      see_also: ["dir", "doc", "meta", "apropos"],
      clojure_var: "ns-publics",
      divergences: nil
    },
    %{
      name: "or",
      description: "Logical OR (short-circuits)",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(or x y ...)"],
      since: nil,
      section: "Control Flow",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "or",
      divergences: nil
    },
    %{
      name: "pcalls",
      description: "Execute thunks in parallel",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(pcalls f1 f2 ...)"],
      since: nil,
      section: "Functional Tools",
      ptc_extension?: true,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "pcalls",
      divergences: nil
    },
    %{
      name: "pmap",
      description: "Apply f to each item in parallel",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(pmap f coll)"],
      since: nil,
      section: "Functional Tools",
      ptc_extension?: true,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "pmap",
      divergences: nil
    },
    %{
      name: "quote",
      description: "Return a symbolic reference without resolving it",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(quote symbol)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: "Only symbols are supported in this phase; quoted collections remain unsupported.",
      see_also: ["dir", "doc", "meta"],
      clojure_var: "quote",
      divergences:
        "DIV: quoted lists, vectors, maps, sets, syntax quote, unquote, and reader metadata are not supported."
    },
    %{
      name: "recur",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(recur ...)"],
      since: nil,
      section: "Definitions & Bindings",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "recur",
      divergences:
        "DIV-01: enforces a 1000-iteration default cap (configurable up to 10000) for sandbox safety. See docs/clojure-conformance-gaps.md."
    },
    %{
      name: "return",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(return ...)"],
      since: nil,
      section: "Agent Control",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "return",
      divergences: nil
    },
    %{
      name: "some->",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(some-> ...)"],
      since: nil,
      section: "Threading Macros",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "some->",
      divergences: nil
    },
    %{
      name: "some->>",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(some->> ...)"],
      since: nil,
      section: "Threading Macros",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "some->>",
      divergences: nil
    },
    %{
      name: "step-done",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(step-done ...)"],
      since: nil,
      section: "Agent Control",
      ptc_extension?: true,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: nil,
      divergences: nil
    },
    %{
      name: "task",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(task ...)"],
      since: nil,
      section: "Agent Control",
      ptc_extension?: true,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: nil,
      divergences: nil
    },
    %{
      name: "task-reset",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(task-reset ...)"],
      since: nil,
      section: "Agent Control",
      ptc_extension?: true,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: nil,
      divergences: nil
    },
    %{
      name: "when",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(when ...)"],
      since: nil,
      section: "Conditionals",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "when",
      divergences: nil
    },
    %{
      name: "when-first",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(when-first ...)"],
      since: nil,
      section: "Conditionals",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "when-first",
      divergences: nil
    },
    %{
      name: "when-let",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(when-let ...)"],
      since: nil,
      section: "Conditionals",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "when-let",
      divergences:
        "DIV-14: only single-symbol bindings supported, no destructuring. See docs/clojure-conformance-gaps.md."
    },
    %{
      name: "when-not",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(when-not ...)"],
      since: nil,
      section: "Conditionals",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "when-not",
      divergences: nil
    },
    %{
      name: "when-some",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(when-some ...)"],
      since: nil,
      section: "Conditionals",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "when-some",
      divergences: nil
    }
  ],
  java_interop: [
    %{
      name: "java.util.Date.",
      class: "java.util.Date",
      kind: :constructor,
      description:
        "Construct current UTC time, from a timestamp / ISO-8601 / RFC-2822 string, or pass through an existing temporal value",
      signatures: [
        "(java.util.Date.)",
        "(java.util.Date. timestamp-or-string)",
        "(java.util.Date. datetime-or-date)"
      ],
      notes:
        "Returns Elixir DateTime. Accepts integer (seconds or ms auto-detected), ISO-8601 (with or without offset — offsetless is treated as UTC), RFC 2822, or an existing DateTime/NaiveDateTime/Date (Date and NaiveDateTime upgrade to UTC; DateTime returns as-is). Time alone is not accepted (no date component)."
    },
    %{
      name: ".getTime",
      class: "java.util.Date",
      kind: :method,
      description: "Return Unix timestamp in milliseconds from DateTime",
      signatures: ["(.getTime date)"],
      notes: ""
    },
    %{
      name: ".toEpochDay",
      class: "java.time.LocalDate",
      kind: :method,
      description: "Return LocalDate epoch-day integer",
      signatures: ["(.toEpochDay local-date)"],
      notes: "Works on LocalDate values returned by `LocalDate/parse`."
    },
    %{
      name: ".plusDays",
      class: "java.time.LocalDate",
      kind: :method,
      description: "Add days to a LocalDate",
      signatures: ["(.plusDays local-date n)"],
      notes: "`n` must be an integer."
    },
    %{
      name: ".minusDays",
      class: "java.time.LocalDate",
      kind: :method,
      description: "Subtract days from a LocalDate",
      signatures: ["(.minusDays local-date n)"],
      notes: "`n` must be an integer."
    },
    %{
      name: ".toMillis",
      class: "java.time.Duration",
      kind: :method,
      description: "Return duration length in milliseconds",
      signatures: ["(.toMillis duration)"],
      notes: "Works on Duration values returned by `Duration/between`."
    },
    %{
      name: ".toDays",
      class: "java.time.Duration",
      kind: :method,
      description: "Return duration length in whole days",
      signatures: ["(.toDays duration)"],
      notes: "Partial days truncate toward zero."
    },
    %{
      name: ".isBefore",
      class: "java.time.LocalDate / java.util.Date",
      kind: :method,
      description: "Returns true if receiver comes strictly before argument (same-type only)",
      signatures: ["(.isBefore a b)"],
      notes: "Works on both LocalDate and DateTime. Mixed types raise an error."
    },
    %{
      name: ".isAfter",
      class: "java.time.LocalDate / java.util.Date",
      kind: :method,
      description: "Returns true if receiver comes strictly after argument (same-type only)",
      signatures: ["(.isAfter a b)"],
      notes: "Works on both LocalDate and DateTime. Mixed types raise an error."
    },
    %{
      name: "LocalDate/parse",
      class: "java.time.LocalDate",
      kind: :static,
      description: "Parse an ISO-8601 date string (YYYY-MM-DD) to a Date",
      signatures: [
        "(LocalDate/parse date-string)",
        "(java.time.LocalDate/parse date-string)",
        "(parse date-string)"
      ],
      notes:
        "Returns an Elixir Date for `YYYY-MM-DD`. If the string carries a time component (`...T...`) it returns a DateTime instead (see `Instant/parse`) — a divergence from Java's strict `LocalDate.parse`. Also available as the bare `parse` builtin."
    },
    %{
      name: "Instant/parse",
      class: "java.time.Instant",
      kind: :static,
      description: "Parse an ISO-8601 instant/date-time string to a DateTime",
      signatures: [
        "(Instant/parse iso-string)",
        "(java.time.Instant/parse iso-string)",
        "(parse iso-string)"
      ],
      notes:
        "Returns an Elixir DateTime. Accepts an offset (`Z`, `+02:00`, …); an offsetless `...T...` string is treated as UTC. `.isBefore` / `.isAfter` / `.getTime` work on the result. A bare `YYYY-MM-DD` string returns a Date instead (see `LocalDate/parse`). Also available as the bare `parse` builtin."
    },
    %{
      name: "Duration/between",
      class: "java.time.Duration",
      kind: :static,
      description: "Return a Duration between two DateTime instants",
      signatures: [
        "(Duration/between start-instant end-instant)",
        "(java.time.Duration/between start-instant end-instant)"
      ],
      notes:
        "Requires DateTime values, such as results from `Instant/parse`; LocalDate values are intentionally rejected."
    },
    %{
      name: "System/currentTimeMillis",
      class: "java.lang.System",
      kind: :static,
      description: "Return current time in milliseconds since Unix epoch",
      signatures: ["(System/currentTimeMillis)", "(currentTimeMillis)"],
      notes: ""
    },
    %{
      name: "Boolean/parseBoolean",
      class: "java.lang.Boolean",
      kind: :static,
      description: "Parse \"true\"/\"false\" to boolean",
      signatures: ["(Boolean/parseBoolean s)"],
      notes:
        "Compatibility alias for `(parse-boolean s)`. Invalid or non-string input returns nil instead of Java's false/throwing behavior."
    },
    %{
      name: "Double/POSITIVE_INFINITY",
      class: "java.lang.Double",
      kind: :constant,
      description: "Positive infinity constant (##Inf)",
      signatures: ["Double/POSITIVE_INFINITY", "POSITIVE_INFINITY"],
      notes: ""
    },
    %{
      name: "Double/parseDouble",
      class: "java.lang.Double",
      kind: :static,
      description: "Parse string to double",
      signatures: ["(Double/parseDouble s)"],
      notes:
        "Compatibility alias for `(parse-double s)`. Invalid or non-string input returns nil instead of throwing."
    },
    %{
      name: "Double/NEGATIVE_INFINITY",
      class: "java.lang.Double",
      kind: :constant,
      description: "Negative infinity constant (##-Inf)",
      signatures: ["Double/NEGATIVE_INFINITY", "NEGATIVE_INFINITY"],
      notes: ""
    },
    %{
      name: "Double/NaN",
      class: "java.lang.Double",
      kind: :constant,
      description: "Not-a-Number constant (##NaN)",
      signatures: ["Double/NaN", "NaN"],
      notes: ""
    },
    %{
      name: "Float/parseFloat",
      class: "java.lang.Float",
      kind: :static,
      description: "Parse string to float",
      signatures: ["(Float/parseFloat s)"],
      notes:
        "Compatibility alias for `(parse-double s)`; PTC-Lisp uses one floating type. Invalid or non-string input returns nil instead of throwing."
    },
    %{
      name: "Integer/parseInt",
      class: "java.lang.Integer",
      kind: :static,
      description: "Parse string to integer",
      signatures: ["(Integer/parseInt s)"],
      notes:
        "Compatibility alias for `(parse-long s)`. Invalid or non-string input returns nil instead of throwing."
    },
    %{
      name: "Long/parseLong",
      class: "java.lang.Long",
      kind: :static,
      description: "Parse string to integer",
      signatures: ["(Long/parseLong s)"],
      notes:
        "Compatibility alias for `(parse-long s)`. Invalid or non-string input returns nil instead of throwing."
    },
    %{
      name: ".contains",
      class: "java.lang.String",
      kind: :method,
      description: "Returns true if string contains substring",
      signatures: ["(.contains s substr)"],
      notes: ""
    },
    %{
      name: ".indexOf",
      class: "java.lang.String",
      kind: :method,
      description: "Index of first occurrence of substring, or -1 if not found",
      signatures: ["(.indexOf s substr)", "(.indexOf s substr from-index)"],
      notes: "Uses grapheme indices (not byte offsets)."
    },
    %{
      name: ".lastIndexOf",
      class: "java.lang.String",
      kind: :method,
      description: "Index of last occurrence of substring, or -1 if not found",
      signatures: ["(.lastIndexOf s substr)"],
      notes: "Uses grapheme indices (not byte offsets)."
    },
    %{
      name: ".toLowerCase",
      class: "java.lang.String",
      kind: :method,
      description: "Convert string to lower case",
      signatures: ["(.toLowerCase s)"],
      notes: ""
    },
    %{
      name: ".toUpperCase",
      class: "java.lang.String",
      kind: :method,
      description: "Convert string to upper case",
      signatures: ["(.toUpperCase s)"],
      notes: ""
    },
    %{
      name: ".startsWith",
      class: "java.lang.String",
      kind: :method,
      description: "Returns true if string starts with prefix",
      signatures: ["(.startsWith s prefix)"],
      notes: ""
    },
    %{
      name: ".endsWith",
      class: "java.lang.String",
      kind: :method,
      description: "Returns true if string ends with suffix",
      signatures: ["(.endsWith s suffix)"],
      notes: ""
    },
    %{
      name: ".length",
      class: "java.lang.String",
      kind: :method,
      description: "Return the grapheme count of a string",
      signatures: ["(.length s)"],
      notes:
        "Returns grapheme count (not byte length), matching `count` and `.indexOf` index semantics."
    },
    %{
      name: ".substring",
      class: "java.lang.String",
      kind: :method,
      description: "Extract a substring by grapheme index",
      signatures: ["(.substring s start)", "(.substring s start end)"],
      notes:
        "Indices are grapheme-based (not byte offsets). Two-arg form returns graphemes in [start, end). Raises on out-of-range indices (matches Java's StringIndexOutOfBoundsException) — note that (.substring s -1) raises rather than silently returning the last grapheme, which matters when chaining .indexOf."
    }
  ]
}