Module context 

The query binding (spec/surface/README.md §1): a DataContext over the store, so the oqx in-memory engine reproduces the whole OQX surface — roots, intrinsics, reach-through, structural relations, the edge graph, the row functions — without a bespoke compiler. Port of packages/core/src/oqx-js/context.ts.

Rows are the store’s raw column objects (blobs as hex) carrying a hidden tag column (TAG_KEY) naming their target; get routes field / attribute / relation resolution per target, lazily querying the store. Row functions (text, under, …) arrive as methods on the row — the runner rewrites them to $it.fn(…) — since a free function sees no row.

The tier-3 planner (crate::planner) hands the rows its SQL produced back through StoreContext::with_rows_root: the context then serves them as the residual query’s oqx::ROWS_ROOT scan, while every other root, relation, intrinsic and row function still reaches the store — the reference’s rowsRoot context option.

Errors travel the engine’s channel: a failure inside a property read or a row function — a bare target name, a store failure — is the Err of get / call_method (an eval-stage OqxError, since oqx 0.13), which aborts the run exactly like a throw from the reference’s get; the runner maps it to filter_invalid with the same message. The one seam still without a channel is root (the engine reads a named root for the top-level source and for a caret that reaches the root scope), so a store failure during a root scan is kept in StoreContext::take_root_failure and the runner reports it after the run.

One seam differs from the reference and is bridged here:

• the Rust engine expands entries(x) in row position itself (never via call_function), so the _data / _frontmatter / _inline source handles are materialized eagerly as plain objects — one key per top-level property in key order, valued by the scalar-vs-list rule — instead of the reference’s lazy handle. _frontmatter.<k> and entries(_frontmatter) read the same values either way.

Structs

SemanticVec

A query phrase’s embedding: the model whose cache to read and the vector as a float32 little-endian blob.

StoreContext

The store-backed context for one repo.

Enums

Target

The five root collections (spec/surface §1.1): the four live row kinds and, since 4.7, revisions — the history target, one row per revision of the repository’s documents (the revisions × commits join). The reference splits the name in two (Target, the four kinds its planner pushes down and its unknown-names pass first keyed by; Kind/Root, all five); here one enum tags every row, and the planner declines the fifth (crate::planner::root_target is five-wide, compile plans four).

Constants

ABSENT_KEY

The value of a statically SINGLE relation that has no row — _dst on an external or dangling link, _block on a node without one (oqx 0.20, SEMANTICS §3): an object the engine treats as one row with no rows (to_rows empty, is_single true), so _dst { _title } is absent rather than [], while as a VALUE it is absent (materialize), so _dst == null, has(_dst) and _dst._title read as before. The port of the reference’s ABSENT_SINGLE.

ALL_TARGETS

The five root collections, in the order the root object lists them (spec/surface §1.1; revisions the fifth since 4.7).

LAZY_KEY

The key marking a LAZY OWNER row (foreign-key elimination, spec/surface §1, 3.0): the owner a reach-through hands out (_doc on a block, node or edge; _block on a node) carries only the columns the child row already knows — doc_id + path (from the child’s doc_id/src_doc and __path), or block_id + doc_id + __path — tagged with the owner’s target, plus this key. get answers _id, _path, the owner’s own foreign keys, its relations and its properties (which need only the id) from those columns and runs NO statement, exactly like the bare _doc_id; the first read of anything else (_format, _hash, _text, …) loads the full row ([StoreContext::owner_full], memoized per run). The port of the reference’s lazyOwner Proxy. The marker is a tagged row to everything else (identity, render_row_values, materialize, hits) and the hidden key is stripped with the tag.

SCAN_KEY

The key of a lazy ROOT SCAN marker: { "__oqx_scan": "docs" } stands for ^docs / a bare docs at the root until the engine reads it in row position (to_rows) or is about to observe it as a value (materialize — an operand, an argument, a projected item, a key), or probes it through index_for, in which case the scan never runs. The marker never reaches the language: the engine materializes every value it observes, so ==, in, entries(…), size(…), truthiness, distinct and order by see the rows exactly as the reference’s Proxy array shows them. A Value has no identity or laziness of its own, so this is the port of that handle.

SOURCE_HANDLES

The source handles of a document (§1.2): _data is the merged authored view (frontmatter + inline), the other two one source each.

TAG_KEY

The hidden column tagging a store row with its target.

Functions

attributes

The engine attributes per kind (spec/surface §1.2 table).

glob_to_like

A * glob as a LIKE pattern with ESCAPE '\'; escape_backslash also escapes \ (the list surfaces do, within does not).

handle_source

The properties.source a handle narrows a read to: _data → both authored sources (None), _frontmatter / _inline → that source.

reach_throughs

The reach-through handles per kind (§1.2) — each a statically single row of another kind: _doc (the owning document; a revision’s current row; a link’s source), _block (a node’s or link’s source block), _dst (a link’s destination document).

render_row_values

§1.4 rows as values (1.2): a store row that surfaces as a VALUE in a result tree — a nested collect { } / first { } / single { } with an empty projection, or a values item that is a row — renders as { _id, _path } (5.0: the hit envelope’s own keys, spelled as the attributes; the target’s id column as a string; the owning document’s path in the reference form, §1 “Paths”: a docs row’s path, every other row’s __path join column, rooted), never the store row. Everything else recurses, dropping the hidden tag as strip_tags.

scan_of

The target of a lazy root-scan marker, if v is one.

strip_tags

Strip the hidden tag from a value tree (the wire form never carries it).

target_of

The tag of a store row, if it is one.