@omgbase/oqx 0.10.2 → 0.12.0

package/CHANGELOG.md

@@ -4,6 +4,168 @@ 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.12.0] - 2026-09-25
+
+**OQX is now a language with a specification and two implementations.** The
+spec lives at `spec/oqx` in the monorepo: `GRAMMAR.md`, `SEMANTICS.md`, and
+835 executable fixtures in 28 files that this package and the Rust
+crate `oqx` both run. **Versioning changed accordingly:** the language version
+is `spec/oqx/VERSION` (`0.12`) and every implementation's version is
+`<language>.<patch>`, so `@omgbase/oqx 0.12.x` and the `oqx` crate `0.12.x`
+both mean "the 0.12 language"; the patch digit is per implementation. The
+package exports `LANGUAGE_VERSION`.
+
+Everything below follows one principle, applied without exception: **least
+surprise.** Where the reference behaved by JavaScript accident, it now does
+what a careful user would predict.
+
+### Changed (breaking) — semantics
+- **Identity is structural.** `distinct` over unprojected rows and `follow`
+  cycle detection/dedup use the `id` property when present, else the row's
+  structural value (deep equality, key order ignored). Previously identities
+  were stringified, so every id-less object collided as `[object Object]`
+  (`count distinct { }` over two different objects gave 1; `follow` over
+  id-less nodes marked every successor a cycle) and `1` equalled `"1"`.
+- **No cross-type ordering.** `<  <=  >  >=` and range coverage order only
+  number/number and string/string; every other pair, including booleans and
+  anything absent, is false. `1 < "2"` and `"3" in 1..5` were true.
+- **Strings order and measure by Unicode code point**, not UTF-16 code unit:
+  `"😀".size()` is 1 and astral characters sort after the BMP.
+- **Own enumerable properties only.** Property reads (`name`, `.name`,
+  `^name`), `has()`, `in` over an object, and `entries()` never see inherited
+  members (`has(toString)` is false). Arrays expose only their integer
+  indices — `.length` is absent; use `size()`. Primitives have no properties.
+- **Absent propagates.** Any arithmetic with an absent operand is absent,
+  including `"a" + missing` (was `"aundefined"`) and `null + 1` (was `1`).
+  `.lower()` / `.upper()` on absent are absent (were `"undefined"` /
+  `"NULL"`).
+- **Regex is an OQX concern.** An invalid `matches()` pattern raises
+  `OqxError` (`eval`, `invalid regular expression`) instead of a raw
+  `SyntaxError`. Lookaround and backreferences are rejected (`not supported in
+  OQX`) so the dialect is the portable intersection.
+- **Ranges never appear in results.** Projecting a range value is an error
+  (`a range … cannot appear in a result`); no range covers an absent value,
+  however open.
+- **`&&` and `||` evaluate strictly left to right** with short-circuit; the
+  engine no longer reorders conjuncts by cost, so `false && bogus()` never
+  errors and `true && bogus()` always does.
+- **`single` reports the true row count** in its error.
+- **`$ordinal` path components compare as values** (numbers numerically,
+  before strings), not as text: `[1, 9, 10]`, not `[1, 10, 9]`.
+- **Bindings out of range** (`run(query, { values })` with fewer values than
+  the query references) raise `OqxError` instead of reading `undefined`.
+
+### Changed (breaking) — grammar
+- **`!` has one precedence everywhere:** a prefix operator binding tighter
+  than comparison, applied to the operand right after it. `where !a == b` is
+  `(!a) == b` (it negated the whole comparison before); `!jobs exists { … }`
+  and `!(a == b)` work as written.
+- **Parenthesized scalars work in `where`:** `where (a + 1) > 2` was a parse
+  error; a group followed by an operator is a scalar.
+- **`follow distinct` requires a relation** (`follow distinct { depth 2 }` no
+  longer treats `distinct` as the relation name); `follow ^rel` is a clear
+  error.
+- **Open-ended ranges stop at clause words** (`in ..5 order by a`); a range
+  with no bound at all is an error.
+- **Duplicate projection names are an error** (`a: 1, a: 2` last-wins is
+  gone), including a dotted default key colliding with an alias.
+- **Malformed numerals are lex errors:** `1e`, `1e+`, `1.`, `.5`, `xs.0`.
+  `1..5`, `1...5`, `..5`, `1..`, `1.5..2.5` are unchanged.
+- **Top-level `limit ^n` / `offset ^n`** are parse errors (`no enclosing
+  scope`); they were always absent and failed at run time.
+- **`true` / `false` / `null` are literals in every position;** as a receiver
+  or follow relation they error instead of resolving a root by that name.
+- **Lifts (`^name:`) outside a where-position `collect`** are parse errors
+  instead of silently doing nothing.
+- **Chained comparisons** (`a == b == c`) error clearly; **stray tokens** after
+  a query or in a block get a located message; clause words without their
+  clause (`order age`, bare `follow`, `limit x`) say what they need.
+
+### Changed (breaking) — regular expressions
+- **`matches()` compiles the OQX regex baseline, not a JavaScript `RegExp`.**
+  The baseline (SEMANTICS §11) is a fixed grammar — literals and escaped
+  metacharacters, `\n \t \r \f \v`, `\uXXXX` / `\u{…}`, the classes
+  `\d \D \w \W \s \S` with spec-fixed sets (`\d` = `[0-9]`, `\w` =
+  `[A-Za-z0-9_]`, `\s` = one listed set), `\b \B` over that `\w`, bracket
+  classes, `.`, `^ $`, the quantifiers and their lazy forms, `|`, `(…)`,
+  `(?:…)`, `(?<name>…)` — and the pattern is validated and rewritten before
+  `RegExp` sees it (`src/regex.ts`). **The line terminator is `\n` alone**
+  for `.` and for `m`-mode anchors (`\r`, U+2028, U+2029 are ordinary
+  characters), and `.` consumes a code point. Every construct outside the
+  grammar is an eval error naming it (`an inline flag (?i) is not supported in
+  OQX regular expressions`): lookaround and backreferences (already rejected),
+  now also inline flags `(?i)` / `(?i:…)`, `\p{…}`, `\x..`, `\c.`, octal
+  escapes, identity escapes of non-metacharacters, possessive quantifiers,
+  atomic and comment groups, `(?P<…>)`, `\A \z \Z \G \K \Q \E`, POSIX and
+  nested classes, class set operations, `[\b]`. Malformed patterns that
+  `RegExp` tolerated (`a{`, a lone `]`, `a**`, `[]`, `[^]`, `(?<n>…)` twice)
+  are `invalid regular expression`.
+- **Flags are an explicit second argument**: `matches(pattern, flags)` with
+  `flags` a string of distinct letters from `i` (simple case folding, so `é`
+  matches `É`), `m`, `s`. Anything else is an eval error: `unknown regex
+  flag` (`"g"`, `"I"`, a non-string) or `duplicate regex flag`. There is no
+  inline flag syntax.
+- **Engine-native dialects are a host opt-in, not query syntax.**
+  `DataContext` gains an optional `regexDialect: "oqx" | "native"` (default
+  `"oqx"`); `new DefaultContext(roots, { regexDialect: "native" })` hands
+  patterns to `RegExp` unvalidated with the `u` flag plus the given flags —
+  implementation-defined, not portable, untested by the spec. `DefaultContext`
+  answers `matches` itself so it can read the dialect; `BUILTIN_METHODS.matches`
+  stays the baseline, and `semantics.regexMatches(recv, args, dialect)` is the
+  helper for custom contexts. `compileRegex(pattern, flags?, dialect?)` and the
+  `RegexDialect` / `RegexFlags` types are exported.
+- Fixtures: the `matches` cases moved from `strings.json` to a new
+  `regex.json` (21 moved, 98 added), pinning each baseline construct, the
+  `\n`-only line terminator, ASCII `\d \w \b`, the `\s` set, code-point `.`,
+  flags, and one rejection per construct.
+
+### Documentation
+- Integer-like object keys enumerate first in JavaScript before OQX sees the
+  object; this is a host fact the reference cannot undo, and fixtures must not
+  depend on the relative order of integer-like and other keys.
+
+## [0.11.0] - 2026-09-24
+
+### Changed (breaking)
+- **Clause order is fixed** (omgbase ADR-020). Within one clause body — the
+  top level or any consumer block — clauses appear at most once each, in
+  exactly this order: `select … from … where … follow … order by … limit N
+  offset N`. Every clause is optional except a top-level `from` (the
+  `<receiver> <consumer> { … }` form supplies its own source). A clause out
+  of order is a parse error that names the order (`` `select` must come
+  before `from` — OQX clause order is select, from, where, follow, order by,
+  limit, offset ``); a second `from` in one body is a duplicate. The
+  order-flexible grammar (`from ${people} select name where …`, `limit 1 name
+  from …`, `offset 1 limit 1`) no longer parses.
+- **Only `select` may drop its keyword, and only when it is the first clause
+  written** (`name, age from people`). Every other clause always carries its
+  keyword, so a predicate is never implicit: the `looksLikePredicate` shape
+  heuristic is gone. **A block now needs `where`** — `jobs exists { where
+  !end }` — and a bare comparison in leading position (`exists { age > 50 }`,
+  `age > 50 from people`) is a parse error that points at `where`. A bare name
+  in leading position projects, as before (`count { active }` selects
+  `active`).
+- **The `from docs count` footgun is closed.** A bare run after `from` is an
+  error; `from people count` fails at `count` with a hint — write
+  `people count { … }` for the whole-query consumer, or `select count from …`
+  to project a field named `count`. (Previously it silently projected the
+  field.)
+
+### Added
+- **`where` may reference the same body's `select` aliases.** Implemented as a
+  compile-time inline rewrite (not a second execution pass): after a body is
+  parsed, each bare identifier in its `where` that names an alias is replaced
+  by the alias's expression, so the engine and any pushdown planner see an
+  ordinary predicate. An alias shadows a same-named row field inside `where`;
+  an alias's own name inside its own expression is still the field
+  (`name: name.upper()` is not recursive); a chain of aliases that returns to
+  one being resolved (`a: b, b: a … where a`) is a parse error; an alias whose
+  value is a `collect`/`first`/`single { … }` block may stand alone as a
+  where leaf (non-empty test) but not inside an expression. Each body rewrites
+  only against its own `select` (nested blocks and `follow` blocks are their
+  own scopes); `^name` is never an alias. `order by` is unchanged — it reads
+  row fields, not aliases.
+
 ## [0.10.2] - 2026-09-23
 
 Moved into the omgbase monorepo (`packages/oqx`, via `git subtree` — full

package/README.md

@@ -13,6 +13,10 @@ JavaScript tagged template.
 > is published independently under its own version line and has **zero runtime
 > dependencies** — it is usable without omgbase, and omgbase code is never
 > imported here (omgbase binds it from the outside via the `DataContext` seam).
+> OQX is a language with more than one implementation; the specification is
+> [`spec/oqx`](https://github.com/omgbase/omgbase/tree/main/spec/oqx). The
+> language version is the package version's `major.minor` (`LANGUAGE_VERSION`,
+> `"0.12"`); the patch digit is this implementation's own.
 > Requirements: Node ≥ 22.13 for `@omgbase/oqx/sqlite`; Node ≥ 22.18 to run the
 > test suite (see [Requirements](#requirements)).
 
@@ -30,7 +34,7 @@ const company = "Globocorp";
 const employees = oqx`
   name, id, title
   from ${people}
-  where jobs exists { employer == ${company} && !end_date }
+  where jobs exists { where employer == ${company} && !end_date }
 `;
 // → [{ name: "Bob", id: 124, title: "Engineer" }, …]  (current Globocorp employees)
 ```
@@ -46,18 +50,30 @@ template's identity and re-runs with fresh bindings each call.
 
 ## Language tutorial
 
-A query has, in spirit, the shape below — but at the top level the clauses are
-**order-flexible**, so you can lead with the projection (SQL-style) or with
-`from`, whichever reads better:
+A query is a list of clauses in a **fixed order**. Each clause appears at most
+once, and every one is optional except `from` at the top level:
 
 ```
-[ [select] projection ]    name, id, title: label
+[ [select] projection ]    name, id, title: label        (or: select distinct …, … values)
 from <collection>          from ${people}
-[ where <predicate> ]      where age >= 18 && jobs exists { !end }
-[ order by <expr> … ]      order by age desc, name
+[ where <predicate> ]      where age >= 18 && jobs exists { where !end }
 [ follow <relation> … ]    follow children { depth 4 }
+[ order by <expr> … ]      order by age desc, name
+[ limit N ]                limit 10
+[ offset N ]               offset 20
 ```
 
+**`select` is the only keyword you may drop, and only when the projection comes
+first** (`name, id from ${people}`). Every other clause always carries its
+keyword — in particular a predicate is never implicit, so a block filters with
+`where` (`jobs exists { where !end }`), and `from ${people} count` is an error
+rather than a projection of a field called `count`. Writing a clause out of
+order is a parse error that names the order (`` `select` must come before
+`from` — OQX clause order is select, from, where, follow, order by, limit,
+offset ``). The same body grammar applies inside every consumer block
+(`collect { … }`, `exists { … }`, …), where `from` is optional because the
+receiver supplies the rows.
+
 The examples below all use this dataset:
 
 ```js
@@ -113,8 +129,12 @@ An item that is not a plain navigation — a call, arithmetic, a comparison —
 no natural key, so it must be aliased (`n: size(jobs)`), unless the projection is
 in `values` mode (next).
 
-The `select` keyword is optional and works in any position — `select name from …`
-is identical to `name from …` (and hosts `select distinct`, §6).
+The `select` keyword may be dropped when the projection is the first clause —
+`select name from …` is identical to `name from …`. The keyword form hosts
+`select distinct` (§6), and is the only way to write a projection whose first
+item would otherwise be misread (there is no other keyword-less clause). The
+projection always comes *before* `from`: `from ${people} select name` is an
+ordering error.
 
 **`values` — scalar projection.** Ordinarily every row projects to a record. Add
 `values` after a projection of exactly **one** item to get the value itself:
@@ -182,8 +202,9 @@ ask for one. As a plain value (not a source) `entries(x)` is an array of
 
 `where` filters rows. The predicate language has comparisons (`== != < <= > >=`),
 boolean operators (`&& || !`) with grouping `( )`, membership (`in`), arithmetic
-(`+ - * / %`), and bare truthiness. The `where` keyword is optional when the
-leading expression is clearly a predicate.
+(`+ - * / %`), 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`.
 
 ```js
 const min = 40;
@@ -231,6 +252,25 @@ non-range string yields an absent range, so `x in range(bad)` is just false.
 **Interpolations are always values, never syntax.** `where name == ${x}` compares
 against the value of `x`; a string in `x` can't inject operators or identifiers.
 
+**`where` sees the `select` aliases.** A name defined in the same body's
+projection may be used in its `where`; an alias shadows a same-named field
+there. It is a compile-time rewrite — the alias's expression is substituted
+inline — so it costs nothing at run time and a storage planner still sees an
+ordinary predicate:
+
+```js
+oqx`select name, adult: age >= 18 from ${people} where adult`;        // ≡ where age >= 18
+oqx`select name, active: age > 50 from ${people} where active`;       // the ALIAS, not the field → Alice
+oqx`select name, current: jobs collect { employer where !end } from ${people} where current`;
+// a collect alias in predicate position means "non-empty" → Bob, Carol
+```
+
+Inside an alias's own expression its name is still the field
+(`name: name.upper()` is not recursive); a chain of aliases that comes back to
+itself (`a: b, b: a … where a`) is a parse error. Each block rewrites only
+against its *own* `select`; `^name` always reads an enclosing row's field, never
+an alias. `order by` is not rewritten — it reads row fields (§8).
+
 **Scoping: bare names are local, `^` reaches out.** A bare identifier resolves
 against the **current row only**. If the row lacks that property the value is
 absent — it never falls through to an enclosing row. To correlate with an
@@ -242,10 +282,10 @@ const accounts = [
   { owner: "x", budget: 100, orders: [{ amount: 50 }, { amount: 150 }] },
   { owner: "y", budget: 200, orders: [{ amount: 250 }] },
 ];
-oqx`owner from ${accounts} where orders exists { amount > ^budget }`;
+oqx`owner from ${accounts} where orders exists { where amount > ^budget }`;
 // [{ owner: "x" }, { owner: "y" }]   — `^budget` is the enclosing account's budget
 
-oqx`owner from ${accounts} where orders exists { amount > budget }`;
+oqx`owner from ${accounts} where orders exists { where amount > budget }`;
 // []   — a bare `budget` is the ORDER's own budget: absent, so `>` is false
 ```
 
@@ -311,13 +351,56 @@ oqx`name from ${people} where tags.contains("admin")`;       // array membership
 - `.contains(v)` works on strings (substring) **and arrays** (an element equal
   to `v` under OQX's strict equality); on anything else it is false.
 - `.size()` / `size(x)` is the length of a string or array, the key count of
-  an object, and 0 for absent; `.matches(re)` compiles its argument as a
-  JavaScript `RegExp`.
+  an object, and 0 for absent.
+- `.matches(re, flags?)` searches the receiver's text for a regular expression
+  written in the **OQX regex baseline** (below), unanchored unless the pattern
+  anchors. `flags` is an optional string of `i` (case-insensitive), `m` (`^`/`$`
+  also at newlines), `s` (`.` also matches `\n`); an absent receiver is `false`.
 
 Anything not in these tables is an **eval error** (`unknown function 'f(…)'` /
 `unknown method '.m(…)'`) — see [custom functions](#custom-functions-and-methods)
 for adding your own.
 
+#### The regex baseline
+
+OQX is a language with more than one implementation, so `matches()` does not
+expose the host's `RegExp`. It compiles a fixed, portable dialect whose every
+construct has one spec-defined meaning (`spec/oqx/SEMANTICS.md` §11):
+
+- literals; escaped metacharacters `\. \* \+ \? \( \) \[ \] \{ \} \| \^ \$ \\ \/ \-`;
+  `\n \t \r \f \v`; `\uXXXX` (four hex digits) and `\u{X…}` (any code point);
+- `\d` = `[0-9]`, `\w` = `[A-Za-z0-9_]`, `\s` = JavaScript's white space (one
+  listed set), `\D \W \S` their complements, `\b \B` word boundaries over that
+  `\w`; bracket classes `[…]` / `[^…]` with ranges;
+- `.` = any code point except `\n` (the line terminator is `\n` alone — `\r`
+  is an ordinary character); anchors `^ $`; quantifiers `* + ? {n} {n,} {n,m}`
+  and their lazy `?` forms; alternation `|`; groups `(…)`, `(?:…)`, `(?<name>…)`.
+
+Everything else — lookaround, backreferences, inline flags `(?i)`, `\p{…}`,
+`\x..`, octal, possessive quantifiers, POSIX classes, `\A \z` … — is an
+`OqxError` (stage `eval`) naming the construct: `an inline flag (?i) is not
+supported in OQX regular expressions`. A pattern that is malformed within the
+baseline is `invalid regular expression …`; a bad flag is `unknown regex flag`
+/ `duplicate regex flag`. The pattern is validated and rewritten before
+`RegExp` sees it (`src/regex.ts`), so JavaScript-only behavior never leaks.
+
+```js
+oqx`name from ${people} where title.matches("^(eng|dir)", "i")`;   // Bob, Alice
+oqx`x: "a\nb".matches("a.b") from ${one}`;                         // false: . stops at \n
+oqx`x: "a\nb".matches("a.b", "s") from ${one}`;                    // true
+oqx`x: "٣".matches(${"\\d"}) from ${one}`;                         // false: \d is ASCII
+oqx`x: "é".matches(${"^\\u{e9}$"}) from ${one}`;                   // true
+```
+
+A pattern with backslashes is easiest to pass as a binding (`${"\\d"}`): the
+template's own escaping and the OQX string literal's `\<c>` escape would each
+consume one level otherwise (`"\\\\d"` in the template is `\d` to the regex).
+
+A host that wants JavaScript's own dialect can opt in per context:
+`new DefaultContext(roots, { regexDialect: "native" })` hands patterns to
+`RegExp` unvalidated (with the `u` flag plus the given flags). That is
+implementation-defined and not portable to the Rust implementation.
+
 ### 5. Consumers
 
 A consumer shapes a result set. There are six:
@@ -333,8 +416,9 @@ A consumer shapes a result set. There are six:
 
 The bare `from … ` form is always `collect`. To reduce the **whole** query with a
 different consumer, use the directive form `<source> <consumer> { <body> }` — note
-this is *not* SQL: `count from people` would project a field called `count`, whereas
-a real reduction is a directive:
+this is *not* SQL: `count from people` projects a field called `count`, and
+`from people count` is a parse error that points at the directive form. A real
+reduction is a directive:
 
 ```js
 oqx`${people} exists { where active }`;            // true
@@ -342,8 +426,11 @@ oqx`${people} count { where active }`;             // 2
 oqx`${people} first { name where age > 50 }`;      // { name: "Alice" }
 ```
 
-(Inside a consumer block a bare identifier **projects** — `count { active }` selects
-a field named `active`; write `count { where active }` to filter.)
+(A consumer block follows the same clause grammar as the top level, with `from`
+optional. A leading bare identifier **projects** — `count { active }` selects a
+field named `active`; write `count { where active }` to filter, and always write
+`where` before a predicate: `exists { !end }` is an error, `exists { where !end }`
+is the test.)
 
 ### 6. Nested collections and relations
 
@@ -354,7 +441,7 @@ In `where`, an `exists { … }` tests non-emptiness and `count { … } <op> N` c
 cardinality:
 
 ```js
-oqx`name from ${people} where jobs exists { !end }`;   // has a current job → Bob, Carol
+oqx`name from ${people} where jobs exists { where !end }`;   // has a current job → Bob, Carol
 oqx`name from ${people} where jobs count {} >= 2`;     // ≥2 jobs → Bob, Alice
 oqx`name from ${people} where jobs none { where end }`; // no past job → Carol
 ```
@@ -384,7 +471,7 @@ counts and collections are over distinct projections rather than raw rows. Spell
 it after the consumer (`count distinct { … }`) or inside via `select distinct`:
 
 ```js
-oqx`from ${jobs} select distinct employer`;            // distinct employers
+oqx`select distinct employer from ${jobs}`;            // distinct employers
 oqx`n: jobs collect distinct { select employer } from ${people}`; // per person, unique employers
 oqx`name from ${people} where jobs count distinct { select employer } == 1`; // worked at exactly one employer
 ```
@@ -437,7 +524,9 @@ fully), not a short-circuiting `exists`.
 ### 8. Ordering
 
 `order by <expr> [asc|desc]`, comma-separated for tie-breaks. Absent values sort
-last.
+last. The sort expression reads the row (fields, `$value`, recursion
+intrinsics) — it is not rewritten against the `select` aliases, so
+`order by decade` sorts by a field called `decade`, not by `decade: age / 10`.
 
 ```js
 oqx`name from ${people} where city == "NYC" order by age desc`;
@@ -456,7 +545,7 @@ inside `{ … }`; it must be a non-negative integer.
 
 ```js
 oqx`name values from ${people} order by age desc limit 2`;                 // ["Alice", "Bob"]
-oqx`name values from ${people} order by age desc offset 1 limit 1`;        // ["Bob"]
+oqx`name values from ${people} order by age desc limit 1 offset 1`;        // ["Bob"]
 oqx`name, latest: jobs collect { employer values order by start desc limit 1 } from ${people}`;
 oqx`name from ${people} where jobs exists { offset 1 }`;                   // has a second job
 ```
@@ -513,9 +602,11 @@ your relation returns fresh objects rather than shared references.
 ### Cheat-sheet
 
 ```
-name, alias: expr, nested: rel collect { … }   projection (select optional)
-from ${source}                                  source collection
-where a == b && rel exists { … } || !c          predicate tree + nested ops
+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 (`where` is never implicit)
+where alias                                      `where` may use this body's select aliases (inlined; 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)
 where x in range(field)                          coerce a string field to a range, then test coverage
@@ -699,14 +790,23 @@ adapter lives on the `@omgbase/oqx/sqlite` subpath.
 - `InMemoryEngine` — `new InMemoryEngine(context?)`; the reference engine over a
   `DataContext` (tier 1/2).
 - `DataContext` — the tier-2 interface: `root`, `get`, `toRows`, `identity`,
-  plus optional `callFunction` / `callMethod` (above).
+  plus optional `callFunction` / `callMethod` (above) and an optional
+  `regexDialect` (`"oqx"` default | `"native"`). The engine dispatches
+  `matches` through `callMethod`, so a custom context that wants the native
+  dialect answers `matches` itself with `semantics.regexMatches(recv, args,
+  "native")`; `BUILTIN_METHODS.matches` is always the baseline.
 - `CallResult` — `{ handled: boolean; value?: unknown }`, returned by those hooks.
-- `DefaultContext` — `new DefaultContext(roots?)`; plain-object access, `.id`
-  identity, and the builtin function/method tables.
+- `DefaultContext` — `new DefaultContext(roots?, options?)`; plain-object
+  access, `.id` identity, 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` /
+  `RegexFlags` are the types.
 - `semantics` — the scalar-contract module (`equals`, `relate`, `arith`,
   `membership`, `truthy`, `compareForSort`, `sizeOf`, `toList`,
   `coerceCollection`, ranges: `makeRange` / `isRange` / `rangeCovers` /
-  `parseRangeString`, entries: `makeEntry` / `isEntry` / `entriesOf`, and the
+  `parseRangeString`, entries: `makeEntry` / `isEntry` / `entriesOf`, regex:
+  `compileRegex` / `regexMatches` / `parseRegexFlags`, and the
   `BUILTIN_FUNCTIONS` / `BUILTIN_METHODS` tables). A backend reproducing a rule
   natively must match these.
 

package/dist/context.d.ts

@@ -1,3 +1,4 @@
+import type { RegexDialect } from "./regex.js";
 /** Result of a context-provided function/method call: `handled: false` tells the
  * engine to fall back to the builtin table (or error if none). */
 export interface CallResult {
@@ -20,13 +21,27 @@ export interface DataContext {
     callFunction?(name: string, args: unknown[]): CallResult;
     /** Optional custom method; return `{ handled: false }` to defer. */
     callMethod?(name: string, recv: unknown, args: unknown[]): CallResult;
+    /** The regex dialect `matches()` compiles against. `"oqx"` (the default when
+     * absent) is the portable baseline the spec tests; `"native"` hands the
+     * pattern to the host `RegExp` unvalidated — implementation-defined, not
+     * portable. Note the engine dispatches `matches` through `callMethod`, so
+     * this is read by the context's own `matches` (`DefaultContext` does;
+     * `regexMatches(recv, args, dialect)` is the helper). `BUILTIN_METHODS.matches`
+     * is always the baseline. */
+    readonly regexDialect?: RegexDialect;
+}
+export interface DefaultContextOptions {
+    /** See `DataContext.regexDialect`. Default `"oqx"`. */
+    regexDialect?: RegexDialect;
 }
 /** The default context: ordinary JavaScript objects. Named roots come from a
- * plain `{ name: collection }` map; properties are own/inherited keys; identity
- * is `.id` when present, else the object itself (reference identity). */
+ * plain `{ name: collection }` map; properties are OWN keys only (an array
+ * exposes only its integer indices, a primitive has none); identity is `.id`
+ * when present, else the row itself (the engine keys it structurally). */
 export declare class DefaultContext implements DataContext {
     private roots;
-    constructor(roots?: Record<string, unknown>);
+    readonly regexDialect: RegexDialect;
+    constructor(roots?: Record<string, unknown>, options?: DefaultContextOptions);
     root(name: string): unknown;
     get(row: unknown, key: string): unknown;
     toRows(value: unknown): Iterable<unknown>;

package/dist/context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../src/context.ts"],"names":[],"mappings":"AAYA;kEACkE;AAClE,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,WAAW;IAC1B,gFAAgF;IAChF,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IAC5B;;;+DAG2D;IAC3D,GAAG,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;IACxC,8DAA8D;IAC9D,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,QAAQ,CAAC,OAAO,CAAC,CAAC;IAC1C,8DAA8D;IAC9D,QAAQ,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAAC;IAChC,2EAA2E;IAC3E,YAAY,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,UAAU,CAAC;IACzD,oEAAoE;IACpE,UAAU,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,UAAU,CAAC;CACvE;AAED;;yEAEyE;AACzE,qBAAa,cAAe,YAAW,WAAW;IAChD,OAAO,CAAC,KAAK,CAA0B;gBAE3B,KAAK,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM;IAI/C,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAI3B,GAAG,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO;IAKvC,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,QAAQ,CAAC,OAAO,CAAC;IAIzC,QAAQ,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO;IAK/B,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,UAAU;IAKvD,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,UAAU;CAIrE"}
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../src/context.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAQ/C;kEACkE;AAClE,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,WAAW;IAC1B,gFAAgF;IAChF,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IAC5B;;;+DAG2D;IAC3D,GAAG,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;IACxC,8DAA8D;IAC9D,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,QAAQ,CAAC,OAAO,CAAC,CAAC;IAC1C,8DAA8D;IAC9D,QAAQ,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAAC;IAChC,2EAA2E;IAC3E,YAAY,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,UAAU,CAAC;IACzD,oEAAoE;IACpE,UAAU,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,UAAU,CAAC;IACtE;;;;;;iCAM6B;IAC7B,QAAQ,CAAC,YAAY,CAAC,EAAE,YAAY,CAAC;CACtC;AAED,MAAM,WAAW,qBAAqB;IACpC,uDAAuD;IACvD,YAAY,CAAC,EAAE,YAAY,CAAC;CAC7B;AAED;;;0EAG0E;AAC1E,qBAAa,cAAe,YAAW,WAAW;IAChD,OAAO,CAAC,KAAK,CAA0B;IACvC,QAAQ,CAAC,YAAY,EAAE,YAAY,CAAC;gBAExB,KAAK,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,EAAE,OAAO,GAAE,qBAA0B;IAKpF,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAI3B,GAAG,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO;IAMvC,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,QAAQ,CAAC,OAAO,CAAC;IAIzC,QAAQ,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO;IAK/B,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,UAAU;IAKvD,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,UAAU;CAKrE"}

package/dist/context.js

@@ -7,22 +7,32 @@
 //
 // (Performant execution over a real store is the tier-3 seam — see planner.ts —
 // which pushes work into the store instead of driving it row-by-row here.)
-import { coerceCollection, BUILTIN_FUNCTIONS, BUILTIN_METHODS } from "./semantics.js";
+import { coerceCollection, regexMatches, BUILTIN_FUNCTIONS, BUILTIN_METHODS } from "./semantics.js";
+// An array's only properties are its integer indices, spelled canonically
+// (`"0"`, `"12"`; never `"01"`, `"length"`, or a method name).
+function isIndexKey(key) {
+    return /^(0|[1-9]\d*)$/.test(key);
+}
 /** The default context: ordinary JavaScript objects. Named roots come from a
- * plain `{ name: collection }` map; properties are own/inherited keys; identity
- * is `.id` when present, else the object itself (reference identity). */
+ * plain `{ name: collection }` map; properties are OWN keys only (an array
+ * exposes only its integer indices, a primitive has none); identity is `.id`
+ * when present, else the row itself (the engine keys it structurally). */
 export class DefaultContext {
     roots;
-    constructor(roots = {}) {
+    regexDialect;
+    constructor(roots = {}, options = {}) {
         this.roots = roots;
+        this.regexDialect = options.regexDialect ?? "oqx";
     }
     root(name) {
-        return this.roots[name];
+        return Object.hasOwn(this.roots, name) ? this.roots[name] : undefined;
     }
     get(row, key) {
-        if (row == null)
+        if (row == null || typeof row !== "object")
             return undefined;
-        return Object(row)[key];
+        if (Array.isArray(row))
+            return isIndexKey(key) ? row[Number(key)] : undefined;
+        return Object.hasOwn(row, key) ? row[key] : undefined;
     }
     toRows(value) {
         return coerceCollection(value);
@@ -33,11 +43,13 @@ export class DefaultContext {
         return row;
     }
     callFunction(name, args) {
-        const fn = BUILTIN_FUNCTIONS[name];
+        const fn = Object.hasOwn(BUILTIN_FUNCTIONS, name) ? BUILTIN_FUNCTIONS[name] : undefined;
         return fn ? { handled: true, value: fn(args) } : { handled: false };
     }
     callMethod(name, recv, args) {
-        const fn = BUILTIN_METHODS[name];
+        if (name === "matches")
+            return { handled: true, value: regexMatches(recv, args, this.regexDialect) };
+        const fn = Object.hasOwn(BUILTIN_METHODS, name) ? BUILTIN_METHODS[name] : undefined;
         return fn ? { handled: true, value: fn(recv, args) } : { handled: false };
     }
 }

package/dist/context.js.map

@@ -1 +1 @@
-{"version":3,"file":"context.js","sourceRoot":"","sources":["../src/context.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAChF,iFAAiF;AACjF,gFAAgF;AAChF,4EAA4E;AAC5E,gFAAgF;AAChF,gFAAgF;AAChF,EAAE;AACF,gFAAgF;AAChF,2EAA2E;AAE3E,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AA2BtF;;yEAEyE;AACzE,MAAM,OAAO,cAAc;IACjB,KAAK,CAA0B;IAEvC,YAAY,QAAiC,EAAE;QAC7C,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACrB,CAAC;IAED,IAAI,CAAC,IAAY;QACf,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAC1B,CAAC;IAED,GAAG,CAAC,GAAY,EAAE,GAAW;QAC3B,IAAI,GAAG,IAAI,IAAI;YAAE,OAAO,SAAS,CAAC;QAClC,OAAQ,MAAM,CAAC,GAAG,CAA6B,CAAC,GAAG,CAAC,CAAC;IACvD,CAAC;IAED,MAAM,CAAC,KAAc;QACnB,OAAO,gBAAgB,CAAC,KAAK,CAAC,CAAC;IACjC,CAAC;IAED,QAAQ,CAAC,GAAY;QACnB,IAAI,GAAG,IAAI,IAAI,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,IAAI,IAAI,GAAG;YAAE,OAAQ,GAA+B,CAAC,EAAE,CAAC;QACtG,OAAO,GAAG,CAAC;IACb,CAAC;IAED,YAAY,CAAC,IAAY,EAAE,IAAe;QACxC,MAAM,EAAE,GAAG,iBAAiB,CAAC,IAAI,CAAC,CAAC;QACnC,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;IACtE,CAAC;IAED,UAAU,CAAC,IAAY,EAAE,IAAa,EAAE,IAAe;QACrD,MAAM,EAAE,GAAG,eAAe,CAAC,IAAI,CAAC,CAAC;QACjC,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;IAC5E,CAAC;CACF"}
+{"version":3,"file":"context.js","sourceRoot":"","sources":["../src/context.ts"],"names":[],"mappings":"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"}

package/dist/engine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../src/engine.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EACV,KAAK,EACN,MAAM,UAAU,CAAC;AAClB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAOhD,yEAAyE;AACzE,MAAM,MAAM,SAAS,GACjB;IAAE,QAAQ,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,EAAE,CAAA;CAAE,GACxC;IAAE,QAAQ,EAAE,QAAQ,CAAC;IAAC,MAAM,EAAE,OAAO,CAAA;CAAE,GACvC;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,OAAO,CAAA;CAAE,GACnC;IAAE,QAAQ,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GACpC;IAAE,QAAQ,EAAE,OAAO,CAAC;IAAC,GAAG,EAAE,OAAO,GAAG,IAAI,CAAA;CAAE,GAC1C;IAAE,QAAQ,EAAE,QAAQ,CAAC;IAAC,GAAG,EAAE,OAAO,GAAG,IAAI,CAAA;CAAE,CAAC;AAEhD,6EAA6E;AAC7E,MAAM,WAAW,MAAM;IACrB,GAAG,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,SAAS,OAAO,EAAE,GAAG,SAAS,CAAC;CAC5D;AA4BD,qBAAa,cAAe,YAAW,MAAM;IAC3C,OAAO,CAAC,GAAG,CAAc;gBAEb,OAAO,GAAE,WAAkC;IAIvD,GAAG,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,GAAE,SAAS,OAAO,EAAO,GAAG,SAAS;IAmD/D,OAAO,CAAC,OAAO;IAef,OAAO,CAAC,OAAO;IAKf,OAAO,CAAC,MAAM;IAId,OAAO,CAAC,KAAK;IASb,OAAO,CAAC,KAAK;IAab,OAAO,CAAC,SAAS;IAejB,OAAO,CAAC,iBAAiB;IA2BzB,OAAO,CAAC,UAAU;IA6DlB,OAAO,CAAC,KAAK;IAeb,OAAO,CAAC,UAAU;IASlB,OAAO,CAAC,SAAS;IAMjB,OAAO,CAAC,SAAS;IAcjB,OAAO,CAAC,WAAW;IAiCnB,OAAO,CAAC,MAAM;IAQd,OAAO,CAAC,QAAQ;IAKhB,OAAO,CAAE,aAAa;IAStB,OAAO,CAAC,SAAS;IAKjB,OAAO,CAAC,gBAAgB;IA2BxB,OAAO,CAAC,UAAU;IAwBlB,OAAO,CAAC,QAAQ;IAwDhB,OAAO,CAAC,SAAS;IAQjB,OAAO,CAAC,QAAQ;CAYjB;AAyFD,8EAA8E;AAC9E,wBAAgB,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,SAAS,OAAO,EAAE,EAAE,KAAK,EAAE,OAAO,GAAG,SAAS,CAG9F"}
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../src/engine.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EACV,KAAK,EACN,MAAM,UAAU,CAAC;AAClB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAOhD,yEAAyE;AACzE,MAAM,MAAM,SAAS,GACjB;IAAE,QAAQ,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,EAAE,CAAA;CAAE,GACxC;IAAE,QAAQ,EAAE,QAAQ,CAAC;IAAC,MAAM,EAAE,OAAO,CAAA;CAAE,GACvC;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,OAAO,CAAA;CAAE,GACnC;IAAE,QAAQ,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GACpC;IAAE,QAAQ,EAAE,OAAO,CAAC;IAAC,GAAG,EAAE,OAAO,GAAG,IAAI,CAAA;CAAE,GAC1C;IAAE,QAAQ,EAAE,QAAQ,CAAC;IAAC,GAAG,EAAE,OAAO,GAAG,IAAI,CAAA;CAAE,CAAC;AAEhD,6EAA6E;AAC7E,MAAM,WAAW,MAAM;IACrB,GAAG,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,SAAS,OAAO,EAAE,GAAG,SAAS,CAAC;CAC5D;AA4BD,qBAAa,cAAe,YAAW,MAAM;IAC3C,OAAO,CAAC,GAAG,CAAc;gBAEb,OAAO,GAAE,WAAkC;IAIvD,GAAG,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,GAAE,SAAS,OAAO,EAAO,GAAG,SAAS;IAmD/D,OAAO,CAAC,OAAO;IAef,OAAO,CAAC,OAAO;IAKf,OAAO,CAAC,MAAM;IAId,OAAO,CAAC,KAAK;IASb,OAAO,CAAC,KAAK;IAab,OAAO,CAAC,SAAS;IAiBjB,OAAO,CAAC,iBAAiB;IA6BzB,OAAO,CAAC,UAAU;IA8DlB,OAAO,CAAC,KAAK;IAgBb,OAAO,CAAC,UAAU;IASlB,OAAO,CAAC,SAAS;IAMjB,OAAO,CAAC,SAAS;IAYjB,OAAO,CAAC,WAAW;IAiCnB,OAAO,CAAC,MAAM;IAQd,OAAO,CAAC,QAAQ;IAKhB,OAAO,CAAE,aAAa;IAStB,OAAO,CAAC,SAAS;IAKjB,OAAO,CAAC,gBAAgB;IA2BxB,OAAO,CAAC,UAAU;IAwBlB,OAAO,CAAC,QAAQ;IA+DhB,OAAO,CAAC,SAAS;IAQjB,OAAO,CAAC,QAAQ;CAYjB;AAkGD,8EAA8E;AAC9E,wBAAgB,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,SAAS,OAAO,EAAE,EAAE,KAAK,EAAE,OAAO,GAAG,SAAS,CAG9F"}