docs: add Array engine and promote eight-engine architecture

Add Array engine documentation and bitemporal query reference.
Promote Timeseries and Spatial from "columnar profiles" to peer engines
with their own storage-engines/ pages. Update all cross-references,
engine counts, and the sidebar to reflect eight peer engines plus Graph
and FTS as cross-engine overlays.

Expand vector-search reference with quantization codec comparison table,
index implementation details (Vamana, NaviX, SIEVE, MetaEmbed, SPFresh,
Matryoshka), and vector-primary collection DDL. Add cross-engine identity
section to the architecture overview.

Author: farhan-syah

docs/administration/rls.rdx

@@ -1,6 +1,6 @@
 ---
 title: Row-Level Security
-description: Per-row filtering based on authenticated user context. Works across all seven engines.
+description: Per-row filtering based on authenticated user context. Works across all eight engines.
 ---
 
 # Row-Level Security (RLS)

docs/architecture/overview.rdx

@@ -55,3 +55,20 @@ nodedb-client / FFI / WASM
 ```
 
 Both paths produce the same plan and execute identically on the Data Plane.
+
+## Cross-Engine Identity
+
+Every row in every engine — document, KV, columnar, timeseries, spatial, vector, array, graph node, FTS posting — carries a stable global `u32` **surrogate** allocated at insert from a WAL-durable, Raft-replicated monotonic counter. Every engine keys its internal indexes on the surrogate, so cross-engine prefilter and join reduce to roaring-bitmap intersections with **zero per-query translation**.
+
+A query like "find product cells whose embedding is near `$q`, that have FTS hits for `'memory leak'`, that live within 5km of point P, in tenant 42" turns into:
+
+```
+vector_index.search($q, k)         → roaring bitmap A
+fts_index.match("memory leak")     → roaring bitmap B
+spatial_index.dwithin(P, 5km)      → roaring bitmap C
+metadata_index.tenant_id = 42      → roaring bitmap D
+
+A ∩ B ∩ C ∩ D                      → final candidate surrogate set
+```
+
+No `HashMap<surrogate, doc_id>` translations between hops. Adding a new engine does not require new translation paths — it just allocates surrogates from the same counter. This is the mechanism behind every cross-engine query example you'll see in the SQL reference.

docs/crdt-sync/offline-sync.rdx

@@ -65,4 +65,4 @@ await db.execute("INSERT INTO invoices ...");
 await db.sync("wss://origin.example.com/sync");
 ```
 
-All seven engines work locally with sub-millisecond reads. CRDT sync is transparent.
+All eight engines work locally with sub-millisecond reads. CRDT sync is transparent.

docs/crdt-sync/overview.rdx

@@ -33,4 +33,4 @@ Multiple devices converge to the same state regardless of operation order. Loro'
 
 ## Local Engine Capabilities
 
-All seven engines work locally on NodeDB-Lite: vector search, graph traversal, document storage, columnar queries, KV lookups, FTS, and CRDT state — with sub-millisecond reads and no network dependency.
+All eight engines work locally on NodeDB-Lite: document, KV, columnar, timeseries, spatial, vector, array, plus graph traversal and FTS overlays — with sub-millisecond reads and no network dependency.

docs/data-modeling/collections.rdx

@@ -35,7 +35,7 @@ CREATE COLLECTION sessions (key TEXT PRIMARY KEY) WITH (engine='kv');
 
 ## Storage Engines
 
-NodeDB has seven peer engines. Pick one per collection via `WITH (engine='<name>')`. The default (no `engine=`) is `document_schemaless`.
+NodeDB has eight peer engines. Seven of them are picked per collection via `WITH (engine='<name>')` — the default (no `engine=`) is `document_schemaless`. The eighth, Array, uses its own `CREATE ARRAY` DDL family. See [Array Engine](../storage-engines/array) for that path.
 
 | Engine                | Selector                            | Best for                                          |
 | --------------------- | ----------------------------------- | ------------------------------------------------- |

docs/introduction/what-is-nodedb.rdx

@@ -1,32 +1,34 @@
 ---
 title: What is NodeDB
-description: A distributed hybrid database with seven engines for multi-modal AI and agentic workloads.
+description: A distributed hybrid database with eight peer engines for multi-modal AI and agentic workloads.
 ---
 
 # What is NodeDB
 
-NodeDB is a single Rust binary that provides seven data engines — Vector, Graph, Document (schemaless + strict), Columnar (with Timeseries and Spatial profiles), Key-Value, and Full-Text Search — each built with purpose-specific data structures. All engines share the same storage, memory, and query planner. Cross-engine queries execute in one process with zero network hops.
+NodeDB is a single Rust binary that provides eight peer engines — Document (schemaless), Document (strict), Key-Value, Columnar, Timeseries, Spatial, Vector, and Array — sharing one storage core, plus Graph and Full-Text Search as cross-engine overlays on any collection. Seven of the eight are selected per-collection via `WITH (engine='<name>')`; Array uses its own `CREATE ARRAY` DDL family. Each engine is built with purpose-specific data structures. All share the same storage, memory, and query planner. Cross-engine queries execute in one process with zero network hops.
 
 ## The Problem
 
 Modern applications don't fit in one database. A healthcare app needs patient records (relational), medical imaging embeddings (vector), care team relationships (graph), device telemetry (timeseries), and offline-first sync for field workers (CRDT). The industry answer is a polyglot stack: PostgreSQL for relational, Qdrant for vectors, Neo4j for graphs, ClickHouse for timeseries, Redis for caching. Each system has its own protocol, deployment, and failure modes. Cross-database queries require application-level joins.
 
 Some databases claim to solve this by bolting on capabilities — "graph" as recursive JOINs, "timeseries" without columnar compression or continuous aggregation. The features exist in name but not in performance.
 
-## Seven Engines
+## Eight Engines
 
 **Vector** — HNSW index with SQ8, PQ, and IVF-PQ quantization. SIMD-accelerated distance math. Adaptive bitmap pre-filtering.
 
 **Graph** — CSR adjacency index with 13 native algorithms (PageRank, WCC, Louvain, SSSP, etc.) and a Cypher-subset MATCH pattern engine. GraphRAG fusion with vector search.
 
 **Document** — Two modes per collection. Schemaless: MessagePack blobs with CRDT sync. Strict: Binary Tuples with O(1) field extraction and 3-4x cache density over BSON.
 
-**Columnar** — Per-column compression (ALP, FastLanes, FSST, Gorilla, LZ4). Block statistics and predicate pushdown. Three profiles: Plain (general analytics), Timeseries (append-only, retention, continuous aggregation), Spatial (R*-tree, geohash, H3).
+**Columnar / Timeseries / Spatial** — Three peer engines sharing one compressed-column storage core (ALP, FastLanes, FSST, Gorilla, LZ4 codecs; block statistics; predicate pushdown). `columnar` for general analytics; `timeseries` adds append-only ingest, retention, and continuous aggregation; `spatial` adds R*-tree, geohash, and H3 indexing.
 
 **Key-Value** — Hash-indexed O(1) point lookups with typed value fields. Native TTL, secondary indexes, atomic INCR/CAS, and predicate-filtered scans. SQL-queryable and joinable.
 
 **Full-Text Search** — Block-Max WAND optimized BM25 with 16 Snowball stemmers, 27-language stop words, CJK bigram tokenization, posting compression, fuzzy matching, and native hybrid vector fusion.
 
+**Array** — ND sparse multi-dimensional engine with tile-based storage, Z-order indexing, per-tile MBR statistics, and bitemporal cells. Replaces TileDB / Zarr / SciDB / Rasdaman for genomics, single-cell biology, raster cubes, and climate models.
+
 **CRDT** — Loro-backed conflict-free replicated data types. AP on the edge, CP in the cloud. SQL constraint validation at sync time with compensation hints.
 
 ## Three Deployment Modes
@@ -35,7 +37,7 @@ Some databases claim to solve this by bolting on capabilities — "graph" as rec
 
 **Origin (local)** — Same binary, single-node. No cluster overhead. Like running PostgreSQL locally.
 
-**NodeDB-Lite (embedded)** — In-process library for phones, browsers (WASM), and desktops. All seven engines run locally with sub-millisecond reads. CRDT sync to Origin via WebSocket.
+**NodeDB-Lite (embedded)** — In-process library for phones, browsers (WASM), and desktops. All eight engines run locally with sub-millisecond reads. CRDT sync to Origin via WebSocket.
 
 ## PostgreSQL Compatible
 

docs/reference/engine-config.rdx

@@ -28,9 +28,9 @@ Graph, KV, and FTS engines do not have dedicated budget config fields. They draw
 | Memtable threshold | 32M entries | Flush to segment threshold |
 | Compaction levels  | 8x8         | Level-based compaction     |
 
-## Columnar Engine
+## Columnar / Timeseries / Spatial Engines
 
-The Timeseries profile uses `timeseries_budget_fraction` (default 10%).
+The `timeseries` peer engine has its own memory budget knob `timeseries_budget_fraction` (default 10%); `columnar` and `spatial` draw from the columnar engine pool.
 
 | Parameter    | Default | Description                |
 | ------------ | ------- | -------------------------- |
@@ -51,5 +51,5 @@ These are the actual config fields controlling memory allocation:
 | `vector_budget_fraction`    | 0.30    | HNSW index and vector data        |
 | `sparse_budget_fraction`    | 0.15    | Graph, KV, FTS, and metadata      |
 | `crdt_budget_fraction`      | 0.10    | CRDT state and sync buffers       |
-| `timeseries_budget_fraction`| 0.10    | Columnar timeseries profile       |
+| `timeseries_budget_fraction`| 0.10    | Timeseries peer engine            |
 | `query_budget_fraction`     | 0.20    | Query execution working memory    |

docs/sql/vector-search.rdx

@@ -60,17 +60,81 @@ FROM articles
 ORDER BY dist LIMIT 10;
 ```
 
-| Argument            | Type    | Notes                                              |
-| ------------------- | ------- | -------------------------------------------------- |
-| `quantization`      | string  | `none`, `sq8`, `pq`, `ivf_pq`, `rabitq`            |
-| `oversample`        | u32     | Candidates fetched before re-ranking                |
-| `query_dim`         | u32     | Override query dimensionality                       |
-| `meta_token_budget` | u32     | Metadata pre-filter budget                          |
-| `ef_search`         | u32     | HNSW search-time `ef`                               |
-| `target_recall`     | f32     | Adaptive recall target                              |
+| Argument            | Type    | Notes                                                                                 |
+| ------------------- | ------- | ------------------------------------------------------------------------------------- |
+| `quantization`      | string  | `none`, `sq8`, `pq`, `binary`, `ternary`, `rabitq`, `bbq`, `opq`                      |
+| `oversample`        | u8      | Candidates fetched before re-ranking. Default `3`. Final rerank set is `oversample × ef_search`. |
+| `query_dim`         | u32     | Coarse-to-fine on first-N dims of Matryoshka embeddings. `None` = full dimensionality. |
+| `meta_token_budget` | u8      | MetaEmbed multivec scoring budget for MaxSim / PLAID                                  |
+| `ef_search`         | u32     | HNSW / Vamana search-time beam width. Default `64`.                                   |
+| `target_recall`     | f32     | Adaptive recall target. The cost-model planner picks oversample / ef_search to hit this. |
 
 Unknown names, duplicate keys, positional 3rd args, or wrong operators (`=` instead of `=>`) all return typed errors that list the canonical names.
 
+### Quantization Choice
+
+| Codec     | Bits/dim | Recall (typ.) | When to pick it                                                |
+| --------- | -------- | ------------- | -------------------------------------------------------------- |
+| `none`    | 32       | 100%          | Small index (< 1M vectors), latency not critical               |
+| `sq8`     | 8        | ~99%          | Balanced default for medium index sizes                        |
+| `pq`      | ~2       | ~95%          | Large memory-bound indexes; classic Product Quantization       |
+| `opq`     | ~2       | ~96%          | PQ + learned random rotation; minor accuracy bump over `pq`    |
+| `rabitq`  | 1        | ~97%          | Frontier 1-bit with `O(1/√D)` error bound (SIGMOD 2024)        |
+| `bbq`     | 1        | ~98%          | Centroid-asymmetric 1-bit + 14-byte corrective; oversample-rerank |
+| `binary`  | 1        | ~85%          | Hamming-only, no rerank — for ultra-cold tiers                 |
+| `ternary` | 1.58     | ~96%          | BitNet-style `{-1, 0, +1}` — cold/hot pack for AVX-512         |
+
+The cost-model planner (`target_recall`) will pick `oversample` and `ef_search` automatically once you set the recall target. Manually set those two only when you need a hard latency ceiling.
+
+## Index Implementations
+
+You don't pick the underlying index directly — it's chosen by the planner from collection metadata + workload signals:
+
+- **HNSW** — in-memory hierarchical graph, the default for moderate-size indexes
+- **Vamana / DiskANN** — flat-beam SSD-resident graph for billion-scale on a single node (`Tier 2` of the vector frontier)
+- **NaviX adaptive-local filtered traversal** (VLDB 2025) — switches per-hop between standard / directed / blind heuristics based on local selectivity. Replaces classic ACORN-1 filtered ANN.
+- **SIEVE workload-driven subindex collections** — the planner builds specialized HNSW subindices for stable predicates (e.g. `tenant_id`) and routes filtered queries to them.
+- **MetaEmbed multi-vector + ColBERT MaxSim + PLAID** (ICLR 2026) — learnable Meta Tokens replace per-token explosion; budgeted MaxSim at query time via `meta_token_budget`.
+- **Matryoshka adaptive-dim querying** — coarse-to-fine ranking on the first-N dimensions of MRL embeddings via `query_dim`.
+- **SPFresh streaming updates** (SOSP 2023) — LIRE topology-aware local rebalancing; no full-rebuild stalls when vectors are added/removed.
+
+## Vector-Primary Collections
+
+By default, vectors are an *index* attached to a column on a normal collection — the document/strict store is the source of truth, and the vector index is a side path. For pure-vector workloads (RAG corpora, recommendation memory, embedding stores) you can flip a collection into **vector-primary** mode, where the vector index becomes the primary access path and the document store is a metadata sidecar:
+
+```sql
+CREATE COLLECTION corpus (
+    id UUID DEFAULT gen_uuid_v7(),
+    embedding FLOAT[384],
+    title TEXT,
+    tenant_id UUID,
+    created_at TIMESTAMP DEFAULT now()
+) WITH (
+    primary='vector',
+    vector_field='embedding',
+    dim=384,
+    metric='cosine',
+    quantization='rabitq',
+    m=32,
+    ef_construction=200,
+    payload_indexes=['tenant_id', 'created_at']
+);
+```
+
+| Option            | Notes                                                                |
+| ----------------- | -------------------------------------------------------------------- |
+| `primary`         | `'document'` (default), `'strict'`, `'kv'`, or `'vector'`            |
+| `vector_field`    | Required when `primary='vector'`. Column name of the embedding.       |
+| `dim`             | Required. Embedding dimensionality.                                   |
+| `metric`          | `'cosine'`, `'l2'`, `'inner_product'`, etc.                          |
+| `quantization`    | Storage-level codec (same vocabulary as the query-time arg above).   |
+| `m`, `ef_construction` | HNSW build-time parameters.                                     |
+| `payload_indexes` | Per-field equality / range / boolean indexes over the metadata sidecar for filtered ANN. Replaces Pinecone metadata filters. |
+
+In vector-primary mode the planner treats the vector index as the source of truth for IDs; metadata fetches only happen for hit IDs. Cross-engine queries, CRDT sync, and SQL semantics all keep working — `primary='vector'` is purely an *access-path* hint, not a different engine.
+
+Default `primary='document'` is unchanged: the existing `CREATE VECTOR INDEX ON ...` syntax continues to work for vector-as-side-index workloads.
+
 ## Hybrid Vector + Text (RRF)
 
 ```sql