@enjoys/context-engine 1.1.1 → 1.2.0

package/data/definition/julia.json

@@ -0,0 +1,232 @@
+{
+  "language": "julia",
+  "definitions": {
+    "Array": {
+      "signature": "Array{T,N}(undef, dims...)",
+      "description": "The fundamental multidimensional container type parameterized by element type T and dimensionality N. Arrays in Julia are column-major, mutable, and support broadcasting, comprehensions, and high-performance linear algebra operations through BLAS integration.",
+      "type": "class",
+      "module": "Base",
+      "members": {
+        "push!": {
+          "signature": "push!(collection, items...) -> collection",
+          "description": "Appends one or more items to the end of the collection, mutating it in place and returning it.",
+          "type": "method"
+        },
+        "pop!": {
+          "signature": "pop!(collection) -> item",
+          "description": "Removes and returns the last element from the collection.",
+          "type": "method"
+        },
+        "length": {
+          "signature": "length(collection) -> Int",
+          "description": "Returns the total number of elements in the collection.",
+          "type": "method"
+        },
+        "size": {
+          "signature": "size(A, [dim]) -> Tuple or Int",
+          "description": "Returns a tuple of dimensions of array A, or the size along a specific dimension if dim is given.",
+          "type": "method"
+        },
+        "sort!": {
+          "signature": "sort!(v; alg=defalg, lt=isless, by=identity, rev=false) -> v",
+          "description": "Sorts the vector v in place using the specified algorithm and comparison functions.",
+          "type": "method"
+        },
+        "filter": {
+          "signature": "filter(f, a) -> Array",
+          "description": "Returns a new array containing only the elements of a for which function f returns true.",
+          "type": "method"
+        },
+        "map": {
+          "signature": "map(f, c...) -> Array",
+          "description": "Transforms each element by applying function f, returning a new collection of results.",
+          "type": "method"
+        },
+        "reshape": {
+          "signature": "reshape(A, dims...) -> AbstractArray",
+          "description": "Returns an array with the same data as A but with different dimensions specified by dims.",
+          "type": "method"
+        }
+      }
+    },
+    "Dict": {
+      "signature": "Dict{K,V}(pairs...)",
+      "description": "A hash-table-based dictionary mapping keys of type K to values of type V. Supports iteration over key-value pairs, efficient lookup, insertion, and deletion. Dict is the standard mutable associative container in Julia's Base library.",
+      "type": "class",
+      "module": "Base",
+      "members": {
+        "get": {
+          "signature": "get(collection, key, default) -> value",
+          "description": "Returns the value for key if it exists in the collection, otherwise returns the default value.",
+          "type": "method"
+        },
+        "haskey": {
+          "signature": "haskey(collection, key) -> Bool",
+          "description": "Determines whether the collection has a mapping for the given key, returning true or false.",
+          "type": "method"
+        },
+        "keys": {
+          "signature": "keys(dict) -> KeySet",
+          "description": "Returns an iterator over all keys in the dictionary.",
+          "type": "method"
+        },
+        "values": {
+          "signature": "values(dict) -> ValueIterator",
+          "description": "Returns an iterator over all values in the dictionary.",
+          "type": "method"
+        },
+        "delete!": {
+          "signature": "delete!(collection, key) -> collection",
+          "description": "Deletes the mapping for the given key from the collection and returns the modified collection.",
+          "type": "method"
+        },
+        "merge": {
+          "signature": "merge(d1, d2...) -> Dict",
+          "description": "Constructs a merged dictionary from the given dictionaries, with later values overwriting earlier ones for duplicate keys.",
+          "type": "method"
+        }
+      }
+    },
+    "String": {
+      "signature": "String(data::AbstractVector{UInt8})",
+      "description": "An immutable UTF-8 encoded string type. Strings in Julia support Unicode natively, are indexed by byte position (not character index), and provide extensive pattern matching, interpolation with $ syntax, and conversion utilities.",
+      "type": "class",
+      "module": "Base",
+      "members": {
+        "occursin": {
+          "signature": "occursin(needle, haystack) -> Bool",
+          "description": "Determines whether the first argument is a substring of the second, supporting both string and regex patterns.",
+          "type": "method"
+        },
+        "replace": {
+          "signature": "replace(s, pat => r; count=typemax(Int)) -> String",
+          "description": "Returns a new string with occurrences of pat replaced by r, optionally limiting the number of replacements.",
+          "type": "method"
+        },
+        "split": {
+          "signature": "split(str, dlm; limit=0, keepempty=true) -> Vector{SubString}",
+          "description": "Splits the string at each occurrence of the delimiter and returns a vector of substrings.",
+          "type": "method"
+        },
+        "join": {
+          "signature": "join(strings, delim=\"\") -> String",
+          "description": "Concatenates an iterable collection of strings with the given delimiter between elements.",
+          "type": "method"
+        },
+        "strip": {
+          "signature": "strip(s::AbstractString, [chars]) -> SubString",
+          "description": "Removes leading and trailing whitespace or specified characters from the string.",
+          "type": "method"
+        }
+      }
+    },
+    "Tuple": {
+      "signature": "Tuple{T1, T2, ...}",
+      "description": "An immutable, fixed-size, ordered collection of elements, each potentially having a different type. Tuples are used extensively for multiple return values, function argument packing, and as dictionary keys due to their immutability and efficient memory layout.",
+      "type": "class",
+      "module": "Base",
+      "members": {
+        "length": {
+          "signature": "length(t::Tuple) -> Int",
+          "description": "Returns the number of elements in the tuple.",
+          "type": "method"
+        },
+        "first": {
+          "signature": "first(t::Tuple) -> element",
+          "description": "Returns the first element of the tuple.",
+          "type": "method"
+        },
+        "last": {
+          "signature": "last(t::Tuple) -> element",
+          "description": "Returns the last element of the tuple.",
+          "type": "method"
+        }
+      }
+    },
+    "Set": {
+      "signature": "Set{T}(itr)",
+      "description": "An unordered collection of unique elements of type T, backed by a Dict. Sets support standard mathematical operations including union, intersection, difference, and symmetric difference, as well as membership testing with the in operator.",
+      "type": "class",
+      "module": "Base",
+      "members": {
+        "union": {
+          "signature": "union(s, itrs...) -> Set",
+          "description": "Constructs the union of sets, containing all elements that appear in any of the arguments.",
+          "type": "method"
+        },
+        "intersect": {
+          "signature": "intersect(s, itrs...) -> Set",
+          "description": "Constructs the intersection of sets, containing only elements common to all arguments.",
+          "type": "method"
+        },
+        "setdiff": {
+          "signature": "setdiff(s, itrs...) -> Set",
+          "description": "Constructs the set of elements in s but not in any of the other iterables.",
+          "type": "method"
+        },
+        "issubset": {
+          "signature": "issubset(a, b) -> Bool",
+          "description": "Determines whether every element of a is also in b.",
+          "type": "method"
+        },
+        "push!": {
+          "signature": "push!(s::Set, x) -> Set",
+          "description": "Adds element x to the set, mutating it in place.",
+          "type": "method"
+        }
+      }
+    },
+    "println": {
+      "signature": "println([io::IO], xs...)",
+      "description": "Prints the textual representation of the arguments to the output stream (defaulting to stdout), followed by a newline character. Each argument is converted to a string via the show function. Multiple arguments are printed consecutively without separators.",
+      "type": "function",
+      "module": "Base"
+    },
+    "typeof": {
+      "signature": "typeof(x) -> DataType",
+      "description": "Returns the concrete type of the value x. This is the leaf type in Julia's type hierarchy and is used for method dispatch, type assertions, and runtime introspection. Combined with supertypes, it reveals the full type ancestry.",
+      "type": "function",
+      "module": "Base"
+    },
+    "struct": {
+      "signature": "struct TypeName fields... end | mutable struct TypeName fields... end",
+      "description": "Declares a composite type with named fields. Immutable structs (the default) are stack-allocated and more efficiently optimized by the compiler. Mutable structs are heap-allocated and allow field reassignment. Both support constructors, type parameters, and abstract supertype declarations.",
+      "type": "keyword",
+      "module": "Base"
+    },
+    "function": {
+      "signature": "function name(args...)::ReturnType body end",
+      "description": "Defines a named function with typed or untyped arguments, optional return type annotation, and a body block. Julia functions support multiple dispatch — defining multiple methods with different argument type signatures that are selected at call time based on the types of all arguments.",
+      "type": "keyword",
+      "module": "Base"
+    },
+    "Channel": {
+      "signature": "Channel{T}(size::Int=0)",
+      "description": "A typed concurrent communication primitive used for passing messages between asynchronous tasks. Channels can be buffered (with a specified size) or unbuffered, and support put!/take! operations for producer-consumer patterns in Julia's cooperative multitasking model.",
+      "type": "class",
+      "module": "Base",
+      "members": {
+        "put!": {
+          "signature": "put!(c::Channel, v) -> Channel",
+          "description": "Appends a value to the channel, blocking if the channel buffer is full until space is available.",
+          "type": "method"
+        },
+        "take!": {
+          "signature": "take!(c::Channel) -> value",
+          "description": "Removes and returns a value from the channel, blocking if empty until a value is available.",
+          "type": "method"
+        },
+        "close": {
+          "signature": "close(c::Channel) -> nothing",
+          "description": "Closes the channel so that no more values can be put into it; existing values can still be taken.",
+          "type": "method"
+        },
+        "isopen": {
+          "signature": "isopen(c::Channel) -> Bool",
+          "description": "Determines whether the channel is still open for putting new values.",
+          "type": "method"
+        }
+      }
+    }
+  }
+}

package/data/definition/kotlin.json

@@ -0,0 +1,269 @@
+{
+  "language": "kotlin",
+  "definitions": {
+    "String": {
+      "signature": "class String : Comparable<String>, CharSequence",
+      "description": "An immutable sequence of UTF-16 characters representing text. Kotlin strings support template expressions via $variable and ${expression} syntax, raw strings using triple quotes, and a rich set of extension functions for searching, transforming, and formatting text content.",
+      "type": "class",
+      "module": "kotlin",
+      "members": {
+        "length": {
+          "signature": "val length: Int",
+          "description": "Returns the number of characters in this string.",
+          "type": "property"
+        },
+        "substring": {
+          "signature": "fun substring(startIndex: Int, endIndex: Int = length): String",
+          "description": "Returns a substring starting at startIndex and ending before endIndex.",
+          "type": "method"
+        },
+        "split": {
+          "signature": "fun split(vararg delimiters: String, ignoreCase: Boolean = false, limit: Int = 0): List<String>",
+          "description": "Splits the string around matches of the given delimiters and returns a list of substrings.",
+          "type": "method"
+        },
+        "replace": {
+          "signature": "fun replace(oldValue: String, newValue: String, ignoreCase: Boolean = false): String",
+          "description": "Returns a new string with all occurrences of oldValue replaced with newValue.",
+          "type": "method"
+        },
+        "trim": {
+          "signature": "fun trim(): String",
+          "description": "Returns a string with leading and trailing whitespace removed.",
+          "type": "method"
+        },
+        "toIntOrNull": {
+          "signature": "fun String.toIntOrNull(radix: Int = 10): Int?",
+          "description": "Parses the string as an integer in the given radix, returning null if the string is not a valid integer.",
+          "type": "method"
+        },
+        "contains": {
+          "signature": "fun contains(other: CharSequence, ignoreCase: Boolean = false): Boolean",
+          "description": "Returns true if this string contains the specified other sequence of characters.",
+          "type": "method"
+        }
+      }
+    },
+    "List": {
+      "signature": "interface List<out E> : Collection<E>",
+      "description": "An ordered, read-only collection of elements that supports indexed access. Lists are one of the most commonly used collection types in Kotlin, created via listOf() for immutable or mutableListOf() for mutable variants, and support rich functional operations via extension functions.",
+      "type": "class",
+      "module": "kotlin.collections",
+      "members": {
+        "get": {
+          "signature": "operator fun get(index: Int): E",
+          "description": "Returns the element at the specified index, throwing IndexOutOfBoundsException if out of range.",
+          "type": "method"
+        },
+        "size": {
+          "signature": "val size: Int",
+          "description": "Returns the number of elements in the list.",
+          "type": "property"
+        },
+        "contains": {
+          "signature": "fun contains(element: E): Boolean",
+          "description": "Checks if the list contains the specified element using equals comparison.",
+          "type": "method"
+        },
+        "indexOf": {
+          "signature": "fun indexOf(element: E): Int",
+          "description": "Returns the index of the first occurrence of the element, or -1 if not found.",
+          "type": "method"
+        },
+        "filter": {
+          "signature": "fun <T> Iterable<T>.filter(predicate: (T) -> Boolean): List<T>",
+          "description": "Returns a list containing only elements matching the given predicate function.",
+          "type": "method"
+        },
+        "map": {
+          "signature": "fun <T, R> Iterable<T>.map(transform: (T) -> R): List<R>",
+          "description": "Returns a list containing the results of applying the transform function to each element.",
+          "type": "method"
+        },
+        "sortedBy": {
+          "signature": "fun <T, R : Comparable<R>> Iterable<T>.sortedBy(selector: (T) -> R?): List<T>",
+          "description": "Returns a list of all elements sorted by the value returned by the selector function.",
+          "type": "method"
+        },
+        "first": {
+          "signature": "fun <T> List<T>.first(): T",
+          "description": "Returns the first element, throwing NoSuchElementException if the list is empty.",
+          "type": "method"
+        }
+      }
+    },
+    "Map": {
+      "signature": "interface Map<K, out V>",
+      "description": "A read-only collection of key-value pairs where each key is unique. Created via mapOf() for immutable or mutableMapOf() for mutable maps. Kotlin maps support destructuring declarations, filtering, mapping, and efficient key-based lookup.",
+      "type": "class",
+      "module": "kotlin.collections",
+      "members": {
+        "get": {
+          "signature": "operator fun get(key: K): V?",
+          "description": "Returns the value for the given key, or null if no such key exists in the map.",
+          "type": "method"
+        },
+        "keys": {
+          "signature": "val keys: Set<K>",
+          "description": "Returns a read-only set of all keys in this map.",
+          "type": "property"
+        },
+        "values": {
+          "signature": "val values: Collection<V>",
+          "description": "Returns a read-only collection of all values in this map.",
+          "type": "property"
+        },
+        "entries": {
+          "signature": "val entries: Set<Map.Entry<K, V>>",
+          "description": "Returns a read-only set of all key-value pairs in this map.",
+          "type": "property"
+        },
+        "containsKey": {
+          "signature": "fun containsKey(key: K): Boolean",
+          "description": "Returns true if the map contains the specified key.",
+          "type": "method"
+        },
+        "getOrDefault": {
+          "signature": "fun getOrDefault(key: K, defaultValue: V): V",
+          "description": "Returns the value for the given key, or the defaultValue if no mapping exists.",
+          "type": "method"
+        }
+      }
+    },
+    "Set": {
+      "signature": "interface Set<out E> : Collection<E>",
+      "description": "A read-only collection of unique elements with no defined ordering guarantee. Created via setOf() for immutable or mutableSetOf() for mutable variants. Supports set-theoretic operations like union, intersect, and subtract via extension functions.",
+      "type": "class",
+      "module": "kotlin.collections",
+      "members": {
+        "contains": {
+          "signature": "fun contains(element: E): Boolean",
+          "description": "Checks if the set contains the specified element.",
+          "type": "method"
+        },
+        "size": {
+          "signature": "val size: Int",
+          "description": "Returns the number of elements in the set.",
+          "type": "property"
+        },
+        "union": {
+          "signature": "infix fun <T> Set<T>.union(other: Iterable<T>): Set<T>",
+          "description": "Returns a set containing all elements from both this set and the other collection.",
+          "type": "method"
+        },
+        "intersect": {
+          "signature": "infix fun <T> Set<T>.intersect(other: Iterable<T>): Set<T>",
+          "description": "Returns a set containing only elements present in both this set and the other collection.",
+          "type": "method"
+        },
+        "subtract": {
+          "signature": "infix fun <T> Set<T>.subtract(other: Iterable<T>): Set<T>",
+          "description": "Returns a set containing elements in this set but not in the other collection.",
+          "type": "method"
+        }
+      }
+    },
+    "Sequence": {
+      "signature": "interface Sequence<out T>",
+      "description": "A lazily evaluated collection that computes elements on demand during iteration. Unlike eager List operations, Sequence chains intermediate operations without creating temporary collections, making it efficient for large data sets or expensive transformations. Created via sequenceOf(), generateSequence(), or the .asSequence() extension.",
+      "type": "class",
+      "module": "kotlin.sequences",
+      "members": {
+        "filter": {
+          "signature": "fun <T> Sequence<T>.filter(predicate: (T) -> Boolean): Sequence<T>",
+          "description": "Returns a sequence containing only elements matching the given predicate (lazy evaluation).",
+          "type": "method"
+        },
+        "map": {
+          "signature": "fun <T, R> Sequence<T>.map(transform: (T) -> R): Sequence<R>",
+          "description": "Returns a sequence that applies the transform function lazily to each element.",
+          "type": "method"
+        },
+        "take": {
+          "signature": "fun <T> Sequence<T>.take(n: Int): Sequence<T>",
+          "description": "Returns a sequence containing only the first n elements.",
+          "type": "method"
+        },
+        "toList": {
+          "signature": "fun <T> Sequence<T>.toList(): List<T>",
+          "description": "Returns a List containing all elements of this sequence, triggering terminal evaluation.",
+          "type": "method"
+        }
+      }
+    },
+    "Pair": {
+      "signature": "data class Pair<out A, out B>(val first: A, val second: B)",
+      "description": "A generic data class representing a pair of two values. Created using the infix function to (e.g., 1 to \"one\"). Commonly used for map entries, returning two values from a function, and destructuring declarations via (a, b) = pair syntax.",
+      "type": "class",
+      "module": "kotlin",
+      "members": {
+        "first": {
+          "signature": "val first: A",
+          "description": "The first element of the pair.",
+          "type": "property"
+        },
+        "second": {
+          "signature": "val second: B",
+          "description": "The second element of the pair.",
+          "type": "property"
+        },
+        "toList": {
+          "signature": "fun toList(): List<Any?>",
+          "description": "Converts this pair into a list containing the first and second elements.",
+          "type": "method"
+        }
+      }
+    },
+    "Regex": {
+      "signature": "class Regex(pattern: String, options: Set<RegexOption> = emptySet())",
+      "description": "Represents a compiled regular expression pattern used for matching, finding, and replacing text. Supports named groups, regex options like IGNORE_CASE and MULTILINE, and provides Kotlin-idiomatic APIs for pattern operations that integrate cleanly with string extension functions.",
+      "type": "class",
+      "module": "kotlin.text",
+      "members": {
+        "find": {
+          "signature": "fun find(input: CharSequence, startIndex: Int = 0): MatchResult?",
+          "description": "Returns the first match of the regular expression in the input, starting at startIndex, or null if not found.",
+          "type": "method"
+        },
+        "findAll": {
+          "signature": "fun findAll(input: CharSequence, startIndex: Int = 0): Sequence<MatchResult>",
+          "description": "Returns a lazy sequence of all non-overlapping matches of the pattern in the input string.",
+          "type": "method"
+        },
+        "matches": {
+          "signature": "fun matches(input: CharSequence): Boolean",
+          "description": "Returns true if the entire input string matches this regular expression pattern.",
+          "type": "method"
+        },
+        "replace": {
+          "signature": "fun replace(input: CharSequence, replacement: String): String",
+          "description": "Replaces all occurrences of the pattern in the input with the replacement string.",
+          "type": "method"
+        },
+        "containsMatchIn": {
+          "signature": "fun containsMatchIn(input: CharSequence): Boolean",
+          "description": "Returns true if there is at least one match of this pattern anywhere in the input string.",
+          "type": "method"
+        }
+      }
+    },
+    "println": {
+      "signature": "fun println(message: Any?)",
+      "description": "Prints the given message to the standard output stream followed by a newline character. Accepts any nullable type, converting it to a string representation via toString(). This is the primary function for console output in Kotlin programs.",
+      "type": "function",
+      "module": "kotlin.io"
+    },
+    "listOf": {
+      "signature": "fun <T> listOf(vararg elements: T): List<T>",
+      "description": "Creates an immutable list containing the specified elements in the order they are provided. The returned list does not support add or remove operations. Use mutableListOf() when mutation is needed. This is the idiomatic Kotlin way to create read-only lists.",
+      "type": "function",
+      "module": "kotlin.collections"
+    },
+    "data class": {
+      "signature": "data class Name(val prop1: Type1, val prop2: Type2, ...)",
+      "description": "Declares a class whose primary purpose is holding data, automatically generating equals(), hashCode(), toString(), copy(), and componentN() destructuring functions from the primary constructor parameters. Data classes must have at least one val or var parameter and cannot be abstract, open, sealed, or inner.",
+      "type": "keyword",
+      "module": "kotlin"
+    }
+  }
+}

package/data/definition/less.json

@@ -0,0 +1,65 @@
+{
+  "language": "less",
+  "definitions": {
+    "color": {
+      "signature": "color(string) -> color",
+      "description": "Parses a color string (hex, rgb, rgba, hsl, hsla, or named color keyword) and returns a color value that can be used in further color manipulation functions. This is the base function for constructing color values programmatically in Less stylesheets.",
+      "type": "function",
+      "module": "Less Color Functions"
+    },
+    "darken": {
+      "signature": "darken(color, amount[, method]) -> color",
+      "description": "Decreases the lightness of the given color by the specified percentage amount in the HSL color space. The optional method parameter can be set to 'relative' for relative percentage changes instead of absolute. Useful for generating darker variants of a base color for hover states or borders.",
+      "type": "function",
+      "module": "Less Color Functions"
+    },
+    "lighten": {
+      "signature": "lighten(color, amount[, method]) -> color",
+      "description": "Increases the lightness of the given color by the specified percentage amount in the HSL color space. Commonly used for creating lighter shades for backgrounds, disabled states, and accent variations from a primary theme color.",
+      "type": "function",
+      "module": "Less Color Functions"
+    },
+    "mix": {
+      "signature": "mix(color1, color2[, weight]) -> color",
+      "description": "Blends two colors together proportionally based on the weight parameter (defaulting to 50%). A weight of 25% mixes 25% of color1 with 75% of color2. Opacity is also factored into the weighting calculation for semi-transparent colors.",
+      "type": "function",
+      "module": "Less Color Functions"
+    },
+    "fade": {
+      "signature": "fade(color, amount) -> color",
+      "description": "Sets the absolute opacity of a color to the specified percentage amount (0% to 100%). Unlike fadein/fadeout which adjust opacity relatively, fade sets it to an exact value, making it predictable for creating semi-transparent overlay colors.",
+      "type": "function",
+      "module": "Less Color Functions"
+    },
+    "spin": {
+      "signature": "spin(color, angle) -> color",
+      "description": "Rotates the hue of a color by the given angle in degrees on the color wheel (0 to 360). Positive values rotate clockwise, negative counter-clockwise. Useful for generating complementary and analogous color schemes from a single base color.",
+      "type": "function",
+      "module": "Less Color Functions"
+    },
+    "percentage": {
+      "signature": "percentage(number) -> percentage",
+      "description": "Converts a unitless number to a percentage value by multiplying by 100. For example, percentage(0.5) returns 50%. Useful when computing relative dimensions or widths from ratios stored in variables.",
+      "type": "function",
+      "module": "Less Math Functions"
+    },
+    "unit": {
+      "signature": "unit(dimension[, unit]) -> number|dimension",
+      "description": "Changes or removes the unit of a dimension value. With one argument, strips the unit and returns a unitless number. With two arguments, replaces the unit with the specified one. Commonly used for unit conversions and arithmetic between incompatible unit types.",
+      "type": "function",
+      "module": "Less Math Functions"
+    },
+    ".mixin": {
+      "signature": ".mixin-name(@param1: default, @param2: default) { ... }",
+      "description": "Defines a reusable set of CSS declarations (a mixin) that can accept parameters with optional default values. Mixins are invoked by their selector name and can be included in any ruleset. They support pattern matching, guards (when conditions), and the ... rest argument syntax for variadic parameters.",
+      "type": "keyword",
+      "module": "Less Mixins"
+    },
+    "@variable": {
+      "signature": "@variable-name: value;",
+      "description": "Declares a Less variable that stores a value for reuse throughout the stylesheet. Variables can hold colors, dimensions, strings, or any CSS value and are evaluated lazily — meaning the last definition in scope wins. They enable centralized theming, consistent spacing scales, and easy global style changes.",
+      "type": "keyword",
+      "module": "Less Variables"
+    }
+  }
+}

package/data/definition/lexon.json

@@ -0,0 +1,65 @@
+{
+  "language": "lexon",
+  "definitions": {
+    "CLAUSE": {
+      "signature": "CLAUSE: <clause_name>.",
+      "description": "Defines a named clause within a Lexon legal contract that encapsulates a specific contractual provision or rule. Clauses are the primary structural units of Lexon contracts, containing statements that specify obligations, permissions, and conditions that govern the behavior of the contracting parties.",
+      "type": "keyword",
+      "module": "Lexon Contract Structure"
+    },
+    "TERMS": {
+      "signature": "TERMS: <terms_description>.",
+      "description": "Declares the overarching terms section of a Lexon contract, establishing the scope and context of the contractual agreement. The terms block contains all clauses, covenants, and definitions that constitute the complete legal arrangement between parties.",
+      "type": "keyword",
+      "module": "Lexon Contract Structure"
+    },
+    "LEX": {
+      "signature": "LEX: <contract_name>.",
+      "description": "The top-level declaration that names and initiates a Lexon smart legal contract. Every Lexon program begins with a LEX statement that identifies the contract, followed by the terms and clauses that define the agreement's provisions and executable logic.",
+      "type": "keyword",
+      "module": "Lexon Contract Structure"
+    },
+    "COVENANT": {
+      "signature": "COVENANT: <covenant_description>.",
+      "description": "Specifies a binding promise or agreement within the contract that one or more parties commit to fulfilling. Covenants in Lexon represent strong contractual commitments that are intended to be enforceable and may trigger obligations or consequences if breached.",
+      "type": "keyword",
+      "module": "Lexon Contract Terms"
+    },
+    "CONDITION": {
+      "signature": "IF <condition> THEN <action>.",
+      "description": "Defines a conditional clause that executes an action only when a specified condition evaluates to true. Conditions enable dynamic contract behavior by allowing different outcomes based on events, dates, states, or party actions during contract execution.",
+      "type": "keyword",
+      "module": "Lexon Contract Logic"
+    },
+    "OBLIGATION": {
+      "signature": "<party> SHALL <action>.",
+      "description": "Declares a mandatory duty that a named party must perform under the contract. Obligations are enforceable requirements — failure to fulfill an obligation may constitute a breach of contract and trigger remedial clauses or penalty provisions defined elsewhere.",
+      "type": "keyword",
+      "module": "Lexon Contract Terms"
+    },
+    "PERMISSION": {
+      "signature": "<party> MAY <action>.",
+      "description": "Grants a named party the right (but not the obligation) to perform a specified action under the contract. Permissions define optional capabilities that contracting parties can exercise at their discretion within the bounds of the agreement.",
+      "type": "keyword",
+      "module": "Lexon Contract Terms"
+    },
+    "PAY": {
+      "signature": "<payer> SHALL PAY <amount> TO <payee>.",
+      "description": "Specifies a payment obligation where one party must transfer a monetary amount to another party. In smart-contract compilation, PAY statements translate to token transfer operations on the blockchain, automating the financial settlement described in the legal text.",
+      "type": "keyword",
+      "module": "Lexon Contract Actions"
+    },
+    "CERTIFY": {
+      "signature": "<certifier> SHALL CERTIFY <statement>.",
+      "description": "Requires a designated party to attest or verify the truth of a statement or the occurrence of an event. Certification actions serve as oracles or attestation points in the contract, enabling off-chain facts to influence on-chain contract execution.",
+      "type": "keyword",
+      "module": "Lexon Contract Actions"
+    },
+    "TERMINATE": {
+      "signature": "TERMINATE.",
+      "description": "Ends the execution of the contract or a specific clause, releasing parties from further obligations defined within the terminated scope. Termination may be conditional (triggered by breach or expiration) or voluntary when explicitly invoked by an authorized party.",
+      "type": "keyword",
+      "module": "Lexon Contract Actions"
+    }
+  }
+}