@omgbase/oqx 0.18.0 → 0.21.0

package/CHANGELOG.md

@@ -4,6 +4,36 @@ All notable changes to `@omgbase/oqx` are recorded here. The format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); versions follow
 [Semantic Versioning](https://semver.org/) (pre-1.0: a minor bump may break).
 
+## [0.21.0] - 2026-10-13
+
+### Minor
+- **OQX 0.21 — template literals** (`spec/oqx` 0.20 → 0.21; new suite `template-literals` (50 cases) + 2 in `errors-eval`: 1258 → 1310 fixtures). `` `text ${expr} text` `` is a backtick-delimited **string value** with `${…}` interpolations, usable wherever a value stands — a `select` item (`` label: `${title} (${era})` ``), a `where` operand, an `order by` key, a function argument or method receiver, the haystack of `in`, a nested block's item reading the enclosing row (`` jobs collect { label: `${^title}: ${employer}` values } ``). Semantics (SEMANTICS §7b): the text and each interpolated value's **string form** (§7: a number without a fraction when integer-valued, `true`/`false` as the words) concatenated; **absent propagates** — any absent interpolation makes the whole literal absent, as `+` does; **a list, a record or a range cannot be interpolated** — an eval error `cannot interpolate … it is a list / a record / a range` (where `+` leaves such operands unspecified, a template literal refuses them); every interpolation is evaluated, in order, before the result is decided. Lexically (GRAMMAR §1, §4): the text decodes with the **same escapes as a string** (`\n` `\t` `\r` `\0`, `\<c>` for any other `<c>` — so `` \` `` keeps a backtick, `\$` a dollar that opens nothing, `\\` a backslash); **newlines are kept verbatim** (a literal may span lines); a `$` not followed by `{`, braces outside an interpolation and quotes are text; an interpolation holds one full expression with **balanced braces**, so it may hold a `{ … }` block (`` `${jobs single { employer values where primary }}` ``) or another template literal, to any depth, read at the enclosing scope depth (`^`, `N^` as usual). Errors: `unterminated template literal at N` and `` unterminated ${…} interpolation … `` are lex errors; `` empty interpolation `${}` `` (offset of the `${`) and `expected '}' to close the `${…}` interpolation` are parse errors; a template literal is a literal — not a receiver, not a bracket receiver, and an unaliased item needs an alias. **Bindings**: a tagged-template fragment that ends inside a backtick literal is the lex error `unterminated template literal … a ${…} binding cannot stand inside a backtick literal` (fragments lex independently). **AST** (AST.md): new node `template { parts: (string | Expr)[] }` with `parts` strictly alternating decoded text strings and expressions (odd length, text first and last: `` `${a}` `` is `["", a, ""]`); the text parts are plain strings, not nodes — `visit`/`transform` skip them; `CHILDREN.template = [parts]`; `isExpr` true; `build.template(parts)`; a `template` node spans its backticks, each interpolated expression itself. **Printer**: a template literal prints as one, its text escaped (`\\`, `` \` ``, `\$` before a `{`, the control escapes) and each interpolation as `${…}`; round-trip law holds over every fixture. Lexer: new token types `tmpl_start` / `tmpl_text` / `tmpl_interp_start` / `tmpl_interp_end` / `tmpl_end`, a mode stack per fragment; the backtick is no longer an `unexpected character`. Planners: the SQLite adapter leaves a template residual (not translatable); `exprRaiseFree` is false for a literal with an interpolation (the data decides whether it raises). `LANGUAGE_VERSION` 0.21.
+- `@omgbase/oqx-syntax`: `LANGUAGE_VERSION` 0.21; new token classes `template` (`string.template.oqx`) and `interpolation` (`punctuation.section.interpolation.oqx`); every grammar enters a template state at the backtick, re-enters the language at `${` and tracks the braces of the interpolation (TextMate begin/end rules `template` / `template-interpolation` / `template-block`, Monarch states `template` / `templateInterpolation` / `templateBlock`, a mode stack in the CodeMirror stream state, a Prism `template` token whose interpolations re-enter the grammar through `rest`, braces balanced to three levels); the backtick left `ILLEGAL_CHARACTERS`; `TEMPLATE` / `TEMPLATE_LITERAL` exported; backtick auto-closing pairs; assets regenerated; parity over every fixture.
+
+## [0.20.0] - 2026-10-11
+
+### Minor
+- OQX 0.20 (`spec/oqx` 0.19 → 0.20; 1188 → 1258 fixtures, three new suites `tuples`, `identity`, `cardinality`):
+
+  - **`follow` loses its options block.** A brace after *any* destination opens that destination's block (`follow children { depth 2 }`, `follow a, children { id != "root" }`, `follow entries(kids) { where … }`), with the 0.17 body rules. Two clauses belong to a destination block alone, after `where` in the fixed order: `depth <1..8>` (this destination expands a frontier row only while its `$depth < n`) and `frontier <expr>` (an occurrence reached through this destination for which it holds is a frontier; read with `^` the walk's enclosing scope; seeds are never frontiers). The former `where` option is the block's `where`; `by` is gone. When several destinations reach a row in one step the first governs the occurrence. **The body that carries the `follow` may carry `frontier <expr>` too** (Brendan, 2026-10-11): it applies to the SEEDS — a seed for which it holds (read in the seed's own scope, `^` the enclosing scope, like `where`) is `$stop == "frontier"` and is not expanded, while it stays in the result — so every block that feeds rows into the walk says which of its rows are frontiers, and the frontier relevant to the current `$it` is defined separately from each destination's. The clause order of every body is `select from where frontier follow order by limit offset` (a destination block's adds `depth` after `frontier`); a body-level `frontier` without a `follow` is the parse error `` `frontier` needs a `follow` ``, a body-level `depth` an error naming the destination block; inside a destination block `frontier` is always the destination's. AST: `follow` keeps only `destinations`/`distinct`; `subquery` gains `frontier`/`depth`, `query` gains `frontier`; `print` writes `follow x collect { where … depth 2 }` and a body's `frontier` between `where` and `follow`.
+  - **Tuples.** `(e1, e2, …)` with two or more elements is a value and a receiver: the elements concatenated with one level of flattening (a collection contributes its items, a row itself; an absent element nothing, a `null` is kept; duplicates kept). `size((a, b))`, `"x" in (tags, aliases)`, `(mom, dad, siblings) { name values }`, `follow (before, after) { depth 2 }` (one destination over the union). New AST node `tuple { items }`.
+  - **Identity is `$key`.** One meaning — the key a row is known by — for `follow` cycle detection, the per-step union, `follow distinct`, `distinct` over unprojected rows, `is`, and reading `$key` on any row. The default is the host's identity through a new `DataContext` seam (TS: optional `identityOf(row)`, replacing the required `identity`, which stays as a deprecated alias for one minor; Rust: `identity` now has a structural default), else the row's structural value; an entry's identity is its key. The language never names an `id` property: the "`id` if present" rule is removed, and the in-memory `DefaultContext` names no identity. A block may project `$key: <expr>` to give the rows it yields that identity (`select name, $key: email from people follow next { $key: email }`); in a destination block `$key:` is not a column. Caveat: identities compare as values across the whole walk, so destinations that can reach the same rows should project the same `$key`.
+  - **Result shape by receiver cardinality.** In row position an array is a collection and a non-array object is one row: a `collect` over it — `doc { title }`, `title from doc`, a nested `d: dst { title }` — yields the one record (or absent when filtered out; `doc { status == "active" }` is a conditional reach-through), not a one-element list; `values` the one value; `first`/`single` that object. A scalar in row position is an eval error (`` `s` is a string ("abc"), not a collection or an object ``) instead of a one-row collection — `list(s)` says it explicitly. A `from` re-projection or a `follow` makes the result plural. Hosts say which of their objects are collections through the new optional `DataContext.isSingle` (TS; default: a non-iterable object is one row) / `is_single` (Rust; default `true`). TS `OqxResult` for `collect` gains `single: boolean` (`unwrap` yields the record or `null`); Rust gains `OqxResult::Record(Option<Value>)`.
+  - **Sugar closures.** `x { … }` ≡ `x collect { … }` wherever a value is accepted, function arguments included (`size(children { is checked })`); `x distinct { … }` ≡ `x collect distinct { … }`.
+
+  omgbase binding (surface stays 3.0; the dialect follows the language):
+
+  - `DataContext.identityOf` (TS) / `identity` (Rust) answers a store row's id for every kind (`doc_id`, `block_id`, `node_id`, `edge_id`), so `$key` on any hit is its id and walks dedup by it as before; the binding no longer relies on the removed `id`-property rule.
+  - The statically single relations `doc`, `block` and `dst` hand out an absent-single marker when they have no row, so `dst { title }` on a link row is one record and, on an external or dangling link, absent — not `[]`; as a value the marker is absent (`dst == null`, `has(dst)`, `dst.title` unchanged). The Rust context's `is_single` marks the lazy root scans as collections.
+  - The `graph` tool compiles to `follow distinct <dir>_links collect { from <dst|doc> depth <n> }`; `query_syntax`, the `query` tool description, both help cards, `docs/query-language.md`, `docs/graph-and-query.md`, `docs/mcp-api.md` and the OQX tutorial describe the 0.20 forms (body-level `frontier` included); the planners treat a destination block's `frontier`/`depth` as its own, never push a tuple down, and a body with `frontier` plans like one with a `follow` — in memory (pinned on both sides). `spec/surface` `query-follow::body-frontier-keeps-seeds-unexpanded` walks the processes with the unverified one kept but not expanded.
+  - `spec/surface` fixtures using the old options block are rewritten to the destination-block forms (`… collect { from dst depth 2 }`; `by type` → `{ $key: type from dst }`) and regenerated; `spec/cli` and `interop.json` regenerated with them.
+  - `@omgbase/oqx-syntax`: `LANGUAGE_VERSION` 0.20; `FOLLOW_OPTIONS` → `DESTINATION_CLAUSES` (`frontier`, `depth`; `by` is no longer a word of the language), assets regenerated.
+
+## [0.19.0] - 2026-10-10
+
+### Minor
+- OQX language 0.19 — outer-reference `follow` destinations take the implicit `collect`. A `follow` destination whose receiver is headed by an outer reference (`^docs`, `^^root.rel`, `0^docs`, `^$it.docs`, with any member chain) can never be a plain destination (plain destinations are relations of the current row), so a `{` right after it now opens a **destination block** with the implicit `collect`: `follow refs(before), ^docs { where ^$path in list(after) }` walks `before` references forward and, backward, every document whose `after` names the frontier row — exactly `^docs collect { … }` with the 0.17 body rules (where-first, projections). Until 0.18 that query failed with the outer-reference error, because the 0.17 carve-out reserved a brace after the last destination for the options block. Any other receiver (a bare relation, a call like `refs(before)` or `entries(kids)`, a binding) keeps that reading: a brace after it is the options block when it is the last destination (`follow children { depth 2 }`, `follow a, children { depth 2 }`) and the "a destination block needs its consumer" error when the brace holds a predicate. An options block may still follow a trailing destination block (`follow ^docs { where … } { depth 2 }`). A plain `follow ^children` (no brace, no consumer) is still an error; its message now names both block spellings: `` `follow` takes a relation of the current row (`follow <relation>`); an outer reference walks a root collection only as a destination block — `follow ^docs { where … }` or `follow ^docs collect { … }` ``. Fixtures: 25 new cases across `follow`, `sugar`, `errors-parse` and `ast` (1188 total); the 0.17 sugar case "an outer-reference destination with a brace is the outer-reference error" is replaced by its positive form. `LANGUAGE_VERSION` is 0.19 in both engines and in `@omgbase/oqx-syntax`; the `query_syntax` reference (`@omgbase/core`, `omgbase-surface`) describes the new rule.
+
 ## [0.18.0] - 2026-10-10
 
 ### Minor

package/README.md

@@ -34,7 +34,7 @@ const company = "Globocorp";
 const employees = oqx`
   name, id, title
   from ${people}
-  where jobs exists { where employer == ${company} && !end_date }
+  where jobs exists { where employer == ${company} and not end_date }
 `;
 // → [{ name: "Bob", id: 124, title: "Engineer" }, …]  (current Globocorp employees)
 ```
@@ -56,8 +56,8 @@ once, and every one is optional except `from` at the top level:
 ```
 [ [select] projection ]    name, id, title: label        (or: select distinct …, … values)
 from <collection>          from ${people}
-[ where <predicate> ]      where age >= 18 && jobs exists { where !end }
-[ follow <dest>, … ]       follow children { depth 4 }     (or: follow before, after; follow ^people collect { … })
+[ where <predicate> ]      where age >= 18 and jobs exists { where not end }
+[ follow <dest>, … ]       follow children { depth 4 }     (or: follow before, after; follow ^people { where … })
 [ order by <expr> … ]      order by age desc, name
 [ limit N ]                limit 10
 [ offset N ]               offset 20
@@ -200,19 +200,22 @@ const flags = { beta: { on: true }, legacy: { on: false } };
 oqx`$key values from entries(${flags}) where on`;                    // ["beta"]  (bare `on` reads the value)
 
 oqx`name, on: entries(prefs) collect { $key values where $it } from ${users}`;   // as a nested receiver
-oqx`name from ${users} where entries(prefs) exists { where $key == "dark" && $it }`;
+oqx`name from ${users} where entries(prefs) exists { where $key == "dark" and $it }`;
 ```
 
 `entries(array)` yields numeric index keys, a `Map` yields its entries, and
-absence/scalars yield nothing. `$key` exists **only** in an entry scope — an
-ordinary row or array element has no implicit index; `entries(arr)` is how you
+absence/scalars yield nothing. An entry's `$key` is its key — and since
+language 0.20 `$key` is the **identity** every row is known by (§9): an
+ordinary row's `$key` is the host's identity, structurally the row itself for
+plain data; an array element has no implicit index — `entries(arr)` is how you
 ask for one. As a plain value (not a source) `entries(x)` is an array of
 `{ key, value }` records.
 
 ### 3. Predicates (where)
 
 `where` filters rows. The predicate language has comparisons (`== != < <= > >=`),
-boolean operators (`&& || !`) with grouping `( )`, membership (`in`), arithmetic
+boolean operators — the words `and`, `or`, `not`; the symbols `&& || !` are
+accepted synonyms — with grouping `( )`, membership (`in`), arithmetic
 (`+ - * / %`), and bare truthiness. The `where` keyword is always written — a
 leading expression without it is a projection, and a bare comparison in that
 position is an error that points you at `where`.
@@ -319,7 +322,7 @@ from a row nested one level deeper. A receiver may start with `^` too, which is
 how a nested consumer runs over a named root or an enclosing row's relation:
 
 ```js
-execute("name, peers: ^people collect { name where city == ^city && name != ^name } from people", { people });
+execute("name, peers: ^people collect { name where city == ^city and name != ^name } from people", { people });
 ```
 
 **Correlated subqueries.** Because inner and outer rows often share names, the
@@ -334,7 +337,7 @@ const family = [
 ];
 oqx`
   name,
-  siblings: ${family} collect { name where parent == ^parent && name != ^name }
+  siblings: ${family} collect { name where parent == ^parent and name != ^name }
   from ${family}
 `;
 // [{ name: "Ada", siblings: [{ name: "Ben" }] },
@@ -357,7 +360,7 @@ Methods on a value: `contains`, `startsWith`, `endsWith`, `matches` (regex),
 ```js
 oqx`name from ${people} where title.startsWith("Eng")`;      // → Bob
 oqx`name from ${people} where title.lower() == "director"`;  // → Alice
-oqx`name from ${people} where has(age) && !has(nickname)`;   // present vs absent
+oqx`name from ${people} where has(age) and not has(nickname)`;   // present vs absent
 oqx`name from ${people} where tags.contains("admin")`;       // array membership
 ```
 
@@ -591,8 +594,10 @@ Reached rows expose recursion **intrinsics** in `select` / `order by`:
 graph beyond — a boundary or the depth cap), `$ordinal` (a deterministic 1..N
 rank over the walk, ordered by depth then path), and `$stop`
 (`"interior"` / `"leaf"` / `"frontier"` / `"depth"` / `"cycle"`, precedence
-cycle > frontier > depth > leaf > interior — only `interior` rows expand). Options
-go in a trailing block:
+cycle > frontier > depth > leaf > interior — only `interior` rows expand). A
+brace after a destination opens that destination's **block** (language 0.20),
+whose body has two clauses of its own after `where`: `depth <n>` and
+`frontier <pred>`:
 
 ```js
 oqx`id, stop: $stop from ${tree} follow children { depth 2 } order by $ordinal`;
@@ -604,10 +609,10 @@ a nested block (`kids: children collect { … }`) a bare `$depth` is the nested
 row's own `$depth` property (absent unless the data carries one), and the
 occurrence's depth is `^$depth`. The same holds everywhere the metadata is not
 present — outside a `follow`, `$depth`/`$ordinal`/`$stop`/`$leaf`/`$frontier`
-are ordinary property reads (a row `{ "$depth": 3 }` projects `3`), and `$key`
-is likewise an ordinary property read outside an `entries()` scope. Where the
-metadata exists it wins over a same-named property (language 0.13; before, the
-six names read absent everywhere they were not metadata).
+are ordinary property reads (a row `{ "$depth": 3 }` projects `3`). `$key` is
+the exception: it is the row's identity everywhere (below). Where the metadata
+exists it wins over a same-named property (language 0.13; before, the six names
+read absent everywhere they were not metadata).
 
 The walk is **per-path**: a node reached by N distinct paths yields N
 occurrences, and revisiting an identity already on the current path is admitted
@@ -616,42 +621,134 @@ runaway. `follow distinct` collapses occurrences to reached nodes (the minimal
 `(depth, path)` per identity).
 
 **Destinations** (language 0.14) are comma-separated; the walk is their union.
-A **plain destination** is a relation of the current row (`children`, `doc.out`
-— an outer reference `^rel` or a literal is a parse error). A **destination
-block** is a receiver followed by `collect`, `first` or `single` (optionally
-`distinct`) and a block — the same directive you would write in `select`,
-re-evaluated per frontier row with `^` bound to that row. Its receiver *may* be
-an outer reference, so a walk can compute successors from a named root:
+A **plain destination** is a relation of the current row (`children`, `doc.out`,
+`entries(kids)`, a tuple `(before, after)` — one destination over the union of
+its elements; an outer reference `^rel` on its own or a literal is a parse
+error). A **destination block** is a receiver followed by a block — `children {
+depth 2 }`, `^people { where manager == ^id }`, `(before, after) { depth 2 }`,
+or with its consumer, `^chain first distinct { … }` — the same directive you
+would write in `select`, re-evaluated per frontier row with `^` bound to that
+row. Its receiver *may* be an outer reference, so a walk can compute successors
+from a named root. Since language 0.20 **a brace after any destination opens
+that destination's block** (there is no options block any more):
 
 ```js
 const people = [{ id: 1, manager: null }, { id: 2, manager: 1 }, { id: 3, manager: 1 }, { id: 4, manager: 2 }];
-oqx`id values from ${people} where id == 1 follow ^people collect { where manager == ^id } order by $ordinal`;
+oqx`id values from ${people} where id == 1 follow ^people { where manager == ^id } order by $ordinal`;
 // [1, 2, 3, 4] — the reporting tree under person 1 (`^people` names the root from a top-level walk)
+oqx`id values from ${people} where id == 1 follow ^people { where manager == ^id depth 2 } order by $ordinal`;
+// [1, 2, 3] — `depth` is a clause of the destination block, after its `where`
 
 const chain = [{ id: "a" }, { id: "b", prev: "a" }, { id: "c", prev: "b" }];
-oqx`id values from ${chain} where id == "b" follow distinct ^chain collect { where id == ^prev }, ^chain collect { where prev == ^id } order by $ordinal`;
+oqx`id values from ${chain} where id == "b" follow distinct ^chain { where id == ^prev }, ^chain { where prev == ^id } order by $ordinal`;
 // ["b", "a", "c"] — both directions of a chain; a block may order, bound and `distinct` its rows
 ```
 
-A row's successors are, per destination in order, that destination's rows,
-filtered by the follow `where`, then **unioned by identity within the step**: a
-node reached by two destinations (or twice by one relation) in the same step is
-a single successor. `exists`/`none`/`count` are not destinations (they are
+A row's successors are, per destination in order, that destination's rows
+(shaped by the block's projection, if any), then **unioned by identity within
+the step**: a node reached by two destinations (or twice by one relation) in the
+same step is a single successor, and the destination that reached it first
+governs it. `exists`/`none`/`count` are not destinations (they are
 where-position tests).
 
-The block accepts: `where <succ>` (which successors keep participating),
-`frontier <pred>` (cut a relation that could continue, whichever destination
-reached it), `depth <n>` (1–8), and `by <expr>` (the identity used for cycle
-detection + `distinct` — default `.id` or the object reference). The follow
-`where` is **correlated**: it reads the candidate successor's scope whose parent
-is the frontier row's — a bare name is the candidate's own property, `^name` is
-the row being expanded, `^^name` the walk's enclosing scope (language 0.14;
-before, `^` skipped the frontier row). So `follow doc.in { where
-before.contains(^$path) }` steps only into rows that name the row they were
-reached from. `frontier` and `by` are not correlated: they read the occurrence
-with `^` the enclosing scope, as the body does. Give `follow` a stable identity
-(`.id` or `by`) when your relation returns fresh objects rather than shared
-references.
+A destination block's body is an ordinary block — `where <succ>` (which
+successors keep participating), a projection, `order by`, `limit`/`offset`,
+`distinct` — plus two clauses after `where`: `frontier <pred>` (an occurrence
+this destination reached for which it holds is a frontier — cut, not expanded)
+and `depth <n>` (1–8: this destination expands a frontier row only while its
+`$depth < n`; a destination block's clause alone). The block's `where` is **correlated**: it reads
+the candidate successor's scope whose parent is the frontier row's — a bare name
+is the candidate's own property, `^name` is the row being expanded, `^^name` the
+walk's enclosing scope (language 0.14; before, `^` skipped the frontier row). So
+`follow doc.in { where before.contains(^$path) }` steps only into rows that
+name the row they were reached from. `frontier` is not correlated: it reads the
+occurrence with `^` the enclosing scope, as the body does; seeds are reached
+through no destination and are never frontiers by a destination's rule. **The
+body that carries the `follow` may write `frontier <pred>` too**, after its
+`where` and before `follow`: it applies to the seeds — a matching seed stays in
+the result with `$stop == "frontier"` and is not expanded (`id from tree frontier
+!active follow children { depth 2 }`); read in the seed's scope like the body's
+`where`. Each destination's `frontier` is its own; without a `follow`, a
+body-level `frontier` is a parse error.
+
+**Identity is `$key`** (language 0.20). Cycle detection, the per-step union,
+`follow distinct`, `distinct` over unprojected rows and `is` all compare one
+thing — the identity a row is known by — and reading `$key` on any row returns
+it. The default is the host's (`DataContext.identityOf`), else the row's
+**structural value**; `DefaultContext` names none, so over plain objects two
+objects with the same `id` are two nodes. A block may project `$key: <expr>` to
+give the rows it yields that identity — the body's `select` names the seeds, a
+destination block its successors (where `$key:` is not a column; the rows keep
+their shape):
+
+```js
+const n1 = { id: 1 }, n2 = { id: 2, next: [n1] }; n1.next = [n2];   // a cyclic graph of fresh references
+oqx`id, stop: $stop, $key: id from ${[n1]} follow next { $key: id } order by $ordinal`;
+// [{ id: 1, stop: "interior", $key: 1 }, { id: 2, stop: "interior", $key: 2 }, { id: 1, stop: "cycle", $key: 1 }]
+oqx`name, $key: email from ${people} follow next { $key: email }`;   // known by email at every step
+```
+
+Identities are compared as values across the whole walk, so destinations that
+can reach the same rows should project the same `$key`, or a cycle through both
+may run to the depth cap. Give a cyclic graph of fresh objects a `$key` (or a
+context with `identityOf`) rather than rely on the structural default.
+
+### 9b. Cardinality and tuples (0.20)
+
+In row position an **array** is a collection and a non-array **object** is one
+row: a block over it yields **one record** (or absent, when the row is filtered
+out) rather than a one-element list, `values` the one value, `first`/`single`
+that object — `doc { title }` is `{ title }`, `doc { status == "active" }` is the
+object or absent (a conditional reach-through), `title from doc` the same record.
+A scalar in row position is an eval error (`list(s)` says "one element"
+explicitly); a `from` re-projection or a `follow` is plural. A host says which
+of its objects are collections through `DataContext.isSingle` (a lazy handle);
+by default a non-iterable object is one row.
+
+```js
+oqx`${settings} { theme }`;             // { theme: "dark" }      (one object → one record)
+oqx`${[settings]} { theme }`;           // [{ theme: "dark" }]    (a collection → a list)
+oqx`from list(${settings})`;            // [settings]             (the explicit one-element collection)
+```
+
+A **tuple** `(e1, e2, …)` — two or more expressions in parentheses — is a value
+and a receiver: its elements concatenated with one level of flattening (a
+collection contributes its items, a row itself; an absent element nothing, a
+`null` is kept; duplicates kept). One parenthesized expression is grouping.
+
+```js
+oqx`n: size((tags, aliases)) from ${people}`;                       // one count over both lists
+oqx`name from ${people} where "x" in (tags, aliases)`;              // membership in the union
+oqx`n: (mom, dad, siblings) { name values } from ${people}`;        // one block over the union
+oqx`id from ${g} follow (before, after) { depth 2 }`;               // one destination over the union
+```
+
+### 9c. Template literals (0.21)
+
+`` `text ${expr} text` `` is a string value: the text and each interpolated
+value's **string form** (numbers without a fraction when integer-valued,
+booleans as the words) concatenated. It stands wherever a value does — a
+`select` item, a `where` operand, an `order by` key, a function argument, a
+method receiver. The text decodes with the same escapes as a string (`` \` ``
+keeps a backtick, `\$` a dollar that opens nothing); newlines are kept, so a
+literal may span lines. An interpolation holds any expression with balanced
+braces — a `{ … }` block or another template literal included.
+
+```js
+oqx`label: \`\${title} (\${era})\` from ${docs}`;                             // "Alpha (3)"
+oqx`x: \`\${jobs single { employer values where primary }}\` from ${docs}`;  // the block's one value
+oqx`title from ${docs} where \`\${title}!\` == "Alpha!"`;
+oqx`x: jobs collect { label: \`\${^title}: \${employer}\` values } from ${docs}`;  // `^` reads the enclosing row
+```
+
+Two rules keep it honest: **absent propagates** — any absent interpolation makes
+the whole literal absent (as `+` does), never `"undefined"` — and **a list, a
+record or a range cannot be interpolated**: that is an eval error (`cannot
+interpolate …`), not a silent `[object Object]`. Inside a JavaScript tagged
+template write the backticks and `${` escaped as above (`` \` ``, `\${`), or
+pass the whole query as a string: a `${…}` *binding* can stand beside a template
+literal but never inside one (a fragment that ends inside the literal is an
+unterminated-literal error).
 
 ### 10. Sugar (0.17)
 
@@ -661,11 +758,15 @@ optimizer and any pushdown planner see it), so nothing here has semantics of its
 own except the postfix `!` and the infix `is`:
 
 ```js
-// A receiver block without a consumer is `collect`; a block whose LEADING
-// expression is syntactically a predicate drops `where`.
+// A receiver block without a consumer is `collect` — wherever a value stands
+// (language 0.20): a select item, a where leaf, a follow destination, a call
+// argument; `x distinct { … }` is `x collect distinct { … }`. A block whose
+// LEADING expression is syntactically a predicate drops `where`.
 oqx`name, current: jobs { !end_date } from ${people}`
 //   ≡ name, current: jobs collect { where !end_date } from ${people}
 oqx`${people} { age > 40 }`                  // ≡ ${people} collect { where age > 40 }
+oqx`n: size(jobs { !end_date }) from ${people}`   // a block as a call argument
+oqx`${people} distinct { city }`             // ≡ ${people} collect distinct { city }
 oqx`${people} count { jobs exists { } }`     // a consumer test is predicate-shaped too
 oqx`${people} first { name }`                // a bare name still projects — unchanged
 oqx`${people} first { is active }`           // the bare-field filter: `is x` ≡ `!!x`, `not x` ≡ `!x`
@@ -678,15 +779,15 @@ oqx`name, first_job: jobs[0], primary: jobs[pay > 2]! from ${people}`
 //   jobs[pay > 2]!   ≡ jobs single { where pay > 2 }!  (zero or many matches ⇒ an eval error)
 
 // Postfix `!` — required: the value, or an eval error naming the expression
-// (and the row's id). Never a filter, never a coercion: 0! and ""! are values.
+// (and the row's `$key` when scalar). Never a filter, never a coercion: 0! and ""! are values.
 oqx`select id!, title from ${docs}`           // insist on an identity before a write
 // Tightest precedence: `refs(c)[0]!.name` requires the lookup, `refs(c)[0].name!` the name.
 
-// `is` / `is not` compare IDENTITY (a row's id when present, else structurally):
+// `is` / `is not` compare IDENTITY (`$key`: the host's, else structural — §9):
 oqx`name from ${people} where manager is null`            // absent (same as == null)
 oqx`${people} count { ^people exists { $it is ^$it } }`   // rows compare; `==` leaves that unspecified
-// `and` / `or` are exact synonyms of `&&` / `||`: `title or path` coalesces.
-// `print` writes the words (language 0.18); `!` stays `!`.
+// `and` / `or` / `not` are the canonical connectives; `&&` / `||` / `!` are exact
+// synonyms (`title or path` coalesces). `print` writes the words (language 0.18); `!` stays `!`.
 
 // A select item may use the items to its left (inlined like a `where` alias):
 oqx`boss: ^people[id == ^manager], bossName: boss.name from ${people}`
@@ -694,7 +795,12 @@ oqx`boss: ^people[id == ^manager], bossName: boss.name from ${people}`
 
 Reserved words, never a bare field name: `from where select is not and or` and
 the literal words `true false null`. The top level is unchanged — `age > 15
-from ${people}` stays an error, because `where` would precede `from`.
+from ${people}` stays an error, because `where` would precede `from`. One
+carve-out: after a `follow` destination that is a relation of the current row
+(a bare name, a call, a binding) a brace is still the **options** block (`follow
+children { depth 2 }`), never a collect; only over an outer-reference receiver,
+which cannot be a plain destination, is the brace a destination block with the
+implicit `collect` (`follow ^people { where … }`, language 0.19).
 
 ### Cheat-sheet
 
@@ -702,11 +808,11 @@ from ${people}` stays an error, because `where` would precede `from`.
 select … from … where … follow … order by … limit N offset N   the fixed clause order (each at most once)
 name, alias: expr, nested: rel collect { … }   projection (`select` may be dropped only here, in first position)
 from ${source}                                  source collection (required at the top level)
-where a == b && rel exists { where … } || !c    predicate tree + nested ops (`and`/`or` ≡ `&&`/`||`)
+where a == b and rel exists { where … } or not c  predicate tree + nested ops (`&&`/`||`/`!` are accepted synonyms)
 rel { pay > 2 }  /  rel { employer }            a block without a consumer is collect; a leading predicate is where-first, a bare name projects
 rel[p]  /  rel[p]!  /  rel[0]  /  rel[0]!       first match / exactly one (required) / positional / required positional
 x!                                               required: the value, or an error when absent (tightest; `a!.b` vs `a.b!`)
-is x / not x  /  x is y / x is not y             truthiness (≡ !!x / !x) / identity (a row's id, else structural; absent ≡ null)
+is x / not x  /  x is y / x is not y             truthiness (≡ !!x / !x) / identity ($key: the host's, else structural; absent ≡ null)
 where alias  /  a: expr, b: a                    `where` and later items may use this body's select aliases (resolved before evaluation; an alias shadows a field)
 where rel none { … }                             zero rows (≡ !rel exists { … }; "all" = none over the complement)
 where x in lo..hi / lo...hi / ..hi / lo..        range membership (incl. / excl. / open-ended)
@@ -721,9 +827,13 @@ from entries(obj) … $key / $it                   a record's properties as a co
 entries(rel) exists { … }                        a free-function call may be a receiver
 order by expr desc, expr2                        ordering
 limit n / offset n                               bound the row set (after where/order/distinct, before the consumer)
-follow rel { where … frontier … depth n by … }  recursion ($depth/$stop/$leaf/$frontier); `^name` in the where is the frontier row
-follow before, after                             several destinations: the union of their rows (per step, by identity)
-follow ^people collect { where manager == ^id } a destination block: successors computed per frontier row (`^` = that row)
+follow rel { where … frontier … depth n }       recursion ($depth/$stop/$leaf/$frontier/$key); the brace is the destination's block, `^name` in its where the frontier row
+follow before, after  /  follow (before, after)  several destinations: the union of their rows (per step, by identity) / one tuple destination
+follow ^people { where manager == ^id }         a destination block: successors computed per frontier row (`^` = that row; `collect` implicit, 0.20)
+$key  /  $key: expr                              the identity a row is known by (the host's, else structural) / give the rows a block yields that identity
+(a, b)  /  rel distinct { … }                   a tuple: the elements, one level flat (a value and a receiver) / collect distinct (0.20)
+`${title} (${era})`                             a template literal: text + string forms; absent anywhere → absent; a list/record → error (0.21)
+obj { title }                                   one object → one record (or absent); a collection → a list; a scalar → an error (0.20)
 ${source} <collect|exists|none|count|first|single> { … }   whole-query consumer
 ```
 
@@ -836,9 +946,12 @@ than approximate it. The conformance suite verifies this.
 
 The engine never touches host objects directly; it asks a `DataContext` to
 resolve named roots, read properties/relations, coerce results to rows, and
-compute identity (and, optionally, to supply a `rootObject()` — the root
+optionally to name a row's identity (`identityOf` — `$key`; the default is the
+row's structural value), to say which of its objects are collections rather
+than one row (`isSingle`; by default a non-iterable object is one row, so a
+block over it is one record), and to supply a `rootObject()` — the root
 scope's row, what `$it` is at the root and `^$it` from a top-level row; without
-one the root row is absent). Implement it to query an ORM graph, a remote API,
+one the root row is absent. Implement it to query an ORM graph, a remote API,
 or lazily loaded relations — the query *semantics* stay in OQX. Name resolution is simple
 for a context: a bare `field`, a `.field` segment, and a `^field` outer
 reference each become one `get(row, key)` against exactly the row of the scope
@@ -851,7 +964,7 @@ const graph = {
   root: (name) => name === "tree" ? [nodes.get(1)] : undefined,
   get:  (row, key) => key === "children" ? row.childIds.map(id => nodes.get(id)) : row[key],
   toRows: (v) => v == null ? [] : Array.isArray(v) ? v : [v],
-  identity: (row) => row.id,                                // for follow dedup
+  identityOf: (row) => row.id,                              // `$key`: for follow dedup, distinct, `is` (optional; default: structural)
 };
 run(parse("id, depth: $depth from tree follow children"), { context: graph });
 ```
@@ -884,7 +997,7 @@ const ctx = {
     return builtins.callMethod(name, recv, args);
   },
 };
-run(parse("id from tree where age(born) > 18 && title.slug() == 'x'"), { context: ctx });
+run(parse("id from tree where age(born) > 18 and title.slug() == 'x'"), { context: ctx });
 ```
 
 The simplest route is to `extends DefaultContext` and `super.callFunction(...)`
@@ -910,7 +1023,7 @@ import { parse, PlannedEngine } from "@omgbase/oqx";
 import { SqliteTable } from "@omgbase/oqx/sqlite";
 
 const planner = new SqliteTable(db, "emp", { columns: ["id", "name", "dept", "level"] });
-new PlannedEngine(planner).run(parse('name from emp where dept == "eng" && level >= 5'), []);
+new PlannedEngine(planner).run(parse('name from emp where dept == "eng" and level >= 5'), []);
 // → `dept`/`level` pushed to SQL; anything untranslatable finishes in-memory
 ```
 
@@ -941,7 +1054,7 @@ results and on errors.
 
 **What is optimized**
 
-- **Correlated equality → hash probe.** A top-level `&&` conjunct of the block's
+- **Correlated equality → hash probe.** A top-level `and` conjunct of the block's
   `where` of the form `local == outer` (either side) — `local` a bare identifier
   or member chain on the block's row (`customer_id`, `meta.id`, `$it`),
   `outer` anything that reads nothing from that row (`^customer_id`, `^^x.id`,
@@ -963,7 +1076,7 @@ results and on errors.
   by`) are answered from the bucket's size after the bound without entering a
   row.
 
-**The sound rule.** `&&` is strictly left to right and short-circuiting (§13),
+**The sound rule.** `and` is strictly left to right and short-circuiting (§13),
 so a probe may skip a row only if everything the scan would have evaluated for
 it could neither raise nor bind: an equality is hoisted only when **every
 conjunct to its left is raise-free** — no function or method call, no `single`,
@@ -973,7 +1086,7 @@ too. A conjunct that could raise *right* of the equality is simply evaluated
 over the bucket, where the scan would have evaluated it on the same rows. A
 block whose `where` lifts anywhere is never probed (a lift could change what
 the outer side reads between rows). Otherwise the block scans as before, so
-`where nope(x) && id == ^id` still raises `unknown function`.
+`where nope(x) and id == ^id` still raises `unknown function`.
 
 Property reads are treated as total (§23: evaluation is otherwise total). A
 `DataContext.get` that throws is caught where the engine relies on reads it
@@ -1082,7 +1195,7 @@ adapter lives on the `@omgbase/oqx/sqlite` subpath.
   (the optimizer rules for nested blocks, default `DEFAULT_RULES`; `[]` is the
   naive scan) and `trace` (a `(event: TraceEvent) => void` sink for index /
   probe / memo / cardinality / fallback events). See [Performance](#performance-relational-patterns).
-- `DataContext` — the tier-2 interface: `root`, `get`, `toRows`, `identity`,
+- `DataContext` — the tier-2 interface: `root`, `get`, `toRows`, `identityOf`, `isSingle`,
   plus optional `callFunction` / `callMethod` (above), an optional
   `indexFor(collection, path)` returning a `RowIndex` for a pre-built equality
   index (`lookup` → positions; optionally `lookupRows` → rows, probed without
@@ -1095,7 +1208,7 @@ adapter lives on the `@omgbase/oqx/sqlite` subpath.
   "native")`; `BUILTIN_METHODS.matches` is always the baseline.
 - `CallResult` — `{ handled: boolean; value?: unknown }`, returned by those hooks.
 - `DefaultContext` — `new DefaultContext(roots?, options?)`; plain-object
-  access, `.id` identity, and the builtin function/method tables. `options`:
+  access, structural identity (`$key` is the row itself unless projected), and the builtin function/method tables. `options`:
   `{ regexDialect?: RegexDialect }` (see the regex baseline, §4).
 - `compileRegex(pattern, flags?, dialect?)` — the `matches()` compiler: a
   `RegExp`, or an `OqxError` for a bad pattern/flag. `RegexDialect` /
@@ -1142,7 +1255,7 @@ adapter lives on the `@omgbase/oqx/sqlite` subpath.
   import { parse, run, IndexedCollection, PlannedEngine } from "@omgbase/oqx";
   const planner = new IndexedCollection("people", people, ["city", "title"]);
   const engine = new PlannedEngine(planner, planner.context());
-  run(parse('name from people where city == "NYC" && age > 30'), { engine });
+  run(parse('name from people where city == "NYC" and age > 30'), { engine });
   // city probe from the index; `age > 30` finished in-memory over the candidates
   ```
 

package/dist/ast.d.ts

@@ -15,6 +15,9 @@ export type BinaryOp = RelOp | IdentityOp | "+" | "-" | "*" | "/" | "%";
 export type UnaryOp = "!" | "-";
 /** The operator of a `logical` expression. */
 export type LogicalOp = "&&" | "||";
+/** One part of a template literal (since 0.21): a decoded text run, or an
+ * interpolated expression. The strings are not nodes (no `kind`, no span). */
+export type TemplatePart = string | Expr;
 /** Scalar value/predicate expression, evaluated against a row scope + bindings. */
 export type Expr = {
     kind: "lit";
@@ -76,6 +79,14 @@ export type Expr = {
     lo: Expr | null;
     hi: Expr | null;
     exclusiveEnd: boolean;
+} | {
+    kind: "tuple";
+    span: Span;
+    items: Expr[];
+} | {
+    kind: "template";
+    span: Span;
+    parts: TemplatePart[];
 } | OpNode;
 /** One `order by` term. */
 export interface OrderSpec {
@@ -123,16 +134,13 @@ export interface OpNode {
  * destination block — a select-position directive (`collect`/`first`/`single`) re-evaluated
  * per frontier row, inside which `^` is that row. Discriminate on `kind === "op"`. */
 export type FollowDestination = Expr | OpNode;
-/** The recursive `follow` clause. */
+/** The recursive `follow` clause (since 0.20 just the destinations: a
+ * destination's `where`, `frontier` and `depth` live in its own block). */
 export interface Follow {
     kind: "follow";
     span: Span;
     destinations: FollowDestination[];
     distinct: boolean;
-    where: Expr | null;
-    frontier: Expr | null;
-    depth: number | null;
-    by: Expr | null;
 }
 /** A nested (sub)query body — the `{ … }` of a directive. */
 export interface Subquery {
@@ -143,6 +151,16 @@ export interface Subquery {
     select: SelectItem[];
     orderBy: OrderSpec[] | null;
     follow: Follow | null;
+    /** `frontier P` / `depth n` (since 0.20). In a `follow` destination block
+     * `frontier` marks the occurrences reached through this destination for
+     * which `P` holds (not expanded; `P` read one level out, under the walk's
+     * enclosing scope), and `depth n` makes the destination expand a frontier
+     * row only while that row's `$depth < n` (1..8; `null` = the hard cap 8).
+     * In any other block `frontier` is legal only with a `follow` and marks the
+     * walk's SEEDS, read in the seed's scope like `where` (as on `Query`);
+     * `depth` is destination-only. Both `null` when absent. */
+    frontier: Expr | null;
+    depth: number | null;
     /** `values` — scalar projection mode: the (single) projected expression is the
      * row's result itself rather than being wrapped in a `{ name: value }` record,
      * so `name values` yields `["Bob", …]` and `$it values` yields the rows. */
@@ -186,6 +204,11 @@ export interface Query {
     orderBy: OrderSpec[] | null;
     consumer: Consumer;
     follow: Follow | null;
+    /** `frontier P` (since 0.20) — legal only when the body has a `follow`: a
+     * seed for which `P` holds (read in the seed's own scope, `^` the enclosing
+     * scope, like `where`) is a frontier (`$stop == "frontier"`, not expanded).
+     * `null` without one. */
+    frontier: Expr | null;
     /** `distinct` — dedup the result rows by their projected value (see OpNode). */
     distinct: boolean;
     /** `values` — scalar projection mode (see Subquery). */

package/dist/ast.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ast.d.ts","sourceRoot":"","sources":["../src/ast.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"ast.d.ts","sourceRoot":"","sources":["../src/ast.ts"],"names":[],"mappings":"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"}

package/dist/ast.js

@@ -12,7 +12,7 @@
 // empty span `[0, 0]` (see `build.ts`).
 /** The expression kinds (`Expr["kind"]`), for `isExpr`. */
 const EXPR_KINDS = new Set([
-    "lit", "ident", "outer", "binding", "member", "call", "unary", "required", "binary", "logical", "in", "range",
+    "lit", "ident", "outer", "binding", "member", "call", "unary", "required", "binary", "logical", "in", "range", "tuple", "template",
 ]);
 /** Whether a node is a scalar `Expr` (an `op` in expression position is not: it
  * is an expression only by position, see AST.md §1). */

package/dist/ast.js.map

@@ -1 +1 @@
-{"version":3,"file":"ast.js","sourceRoot":"","sources":["../src/ast.ts"],"names":[],"mappings":"AAAA,+EAA+E;AAC/E,8EAA8E;AAC9E,gFAAgF;AAChF,+EAA+E;AAC/E,2EAA2E;AAC3E,gFAAgF;AAChF,wDAAwD;AACxD,EAAE;AACF,iFAAiF;AACjF,gFAAgF;AAChF,4EAA4E;AAC5E,wCAAwC;AAqKxC,2DAA2D;AAC3D,MAAM,UAAU,GAAwB,IAAI,GAAG,CAAC;IAC9C,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,SAAS,EAAE,IAAI,EAAE,OAAO;CAC9G,CAAC,CAAC;AAEH;wDACwD;AACxD,MAAM,UAAU,MAAM,CAAC,IAAa;IAClC,OAAO,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACnC,CAAC"}
+{"version":3,"file":"ast.js","sourceRoot":"","sources":["../src/ast.ts"],"names":[],"mappings":"AAAA,+EAA+E;AAC/E,8EAA8E;AAC9E,gFAAgF;AAChF,+EAA+E;AAC/E,2EAA2E;AAC3E,gFAAgF;AAChF,wDAAwD;AACxD,EAAE;AACF,iFAAiF;AACjF,gFAAgF;AAChF,4EAA4E;AAC5E,wCAAwC;AAgMxC,2DAA2D;AAC3D,MAAM,UAAU,GAAwB,IAAI,GAAG,CAAC;IAC9C,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,SAAS,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,UAAU;CACnI,CAAC,CAAC;AAEH;wDACwD;AACxD,MAAM,UAAU,MAAM,CAAC,IAAa;IAClC,OAAO,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACnC,CAAC"}