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 $self receiver (see the runner’s AST rewrite), 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).

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 } (3.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.