feat(docs): add Graph Engine, Document Engine, and NodeDB-Lite sections

Introduce three entirely new documentation sections that were absent from
the initial scaffold:

- engines/graph/: CSR index internals, GraphRAG integration, traversal
  query reference, and engine overview
- engines/document/: JSON functions, secondary indexes, and engine overview
- nodedb-lite/: embedded/edge runtime overview, quickstart, Rust and
  JavaScript SDKs, iOS/Android guide, sync protocol, shape definitions,
  and offline compensation semantics

Also adds query/aggregations.rdx and query/joins.rdx to the SQL query
reference, covering GROUP BY / window functions and join strategies
respectively.

Author: farhan-syah

engines/document/json-functions.rdx

@@ -0,0 +1,358 @@
+---
+title: Document Field Functions
+description: doc_get, doc_exists, doc_array_contains UDFs for nested access.
+---
+
+# Document Field Functions
+
+NodeDB provides user-defined functions (UDFs) to extract and query nested fields within MessagePack documents. These enable flexible querying of semi-structured data.
+
+## Core Functions
+
+### doc_get(document, path) → value
+
+Extract a value from a document at the specified path.
+
+**Parameters**:
+- `document`: MessagePack blob column
+- `path`: String path to field (dot-notation or array subscript)
+
+**Returns**: Extracted value, or NULL if path doesn't exist
+
+**Examples**:
+
+```sql
+-- Simple field
+SELECT doc_get(data, 'title') as title FROM documents;
+
+-- Nested field
+SELECT doc_get(data, 'metadata.author') as author FROM documents;
+
+-- Array element (0-indexed)
+SELECT doc_get(data, 'tags.0') as first_tag FROM documents;
+
+-- Deep nesting
+SELECT doc_get(data, 'metadata.settings.notifications.email') as email_notif
+FROM documents;
+```
+
+**Return type inference**:
+
+```sql
+-- Automatically typed based on document value
+SELECT
+  doc_get(data, 'title') as title_string,           -- returns STRING
+  doc_get(data, 'count') as count_int,              -- returns INTEGER
+  doc_get(data, 'score') as score_float,            -- returns FLOAT
+  doc_get(data, 'created') as timestamp,            -- returns TIMESTAMP
+  doc_get(data, 'active') as is_active              -- returns BOOLEAN
+FROM documents;
+```
+
+**Path notation**:
+
+```sql
+-- Dot notation (preferred)
+doc_get(data, 'user.email')         -- user.email field
+doc_get(data, 'tags.0')             -- first element of tags array
+
+-- Bracket notation (alternative)
+doc_get(data, 'user[email]')
+doc_get(data, 'tags[0]')
+
+-- Escaped dots (if field contains literal dot)
+doc_get(data, 'config\.version')    -- config.version field
+```
+
+### doc_exists(document, path) → boolean
+
+Check if a field exists in a document without extracting it.
+
+**Parameters**:
+- `document`: MessagePack blob
+- `path`: String path
+
+**Returns**: TRUE if path exists, FALSE otherwise
+
+**Examples**:
+
+```sql
+-- Filter documents that have a specific field
+SELECT id FROM documents
+WHERE doc_exists(data, 'author');
+
+-- Check nested field
+SELECT id FROM documents
+WHERE doc_exists(data, 'metadata.email');
+
+-- Combine with value extraction
+SELECT
+  id,
+  CASE WHEN doc_exists(data, 'verified')
+    THEN doc_get(data, 'verified')
+    ELSE FALSE
+  END as is_verified
+FROM documents;
+```
+
+**Use cases**:
+
+```sql
+-- Find incomplete documents (missing required field)
+SELECT id FROM documents
+WHERE NOT doc_exists(data, 'required_field');
+
+-- Process only documents with optional fields
+SELECT id, doc_get(data, 'optional_field')
+FROM documents
+WHERE doc_exists(data, 'optional_field');
+
+-- Count documents with a feature
+SELECT doc_get(data, 'type'), COUNT(*)
+FROM documents
+WHERE doc_exists(data, 'premium_features')
+GROUP BY doc_get(data, 'type');
+```
+
+### doc_array_contains(array_field, value) → boolean
+
+Check if an array field contains a specific value.
+
+**Parameters**:
+- `array_field`: Result of doc_get() extracting array, or array literal
+- `value`: Value to search for in array
+
+**Returns**: TRUE if value found, FALSE otherwise
+
+**Examples**:
+
+```sql
+-- Simple array membership
+SELECT id FROM documents
+WHERE doc_array_contains(doc_get(data, 'tags'), 'ai');
+
+-- Multiple membership checks
+SELECT id FROM documents
+WHERE doc_array_contains(doc_get(data, 'tags'), 'ai')
+  AND doc_array_contains(doc_get(data, 'tags'), 'database');
+
+-- Find documents NOT containing a tag
+SELECT id FROM documents
+WHERE NOT doc_array_contains(doc_get(data, 'tags'), 'deprecated');
+```
+
+**Type matching**:
+
+```sql
+-- String array
+WHERE doc_array_contains(doc_get(data, 'tags'), 'ai')
+
+-- Integer array
+WHERE doc_array_contains(doc_get(data, 'priorities'), 1)
+
+-- Mixed type arrays (searches by value AND type)
+SELECT id FROM documents
+WHERE doc_array_contains(doc_get(data, 'values'), 3.14)
+```
+
+**Performance**: Uses index if array field is indexed; otherwise O(n) scan.
+
+## Advanced Patterns
+
+### Exploding Arrays
+
+Convert array field into multiple rows:
+
+```sql
+-- One row per tag
+SELECT id, UNNEST(doc_get(data, 'tags')) as tag
+FROM documents;
+
+-- Result:
+-- id    | tag
+-- doc:1 | ai
+-- doc:1 | database
+-- doc:2 | vector
+```
+
+### Array Aggregation
+
+Combine array values across documents:
+
+```sql
+-- All unique tags across all documents
+SELECT DISTINCT tag
+FROM (
+  SELECT UNNEST(doc_get(data, 'tags')) as tag
+  FROM documents
+) t
+ORDER BY tag;
+
+-- Most common tag
+SELECT tag, COUNT(*) as count
+FROM (
+  SELECT UNNEST(doc_get(data, 'tags')) as tag
+  FROM documents
+) t
+GROUP BY tag
+ORDER BY count DESC
+LIMIT 1;
+```
+
+### Type Casting
+
+Convert extracted fields to specific types:
+
+```sql
+-- String to integer
+SELECT
+  id,
+  CAST(doc_get(data, 'status_code') AS INTEGER) as code
+FROM documents;
+
+-- Timestamp parsing
+SELECT
+  id,
+  CAST(doc_get(data, 'created') AS TIMESTAMP) as created_at
+FROM documents
+ORDER BY created_at DESC;
+
+-- JSON to type-specific value
+SELECT
+  id,
+  doc_get(data, 'score')::FLOAT as score
+FROM documents
+WHERE CAST(doc_get(data, 'score') AS FLOAT) > 0.8;
+```
+
+### Combining with Full-Text Search
+
+Extract text for BM25 ranking:
+
+```sql
+-- Search full text, extract metadata
+SELECT
+  id,
+  doc_get(data, 'title') as title,
+  bm25_score(doc_get(data, 'content'), 'neural networks') as relevance
+FROM documents
+WHERE bm25_score(doc_get(data, 'content'), 'neural networks') > 0.0
+ORDER BY relevance DESC
+LIMIT 20;
+```
+
+### Conditional Extraction
+
+Handle missing or optional fields:
+
+```sql
+-- Use COALESCE for defaults
+SELECT
+  id,
+  COALESCE(doc_get(data, 'name'), 'Unknown') as name,
+  COALESCE(doc_get(data, 'priority'), 0) as priority
+FROM documents;
+
+-- Conditional logic
+SELECT
+  id,
+  CASE
+    WHEN doc_exists(data, 'premium') THEN doc_get(data, 'premium')
+    ELSE FALSE
+  END as has_premium
+FROM documents;
+```
+
+## Performance Considerations
+
+### Path Depth
+
+Extraction cost increases with nesting depth:
+
+```sql
+-- Fast (1 level)
+doc_get(data, 'title')           -- ~100ns
+
+-- Medium (3 levels)
+doc_get(data, 'metadata.author.name')  -- ~200ns
+
+-- Slow (5+ levels)
+doc_get(data, 'a.b.c.d.e')       -- ~500ns
+```
+
+**Optimization**: Flatten deeply nested structures or precompute derived fields.
+
+### Indexing for Performance
+
+Index frequently extracted fields:
+
+```sql
+-- This query is slow (no index):
+SELECT id FROM documents
+WHERE doc_get(data, 'status') = 'active'
+ORDER BY doc_get(data, 'created');
+-- Full scan: 100ms
+
+-- Add index:
+CREATE INDEX idx_status ON documents (doc_get(data, 'status'));
+-- Now: 5-10ms (index scan)
+```
+
+### Array Operations
+
+Array membership is O(n) unless indexed:
+
+```sql
+-- Without index: scans all elements
+SELECT id FROM documents
+WHERE doc_array_contains(doc_get(data, 'tags'), 'ai');
+-- ~50ms for 1M documents
+
+-- With index:
+CREATE INDEX idx_tags ON documents USING UNNEST(doc_get(data, 'tags'));
+-- Now: 1-5ms
+```
+
+## Examples: Real-World Queries
+
+**User profile queries**:
+
+```sql
+SELECT
+  doc_get(data, 'username') as username,
+  doc_get(data, 'email') as email,
+  doc_array_contains(doc_get(data, 'roles'), 'admin') as is_admin
+FROM documents
+WHERE doc_get(data, 'type') = 'user'
+  AND doc_exists(data, 'verified_at');
+```
+
+**Log filtering and analysis**:
+
+```sql
+SELECT
+  doc_get(data, 'timestamp') as ts,
+  doc_get(data, 'level') as level,
+  doc_get(data, 'message') as msg
+FROM documents
+WHERE doc_get(data, 'type') = 'log'
+  AND doc_get(data, 'level') IN ('ERROR', 'WARN')
+  AND doc_get(data, 'timestamp') >= NOW() - INTERVAL '1 hour'
+ORDER BY ts DESC;
+```
+
+**Product catalog with tags**:
+
+```sql
+SELECT
+  id,
+  doc_get(data, 'name') as name,
+  doc_get(data, 'price') as price
+FROM documents
+WHERE doc_get(data, 'type') = 'product'
+  AND doc_array_contains(doc_get(data, 'categories'), 'electronics')
+  AND CAST(doc_get(data, 'price') AS FLOAT) < 100
+ORDER BY doc_get(data, 'rating') DESC;
+```
+
+See [Document Engine Overview](/engines/document/overview) for storage and [Secondary Indexes](/engines/document/secondary-indexes) for optimization.