@enjoys/context-engine 1.1.1 → 1.2.0

package/data/definition/liquid.json

@@ -0,0 +1,176 @@
+{
+  "language": "liquid",
+  "definitions": {
+    "assign": {
+      "signature": "{% assign variable = value %}",
+      "description": "Creates a new named variable and assigns it a value within a Liquid template, persisting for the remainder of the template rendering context.",
+      "type": "function",
+      "module": "tags"
+    },
+    "capture": {
+      "signature": "{% capture variable %}...{% endcapture %}",
+      "description": "Captures the rendered content between the opening and closing tags into a string variable, allowing complex string building from template fragments.",
+      "type": "function",
+      "module": "tags"
+    },
+    "for": {
+      "signature": "{% for item in collection %}...{% endfor %}",
+      "description": "Iterates over an array or range, rendering the enclosed block for each element. Supports limit, offset, reversed parameters and exposes forloop object with index, first, last properties.",
+      "type": "function",
+      "module": "tags",
+      "members": {
+        "forloop.index": {
+          "signature": "forloop.index -> Integer",
+          "description": "Returns the 1-based index of the current iteration within the for loop.",
+          "type": "method"
+        },
+        "forloop.index0": {
+          "signature": "forloop.index0 -> Integer",
+          "description": "Returns the 0-based index of the current iteration within the for loop.",
+          "type": "method"
+        },
+        "forloop.first": {
+          "signature": "forloop.first -> Boolean",
+          "description": "Returns true if the current iteration is the first one in the loop.",
+          "type": "method"
+        },
+        "forloop.last": {
+          "signature": "forloop.last -> Boolean",
+          "description": "Returns true if the current iteration is the last one in the loop.",
+          "type": "method"
+        },
+        "forloop.length": {
+          "signature": "forloop.length -> Integer",
+          "description": "Returns the total number of iterations in the for loop.",
+          "type": "method"
+        }
+      }
+    },
+    "if": {
+      "signature": "{% if condition %}...{% endif %}",
+      "description": "Conditionally renders enclosed content when the given expression evaluates to a truthy value. Supports elsif and else branches for multiple condition paths.",
+      "type": "function",
+      "module": "tags"
+    },
+    "unless": {
+      "signature": "{% unless condition %}...{% endunless %}",
+      "description": "Renders enclosed content only when the given condition evaluates to false or nil, acting as the inverse of the if tag for cleaner negation logic.",
+      "type": "function",
+      "module": "tags"
+    },
+    "case": {
+      "signature": "{% case variable %}{% when value %}...{% endcase %}",
+      "description": "Creates a switch-style conditional that checks a variable against multiple when values and renders the matching block, with optional else for default output.",
+      "type": "function",
+      "module": "tags"
+    },
+    "include": {
+      "signature": "{% include 'snippet' %}",
+      "description": "Inserts the rendered content of another template file into the current template. Supports passing variables with the with keyword for parameterized partial rendering. Deprecated in favor of render.",
+      "type": "function",
+      "module": "tags"
+    },
+    "render": {
+      "signature": "{% render 'snippet', var: value %}",
+      "description": "Renders a partial template in an isolated scope, preventing it from accessing or modifying the parent template variables. Preferred over include for better encapsulation and performance.",
+      "type": "function",
+      "module": "tags"
+    },
+    "comment": {
+      "signature": "{% comment %}...{% endcomment %}",
+      "description": "Prevents any content between the opening and closing tags from being rendered in the final output, useful for adding developer notes or temporarily disabling template sections.",
+      "type": "function",
+      "module": "tags"
+    },
+    "raw": {
+      "signature": "{% raw %}...{% endraw %}",
+      "description": "Outputs the enclosed content without processing any Liquid tags or objects, allowing display of Liquid code examples or curly-brace syntax in template output.",
+      "type": "function",
+      "module": "tags"
+    },
+    "append": {
+      "signature": "{{ value | append: 'string' }} -> String",
+      "description": "String filter that concatenates the given string to the end of the input value, commonly used for building URLs, file paths, or composite display strings.",
+      "type": "function",
+      "module": "filters"
+    },
+    "prepend": {
+      "signature": "{{ value | prepend: 'string' }} -> String",
+      "description": "String filter that adds the specified string to the beginning of the input value, useful for prefixing paths, protocols, or labels to existing strings.",
+      "type": "function",
+      "module": "filters"
+    },
+    "downcase": {
+      "signature": "{{ value | downcase }} -> String",
+      "description": "Converts all characters in the input string to lowercase, useful for normalizing user input, generating URL slugs, or case-insensitive display formatting.",
+      "type": "function",
+      "module": "filters"
+    },
+    "upcase": {
+      "signature": "{{ value | upcase }} -> String",
+      "description": "Converts all characters in the input string to uppercase, commonly used for headings, labels, or emphasis in template output rendering.",
+      "type": "function",
+      "module": "filters"
+    },
+    "split": {
+      "signature": "{{ value | split: 'delimiter' }} -> Array",
+      "description": "Divides a string into an array of substrings based on the specified delimiter, enabling iteration over comma-separated lists, path segments, or other structured text.",
+      "type": "function",
+      "module": "filters"
+    },
+    "join": {
+      "signature": "{{ array | join: 'glue' }} -> String",
+      "description": "Combines all elements of an array into a single string, inserting the specified glue string between each element for formatted list output.",
+      "type": "function",
+      "module": "filters"
+    },
+    "strip_html": {
+      "signature": "{{ value | strip_html }} -> String",
+      "description": "Removes all HTML tags from the input string, producing plain text output suitable for meta descriptions, excerpts, or non-HTML contexts.",
+      "type": "function",
+      "module": "filters"
+    },
+    "date": {
+      "signature": "{{ value | date: 'format' }} -> String",
+      "description": "Converts a timestamp or date string into a formatted date string using strftime-compatible format directives such as %Y for year, %m for month, and %d for day.",
+      "type": "function",
+      "module": "filters"
+    },
+    "where": {
+      "signature": "{{ array | where: 'property', 'value' }} -> Array",
+      "description": "Filters an array of objects, returning only those whose specified property matches the given value. Essential for querying collections by attributes in Shopify and Jekyll templates.",
+      "type": "function",
+      "module": "filters"
+    },
+    "map": {
+      "signature": "{{ array | map: 'property' }} -> Array",
+      "description": "Extracts the values of a specific property from each object in an array, producing a new array of those values for iteration or display.",
+      "type": "function",
+      "module": "filters"
+    },
+    "sort": {
+      "signature": "{{ array | sort: 'property' }} -> Array",
+      "description": "Returns a sorted copy of the input array. When a property name is specified, sorts objects by that property value in ascending order.",
+      "type": "function",
+      "module": "filters"
+    },
+    "size": {
+      "signature": "{{ value | size }} -> Integer",
+      "description": "Returns the number of characters in a string or the number of elements in an array, commonly used in conditional checks for empty collections or length limits.",
+      "type": "function",
+      "module": "filters"
+    },
+    "default": {
+      "signature": "{{ value | default: 'fallback' }} -> Any",
+      "description": "Returns the input value if it is present and not empty; otherwise returns the specified fallback value, providing safe defaults for potentially nil or blank variables.",
+      "type": "function",
+      "module": "filters"
+    },
+    "replace": {
+      "signature": "{{ value | replace: 'search', 'replacement' }} -> String",
+      "description": "Replaces all occurrences of the search string in the input with the replacement string, useful for text transformations, sanitization, and URL slug generation.",
+      "type": "function",
+      "module": "filters"
+    }
+  }
+}

package/data/definition/m3.json

@@ -0,0 +1,220 @@
+{
+  "language": "m3",
+  "definitions": {
+    "TEXT": {
+      "signature": "TEXT",
+      "description": "The built-in immutable string type in Modula-3, representing a sequence of characters with reference semantics. TEXT values are garbage-collected and support concatenation with the ampersand operator.",
+      "type": "class",
+      "module": "Text",
+      "members": {
+        "Length": {
+          "signature": "Text.Length(t: TEXT) -> CARDINAL",
+          "description": "Returns the number of characters in the given text value.",
+          "type": "method"
+        },
+        "GetChar": {
+          "signature": "Text.GetChar(t: TEXT, i: CARDINAL) -> CHAR",
+          "description": "Returns the character at position i in the text, with zero-based indexing.",
+          "type": "method"
+        },
+        "Sub": {
+          "signature": "Text.Sub(t: TEXT, start: CARDINAL, length: CARDINAL) -> TEXT",
+          "description": "Returns a substring of t starting at position start with the given length.",
+          "type": "method"
+        },
+        "Equal": {
+          "signature": "Text.Equal(t: TEXT, u: TEXT) -> BOOLEAN",
+          "description": "Returns TRUE if the two text values contain identical character sequences.",
+          "type": "method"
+        },
+        "Cat": {
+          "signature": "Text.Cat(t: TEXT, u: TEXT) -> TEXT",
+          "description": "Concatenates two text values and returns the combined result.",
+          "type": "method"
+        }
+      }
+    },
+    "INTEGER": {
+      "signature": "INTEGER",
+      "description": "The built-in signed integer type in Modula-3, representing whole numbers within the platform-dependent range. Supports standard arithmetic, comparison, and bitwise operations defined by the language.",
+      "type": "class",
+      "module": "builtin"
+    },
+    "REAL": {
+      "signature": "REAL",
+      "description": "The standard single-precision floating-point type in Modula-3, conforming to IEEE 754 representation. Used for numeric computations requiring fractional values with moderate precision.",
+      "type": "class",
+      "module": "builtin"
+    },
+    "LONGREAL": {
+      "signature": "LONGREAL",
+      "description": "The double-precision floating-point type in Modula-3, providing higher precision than REAL for scientific and mathematical computations requiring greater accuracy in decimal representation.",
+      "type": "class",
+      "module": "builtin"
+    },
+    "BOOLEAN": {
+      "signature": "BOOLEAN = {FALSE, TRUE}",
+      "description": "The built-in enumeration type with exactly two values, FALSE and TRUE, used for logical operations, conditionals, and control flow in Modula-3 programs.",
+      "type": "class",
+      "module": "builtin"
+    },
+    "CHAR": {
+      "signature": "CHAR",
+      "description": "The built-in character type representing a single 8-bit character in the ISO Latin-1 character set. CHAR values are ordinal and support ORD and VAL operations for conversion.",
+      "type": "class",
+      "module": "builtin"
+    },
+    "ARRAY": {
+      "signature": "ARRAY [index_type] OF element_type",
+      "description": "A fixed-size or open array type in Modula-3 that stores elements of a uniform type indexed by an ordinal type. Open arrays use ARRAY OF T syntax and are passed by reference.",
+      "type": "class",
+      "module": "builtin",
+      "members": {
+        "NUMBER": {
+          "signature": "NUMBER(a: ARRAY) -> CARDINAL",
+          "description": "Returns the number of elements in the array.",
+          "type": "method"
+        },
+        "FIRST": {
+          "signature": "FIRST(a: ARRAY) -> index_type",
+          "description": "Returns the first valid index of the array.",
+          "type": "method"
+        },
+        "LAST": {
+          "signature": "LAST(a: ARRAY) -> index_type",
+          "description": "Returns the last valid index of the array.",
+          "type": "method"
+        }
+      }
+    },
+    "RECORD": {
+      "signature": "RECORD field1: Type1; field2: Type2; END",
+      "description": "A composite value type in Modula-3 that groups named fields of potentially different types into a single structured data unit, similar to structs in C or records in Pascal.",
+      "type": "class",
+      "module": "builtin"
+    },
+    "NEW": {
+      "signature": "NEW(T, ...) -> REF T",
+      "description": "Allocates heap memory for a reference type and returns a traced reference to the newly created object. Accepts optional field initializers for record and object types in Modula-3.",
+      "type": "function",
+      "module": "builtin"
+    },
+    "THREAD": {
+      "signature": "THREAD",
+      "description": "The standard Modula-3 interface for concurrent programming, providing thread creation via Fork, synchronization with Mutex and Condition variables, and cooperative scheduling primitives.",
+      "type": "interface",
+      "module": "Thread",
+      "members": {
+        "Fork": {
+          "signature": "Thread.Fork(cl: Thread.Closure) -> Thread.T",
+          "description": "Creates and starts a new thread executing the given closure's apply method.",
+          "type": "method"
+        },
+        "Join": {
+          "signature": "Thread.Join(t: Thread.T) -> REFANY",
+          "description": "Blocks the calling thread until thread t completes and returns its result.",
+          "type": "method"
+        },
+        "Wait": {
+          "signature": "Thread.Wait(m: MUTEX, c: Thread.Condition)",
+          "description": "Atomically releases the mutex and suspends the thread until the condition is signaled.",
+          "type": "method"
+        },
+        "Signal": {
+          "signature": "Thread.Signal(c: Thread.Condition)",
+          "description": "Wakes one thread waiting on the given condition variable.",
+          "type": "method"
+        },
+        "Broadcast": {
+          "signature": "Thread.Broadcast(c: Thread.Condition)",
+          "description": "Wakes all threads waiting on the given condition variable.",
+          "type": "method"
+        }
+      }
+    },
+    "Fmt": {
+      "signature": "Fmt",
+      "description": "The standard formatting interface in Modula-3 providing functions to convert integers, reals, booleans, and characters to their TEXT representations for output and string construction.",
+      "type": "interface",
+      "module": "Fmt",
+      "members": {
+        "Int": {
+          "signature": "Fmt.Int(n: INTEGER, base: [2..16]) -> TEXT",
+          "description": "Converts an integer to its text representation in the specified base.",
+          "type": "method"
+        },
+        "Real": {
+          "signature": "Fmt.Real(x: REAL, style: Fmt.Style, prec: CARDINAL) -> TEXT",
+          "description": "Converts a real number to text with the given formatting style and precision.",
+          "type": "method"
+        },
+        "Bool": {
+          "signature": "Fmt.Bool(b: BOOLEAN) -> TEXT",
+          "description": "Returns the text TRUE or FALSE for the given boolean value.",
+          "type": "method"
+        },
+        "Char": {
+          "signature": "Fmt.Char(c: CHAR) -> TEXT",
+          "description": "Converts a single character to a one-character text value.",
+          "type": "method"
+        }
+      }
+    },
+    "Wr": {
+      "signature": "Wr",
+      "description": "The standard writer interface in Modula-3 providing buffered output streams for writing text to files, standard output, and other destinations with flush and close operations.",
+      "type": "interface",
+      "module": "Wr",
+      "members": {
+        "PutText": {
+          "signature": "Wr.PutText(wr: Wr.T, t: TEXT)",
+          "description": "Writes the given text string to the output writer stream.",
+          "type": "method"
+        },
+        "PutChar": {
+          "signature": "Wr.PutChar(wr: Wr.T, c: CHAR)",
+          "description": "Writes a single character to the output writer stream.",
+          "type": "method"
+        },
+        "Flush": {
+          "signature": "Wr.Flush(wr: Wr.T)",
+          "description": "Flushes any buffered output to the underlying destination.",
+          "type": "method"
+        },
+        "Close": {
+          "signature": "Wr.Close(wr: Wr.T)",
+          "description": "Flushes remaining output and closes the writer, releasing associated resources.",
+          "type": "method"
+        }
+      }
+    },
+    "Rd": {
+      "signature": "Rd",
+      "description": "The standard reader interface in Modula-3 providing buffered input streams for reading characters and lines from files, standard input, and other sources with EOF detection.",
+      "type": "interface",
+      "module": "Rd",
+      "members": {
+        "GetChar": {
+          "signature": "Rd.GetChar(rd: Rd.T) -> CHAR",
+          "description": "Reads and returns the next character from the input reader stream.",
+          "type": "method"
+        },
+        "GetLine": {
+          "signature": "Rd.GetLine(rd: Rd.T) -> TEXT",
+          "description": "Reads and returns text up to the next newline character from the input stream.",
+          "type": "method"
+        },
+        "EOF": {
+          "signature": "Rd.EOF(rd: Rd.T) -> BOOLEAN",
+          "description": "Returns TRUE if the reader has reached the end of the input stream.",
+          "type": "method"
+        },
+        "Close": {
+          "signature": "Rd.Close(rd: Rd.T)",
+          "description": "Closes the reader and releases associated resources.",
+          "type": "method"
+        }
+      }
+    }
+  }
+}

package/data/definition/mdx.json

@@ -0,0 +1,78 @@
+{
+  "language": "mdx",
+  "definitions": {
+    "export": {
+      "signature": "export const name = value",
+      "description": "Exports a JavaScript value, component, or function from an MDX file, making it available for import by other modules. Supports named exports and default exports for layout components.",
+      "type": "function",
+      "module": "MDX"
+    },
+    "import": {
+      "signature": "import { Component } from 'module'",
+      "description": "Imports JavaScript modules, React components, or other MDX files into the current document, enabling use of external components and utilities within the markdown content.",
+      "type": "function",
+      "module": "MDX"
+    },
+    "export default": {
+      "signature": "export default (props) => <Layout>{props.children}</Layout>",
+      "description": "Defines a default export wrapper component that controls the layout of the entire MDX document, receiving the rendered content as children for custom page structure.",
+      "type": "function",
+      "module": "MDX"
+    },
+    "JSX Component": {
+      "signature": "<Component prop={value}>children</Component>",
+      "description": "Embeds a JSX or React component directly within markdown content, passing props and children. Components are resolved from imports or the MDXProvider component mapping context.",
+      "type": "function",
+      "module": "MDX"
+    },
+    "MDXProvider": {
+      "signature": "<MDXProvider components={mapping}>children</MDXProvider>",
+      "description": "A React context provider that supplies custom component mappings to MDX content, allowing replacement of standard HTML elements like h1, p, a, code with custom React components.",
+      "type": "class",
+      "module": "@mdx-js/react",
+      "members": {
+        "components": {
+          "signature": "components: Record<string, React.ComponentType>",
+          "description": "An object mapping HTML tag names to React components used for rendering.",
+          "type": "method"
+        }
+      }
+    },
+    "frontmatter": {
+      "signature": "---\ntitle: string\ndate: string\n---",
+      "description": "YAML metadata block at the top of an MDX file enclosed by triple dashes, defining document properties like title, date, author, and custom fields accessible via props or plugins.",
+      "type": "function",
+      "module": "MDX"
+    },
+    "useMDXComponents": {
+      "signature": "useMDXComponents() -> Record<string, React.ComponentType>",
+      "description": "A React hook that returns the current MDX component mapping from the nearest MDXProvider context, enabling custom components to access and extend the component resolution chain.",
+      "type": "function",
+      "module": "@mdx-js/react"
+    },
+    "remarkPlugins": {
+      "signature": "remarkPlugins: Plugin[]",
+      "description": "Configuration option specifying remark plugins that transform the markdown AST before compilation, enabling features like GitHub-flavored markdown, math expressions, and custom syntax extensions.",
+      "type": "interface",
+      "module": "@mdx-js/mdx"
+    },
+    "rehypePlugins": {
+      "signature": "rehypePlugins: Plugin[]",
+      "description": "Configuration option specifying rehype plugins that transform the HTML or JSX AST after markdown processing, enabling features like syntax highlighting, heading anchors, and HTML sanitization.",
+      "type": "interface",
+      "module": "@mdx-js/mdx"
+    },
+    "compile": {
+      "signature": "compile(source: string, options?: CompileOptions) -> Promise<VFile>",
+      "description": "Compiles an MDX string into JavaScript code that exports a React component. Accepts remark and rehype plugins, JSX runtime configuration, and output format options.",
+      "type": "function",
+      "module": "@mdx-js/mdx"
+    },
+    "evaluate": {
+      "signature": "evaluate(source: string, options: EvaluateOptions) -> Promise<MDXModule>",
+      "description": "Compiles and evaluates an MDX string at runtime, returning the default export component and any named exports. Requires a JSX runtime to be provided in options.",
+      "type": "function",
+      "module": "@mdx-js/mdx"
+    }
+  }
+}

package/data/definition/mips.json

@@ -0,0 +1,185 @@
+{
+  "language": "mips",
+  "definitions": {
+    "add": {
+      "signature": "add $rd, $rs, $rt",
+      "description": "Adds the values in registers rs and rt, storing the result in register rd. Triggers an arithmetic overflow exception if the result exceeds the signed 32-bit integer range.",
+      "type": "function",
+      "module": "R-Type Arithmetic"
+    },
+    "addi": {
+      "signature": "addi $rt, $rs, immediate",
+      "description": "Adds a sign-extended 16-bit immediate value to the contents of register rs and stores the result in register rt. Raises overflow exception on signed overflow.",
+      "type": "function",
+      "module": "I-Type Arithmetic"
+    },
+    "sub": {
+      "signature": "sub $rd, $rs, $rt",
+      "description": "Subtracts the value in register rt from register rs and stores the result in register rd. Triggers an arithmetic overflow exception on signed integer overflow.",
+      "type": "function",
+      "module": "R-Type Arithmetic"
+    },
+    "mul": {
+      "signature": "mul $rd, $rs, $rt",
+      "description": "Multiplies the values in registers rs and rt, storing the lower 32 bits of the result in register rd. A pseudo-instruction in some assemblers that wraps mult and mflo.",
+      "type": "function",
+      "module": "R-Type Arithmetic"
+    },
+    "and": {
+      "signature": "and $rd, $rs, $rt",
+      "description": "Performs a bitwise AND operation between the values in registers rs and rt, storing the result in register rd for masking and flag extraction operations.",
+      "type": "function",
+      "module": "R-Type Logic"
+    },
+    "or": {
+      "signature": "or $rd, $rs, $rt",
+      "description": "Performs a bitwise OR operation between the values in registers rs and rt, storing the result in register rd for combining bit flags or setting specific bits.",
+      "type": "function",
+      "module": "R-Type Logic"
+    },
+    "sll": {
+      "signature": "sll $rd, $rt, shamt",
+      "description": "Shifts the value in register rt left by the specified shift amount of 0 to 31 bits, filling vacated positions with zeros and storing the result in register rd.",
+      "type": "function",
+      "module": "R-Type Shift"
+    },
+    "srl": {
+      "signature": "srl $rd, $rt, shamt",
+      "description": "Shifts the value in register rt right by the specified shift amount of 0 to 31 bits, filling vacated positions with zeros as a logical shift and storing result in register rd.",
+      "type": "function",
+      "module": "R-Type Shift"
+    },
+    "lw": {
+      "signature": "lw $rt, offset($rs)",
+      "description": "Loads a 32-bit word from memory at the address computed by adding the sign-extended offset to register rs, storing the value in register rt. Address must be word-aligned.",
+      "type": "function",
+      "module": "Memory Access"
+    },
+    "sw": {
+      "signature": "sw $rt, offset($rs)",
+      "description": "Stores the 32-bit word from register rt into memory at the address computed by adding the sign-extended offset to register rs. Address must be word-aligned.",
+      "type": "function",
+      "module": "Memory Access"
+    },
+    "lb": {
+      "signature": "lb $rt, offset($rs)",
+      "description": "Loads a byte from memory at the computed address, sign-extends it to 32 bits, and stores the result in register rt. Used for reading signed character data.",
+      "type": "function",
+      "module": "Memory Access"
+    },
+    "sb": {
+      "signature": "sb $rt, offset($rs)",
+      "description": "Stores the least significant byte of register rt into memory at the address computed by adding the sign-extended offset to register rs.",
+      "type": "function",
+      "module": "Memory Access"
+    },
+    "la": {
+      "signature": "la $rt, label",
+      "description": "Pseudo-instruction that loads the 32-bit address of a label into register rt. Typically expands to a lui and ori instruction pair for the upper and lower 16 bits.",
+      "type": "function",
+      "module": "Pseudo-Instructions"
+    },
+    "li": {
+      "signature": "li $rt, immediate",
+      "description": "Pseudo-instruction that loads a 32-bit immediate constant into register rt, expanding to lui and ori as needed depending on the magnitude of the value.",
+      "type": "function",
+      "module": "Pseudo-Instructions"
+    },
+    "beq": {
+      "signature": "beq $rs, $rt, label",
+      "description": "Branch on Equal compares registers rs and rt, and if they are equal, branches to the target label by adding the sign-extended offset to the program counter.",
+      "type": "function",
+      "module": "Branch"
+    },
+    "bne": {
+      "signature": "bne $rs, $rt, label",
+      "description": "Branch on Not Equal compares registers rs and rt, and if they differ, branches to the target label by adding the sign-extended offset to the program counter.",
+      "type": "function",
+      "module": "Branch"
+    },
+    "slt": {
+      "signature": "slt $rd, $rs, $rt",
+      "description": "Set on Less Than sets register rd to 1 if the signed value in rs is less than the signed value in rt, otherwise sets rd to 0. Essential for comparison-based branching.",
+      "type": "function",
+      "module": "R-Type Comparison"
+    },
+    "j": {
+      "signature": "j target",
+      "description": "Unconditional Jump instruction that jumps to the instruction at the specified 26-bit target address, with the upper 4 bits from the current program counter. Used for loops and gotos.",
+      "type": "function",
+      "module": "Jump"
+    },
+    "jal": {
+      "signature": "jal target",
+      "description": "Jump and Link saves the return address PC+4 in register $ra and jumps to the target address. The standard instruction for calling subroutines in MIPS assembly programs.",
+      "type": "function",
+      "module": "Jump"
+    },
+    "jr": {
+      "signature": "jr $rs",
+      "description": "Jump Register jumps to the address stored in register rs. Commonly used with $ra to return from a subroutine called by jal, restoring execution to the caller.",
+      "type": "function",
+      "module": "Jump"
+    },
+    "syscall": {
+      "signature": "syscall",
+      "description": "Triggers a system call to the operating system or simulator. The service number in $v0 with arguments in $a0-$a3. Common services include 1 for print_int, 4 for print_string, 10 for exit.",
+      "type": "function",
+      "module": "System"
+    },
+    "$v0": {
+      "signature": "$v0 (Register 2)",
+      "description": "Value register 0, used for function return values and syscall service numbers. By convention, integer return values from functions are placed in $v0 before returning.",
+      "type": "function",
+      "module": "Registers"
+    },
+    "$a0": {
+      "signature": "$a0 (Register 4)",
+      "description": "Argument register 0, used to pass the first argument to subroutines and syscalls. Part of the $a0-$a3 convention for the first four function parameters in MIPS calling convention.",
+      "type": "function",
+      "module": "Registers"
+    },
+    "$sp": {
+      "signature": "$sp (Register 29)",
+      "description": "Stack Pointer register, pointing to the top of the runtime stack in memory. Grows downward by convention; functions adjust it with addi $sp, $sp, -N to allocate stack frames.",
+      "type": "function",
+      "module": "Registers"
+    },
+    "$ra": {
+      "signature": "$ra (Register 31)",
+      "description": "Return Address register, automatically set by the jal instruction to hold the address of the instruction following the call. Used by jr $ra to return from subroutines.",
+      "type": "function",
+      "module": "Registers"
+    },
+    ".data": {
+      "signature": ".data",
+      "description": "Assembler directive that marks the beginning of the data segment, where variables, strings, and constants are declared using directives like .word, .asciiz, and .byte.",
+      "type": "function",
+      "module": "Directives"
+    },
+    ".text": {
+      "signature": ".text",
+      "description": "Assembler directive that marks the beginning of the code and text segment containing executable instructions. Typically follows the .data section in MIPS assembly programs.",
+      "type": "function",
+      "module": "Directives"
+    },
+    ".globl": {
+      "signature": ".globl label",
+      "description": "Assembler directive that declares a label as globally visible, making it accessible to the linker and other object files. Commonly used with main as the program entry point.",
+      "type": "function",
+      "module": "Directives"
+    },
+    ".asciiz": {
+      "signature": ".asciiz \"string\"",
+      "description": "Assembler directive that stores a null-terminated ASCII string in the data segment, automatically appending a zero byte. Used for strings passed to print_string syscall.",
+      "type": "function",
+      "module": "Directives"
+    },
+    ".word": {
+      "signature": ".word value [, value ...]",
+      "description": "Assembler directive that stores one or more 32-bit integer values in the data segment, each occupying four consecutive bytes with proper word alignment.",
+      "type": "function",
+      "module": "Directives"
+    }
+  }
+}