@omgbase/core 0.24.0 → 0.27.1

package/dist/src/mutate/frontmatter-parts.js

@@ -0,0 +1,237 @@
+// Frontmatter entries (spec/mutate §11.3 "Frontmatter entries", 3.6). The
+// effect planner's `set`/`unset frontmatter.<key>` edits ONE entry of a
+// document's frontmatter and leaves every other byte alone. To do that the
+// `frontmatter` block's raw (fences included) is cut into an ordered list of
+// PARTS — the opening fence line, one part per top-level YAML entry (with the
+// lines that continue it and the comment lines that lead it), the trailing
+// comment/blank lines, the closing fence — by a LEXICAL, line-based rule, not
+// a YAML parse: it is total (every frontmatter the store holds, valid YAML or
+// not, splits), byte-exact (the parts concatenate back to the raw, always) and
+// identical in both engines; what a line *means* is the properties layer's
+// business. Where the rule and YAML disagree (a pathological document) the
+// edit may touch a wider or narrower run of lines than a YAML parser would,
+// but never loses a byte of the other entries.
+//
+// Storage is untouched: a revision's frontmatter stays one blob (spec/store
+// 15.0). The parts are the planner's view of the bytes, computed from
+// `frontmatter_raw` when a frontmatter key is set or unset.
+/** Split text into lines, each keeping its own line ending (`\n` or `\r\n`); the last line has none. `""` → `[""]`. */
+export function splitLines(text) {
+    const out = [];
+    let start = 0;
+    for (let i = 0; i < text.length; i++) {
+        if (text.charCodeAt(i) === 10) {
+            out.push(text.slice(start, i + 1));
+            start = i + 1;
+        }
+    }
+    out.push(text.slice(start));
+    return out;
+}
+/** A line without its line ending. */
+function content(line) {
+    return line.endsWith("\r\n") ? line.slice(0, -2) : line.endsWith("\n") ? line.slice(0, -1) : line;
+}
+/** The line ending of `line` (`"\r\n"`, `"\n"`, or `""` when it has none). */
+export function lineEndingOf(line) {
+    return line.endsWith("\r\n") ? "\r\n" : line.endsWith("\n") ? "\n" : "";
+}
+/** A blank line (empty, or spaces and tabs only). */
+export function isBlankLine(line) {
+    return /^[ \t]*$/.test(content(line));
+}
+/** A comment line — `#` in column 0. (An indented `#` is content: a block scalar's line, for one.) */
+export function isCommentLine(line) {
+    return content(line).startsWith("#");
+}
+/** A LEAD line: blank or comment — the lines that travel with the entry that follows them. */
+function isLeadLine(line) {
+    return isBlankLine(line) || isCommentLine(line);
+}
+// Characters that cannot begin a plain YAML key (flow indicators, anchors,
+// aliases, tags, block scalar indicators, directives, reserved).
+const NOT_A_PLAIN_KEY_START = new Set(["[", "]", "{", "}", ",", "&", "*", "!", "|", ">", "%", "@", "`"]);
+/**
+ * The entry boundary: the key of a column-0 line that opens a top-level
+ * mapping entry, or `null` when the line does not. A line opens an entry when
+ * it is not blank, not a comment, not a sequence item (`-` followed by a
+ * space, a tab or the end of the line), not an explicit key or value
+ * indicator (`?` / `:` the same way), not a document marker (`---` / `...`
+ * followed by whitespace or the end of the line), and reads as `<key>:`
+ * followed by a space, a tab or the end of the line — the key either
+ * - quoted: a `"…"` string (`\` escapes the next character) or a `'…'` string
+ *   (`''` is a literal quote), closed on the same line, then optional spaces/
+ *   tabs, then the colon; the key is the content with `\\` → `\`, `\"` → `"`
+ *   (double) or `''` → `'` (single) undone and every other escape kept as
+ *   written; or
+ * - plain: the text before the FIRST `:` that is followed by a space, a tab or
+ *   the end of the line, trailing spaces/tabs trimmed — non-empty, not
+ *   starting with a flow indicator, an anchor/alias/tag/block-scalar/
+ *   directive/reserved character (`[ ] { } , & * ! | > % @ \``) and not
+ *   containing ` #` or `\t#` (a comment would start there).
+ * Anything else — an indented line, a flow collection's continuation, a block
+ * scalar's content — is a continuation of the entry above it.
+ */
+export function entryKeyOf(line) {
+    const c = content(line);
+    if (c.length === 0)
+        return null;
+    const c0 = c[0];
+    if (c0 === " " || c0 === "\t" || c0 === "#")
+        return null;
+    if (c0 === '"' || c0 === "'")
+        return quotedKey(c, c0);
+    const c1 = c.length > 1 ? c[1] : "";
+    const wsOrEnd = (ch) => ch === "" || ch === " " || ch === "\t";
+    if ((c0 === "-" || c0 === "?" || c0 === ":") && wsOrEnd(c1))
+        return null;
+    if ((c.startsWith("---") || c.startsWith("...")) && wsOrEnd(c.length > 3 ? c[3] : ""))
+        return null;
+    if (NOT_A_PLAIN_KEY_START.has(c0))
+        return null;
+    const m = /^(.*?):(?:[ \t]|$)/.exec(c);
+    if (!m)
+        return null;
+    const key = m[1].replace(/[ \t]+$/, "");
+    if (key.length === 0 || / #|\t#/.test(key))
+        return null;
+    return key;
+}
+function quotedKey(c, quote) {
+    let i = 1;
+    let close = -1;
+    if (quote === '"') {
+        while (i < c.length) {
+            const ch = c[i];
+            if (ch === "\\")
+                i += 2;
+            else if (ch === '"') {
+                close = i;
+                break;
+            }
+            else
+                i++;
+        }
+    }
+    else {
+        while (i < c.length) {
+            if (c[i] === "'") {
+                if (c[i + 1] === "'")
+                    i += 2;
+                else {
+                    close = i;
+                    break;
+                }
+            }
+            else
+                i++;
+        }
+    }
+    if (close < 0)
+        return null;
+    if (!/^[ \t]*:(?:[ \t]|$)/.test(c.slice(close + 1)))
+        return null;
+    const inner = c.slice(1, close);
+    return quote === '"' ? inner.replace(/\\(["\\])/g, "$1") : inner.replace(/''/g, "'");
+}
+/**
+ * The frontmatter block's raw (fences included, no trailing line ending) → its
+ * parts, in order. The parts always concatenate back to `raw` byte for byte:
+ * every line of the raw lands in exactly one part.
+ *
+ * - part 0 is the opening fence line with its line ending, key `null`;
+ * - the last part is the closing fence line (no line ending), key `null`;
+ * - between them, the body lines: every line before the first entry line is
+ *   one part with key `null` (comments, blank lines, or — when no line opens
+ *   an entry: a bare scalar, a sequence — the whole body); then one part per
+ *   entry, from the first of the lead lines (blank / column-0 comment)
+ *   immediately preceding its key line (never reaching back past the
+ *   previous entry's key line) through the line before the next entry's
+ *   lead, the last entry ending before the trailing lead run; the trailing
+ *   lead run (blank / comment lines after the last entry's content) is one
+ *   part with key `null`.
+ *
+ * A raw with fewer than two lines (not a frontmatter block) is one part.
+ */
+export function splitFrontmatterRaw(raw) {
+    const lines = splitLines(raw);
+    if (lines.length < 2)
+        return [{ key: null, bytes: raw }];
+    const open = lines[0];
+    const close = lines[lines.length - 1];
+    const body = lines.slice(1, -1);
+    const parts = [{ key: null, bytes: open }];
+    const entryAt = body.map(entryKeyOf);
+    const entryIdx = [];
+    entryAt.forEach((k, i) => {
+        if (k !== null)
+            entryIdx.push(i);
+    });
+    if (entryIdx.length === 0) {
+        if (body.length > 0)
+            parts.push({ key: null, bytes: body.join("") });
+        parts.push({ key: null, bytes: close });
+        return parts;
+    }
+    // Where each entry's part starts: its lead run, bounded by the previous
+    // entry's key line; the first entry starts at its key line (the lines
+    // before it are the leading null part).
+    const starts = entryIdx.map((i, n) => {
+        if (n === 0)
+            return i;
+        const floor = entryIdx[n - 1] + 1;
+        let j = i;
+        while (j - 1 >= floor && isLeadLine(body[j - 1]))
+            j--;
+        return j;
+    });
+    // The trailing null part: the lead run after the last entry's key line.
+    let tail = body.length;
+    const lastKey = entryIdx[entryIdx.length - 1];
+    while (tail - 1 > lastKey && isLeadLine(body[tail - 1]))
+        tail--;
+    if (starts[0] > 0)
+        parts.push({ key: null, bytes: body.slice(0, starts[0]).join("") });
+    entryIdx.forEach((i, n) => {
+        const end = n + 1 < starts.length ? starts[n + 1] : tail;
+        parts.push({ key: entryAt[i], bytes: body.slice(starts[n], end).join("") });
+    });
+    if (tail < body.length)
+        parts.push({ key: null, bytes: body.slice(tail).join("") });
+    parts.push({ key: null, bytes: close });
+    return parts;
+}
+/** The inverse of {@link splitFrontmatterRaw}: the parts' bytes concatenated. */
+export function joinFrontmatterParts(parts) {
+    return parts.map((p) => p.bytes).join("");
+}
+/**
+ * The frontmatter block's raw and its trailing trivia, out of a document's
+ * `frontmatter_raw` (`raw + docs.frontmatter_trivia`, spec/mutate §2): the
+ * closing fence is the first line after the opening one that is `---`
+ * followed only by spaces/tabs (the format layer's rule); the raw ends with
+ * that line's content, the trivia is everything after. `null` when no closing
+ * fence is found (not a frontmatter the format layer would have produced).
+ */
+export function splitFrontmatterTrivia(frontmatterRaw) {
+    const lines = splitLines(frontmatterRaw);
+    for (let i = 1; i < lines.length; i++) {
+        const line = lines[i];
+        if (/^---[ \t]*$/.test(content(line))) {
+            const upto = lines.slice(0, i).join("") + content(line);
+            return { raw: upto, trivia: frontmatterRaw.slice(upto.length) };
+        }
+    }
+    return null;
+}
+/** The lines of a part that LEAD its key line (blank / column-0 comment lines), as one string; `""` for a part without a key. */
+export function leadOf(part) {
+    if (part.key === null)
+        return "";
+    const lines = splitLines(part.bytes);
+    let n = 0;
+    while (n < lines.length - 1 && isLeadLine(lines[n]))
+        n++;
+    return lines.slice(0, n).join("");
+}
+//# sourceMappingURL=frontmatter-parts.js.map

package/dist/src/mutate/load.js

@@ -1,3 +1,4 @@
+import { currentFrontmatterRaw } from "../core/read/document.js";
 export function loadMutDoc(db, docId) {
     const doc = db.prepare("SELECT doc_id, path, format, leading_trivia, frontmatter_trivia, current_rev FROM docs WHERE doc_id = ? AND deleted_commit IS NULL").get(docId);
     if (!doc)
@@ -44,15 +45,14 @@ export function loadMutDoc(db, docId) {
     }
     let frontmatterRaw = null;
     if (doc.current_rev) {
-        const rev = db.prepare("SELECT frontmatter_blob FROM revisions WHERE rev_id = ?").get(doc.current_rev);
-        if (rev?.frontmatter_blob) {
-            const fm = blob.get(rev.frontmatter_blob);
-            // Append the exact stored separator (docs.frontmatter_trivia) so the
-            // write path round-trips byte-for-byte. Ingest always captures it when a
-            // frontmatter block exists, so the ?? "" is just a type guard.
-            if (fm)
-                frontmatterRaw = fm.bytes.toString("utf8") + (doc.frontmatter_trivia ?? "");
-        }
+        // The current revision's frontmatter, resolved when stored as a delta
+        // (spec/store §6.1, 16.0). Append the exact stored separator
+        // (docs.frontmatter_trivia) so the write path round-trips byte-for-byte.
+        // Ingest always captures it when a frontmatter block exists, so the ?? ""
+        // is just a type guard.
+        const fm = currentFrontmatterRaw(db, doc.current_rev);
+        if (fm !== null)
+            frontmatterRaw = fm + (doc.frontmatter_trivia ?? "");
     }
     return {
         docId: doc.doc_id,

package/dist/src/mutate/select.js

@@ -1,5 +1,5 @@
 import { OqxError, parse } from "@omgbase/oqx";
-import { checkRootSpellings, oqxRunQuery, reservedAlias } from "../oqx-js/run.js";
+import { TUPLE_HINT, bracketListAsTuple, checkRootSpellings, oqxRunQuery, reservedAlias } from "../oqx-js/run.js";
 import { rootTarget } from "../oqx-js/planner.js";
 import { FilterInvalid } from "../search/cel/parser.js";
 import { EFFECT_OPS, EXPRESSION_LEADER, bareTarget, effectInvalid, findDocumentTarget, isNewSymbol, isTargetId, looksLikePath, validateEffect, validateTarget, } from "./effects.js";
@@ -545,8 +545,14 @@ function admitSelector(select, request) {
         checkRootSpellings(raw);
     }
     catch (e) {
-        if (e instanceof OqxError)
-            throw selectionInvalid(`select: ${e.message}`);
+        if (e instanceof OqxError) {
+            // (spec/surface 4.11) `id in ["a", "b"]` — the bracket list rewritten to a
+            // tuple is the `fix` (the same request over the corrected selector).
+            const rewritten = bracketListAsTuple(select, e.message);
+            if (rewritten === null)
+                throw selectionInvalid(`select: ${e.message}`);
+            throw selectionInvalid(`select: ${e.message}${TUPLE_HINT}`, request === undefined ? {} : { fix: fixRequest({ ...request, select: rewritten }) });
+        }
         if (e instanceof FilterInvalid)
             throw selectionInvalid(`select: ${e.message}`);
         throw e;

package/dist/src/oqx-js/context.js

@@ -5,8 +5,8 @@
 // store's raw column objects, tagged with their target; `get` routes field /
 // intrinsic / relation resolution per target, lazily querying the store for
 // relations. Domain functions (text/semantic/under_*/…) are row-scoped, so they
-// arrive via `callMethod` on a synthetic `$self` receiver (see run.ts's AST
-// rewrite) rather than as free functions (which see no row).
+// arrive via `callMethod` on the row as receiver — run.ts's AST rewrite turns
+// them into `$it.fn(…)` — rather than as free functions (which see no row).
 //
 // This is the correctness tier: N+1 queries, materialized collections — fine for
 // the corpus and the differential baseline. The tier-3 SQLite planner (planner.ts)
@@ -451,6 +451,18 @@ export function makeStoreContext(store, repoId, opts = {}) {
             return tag(load(), "blocks");
         return lazyOwner({ block_id: row.block_id, doc_id: row.doc_id, __path: row.__path }, "blocks", load);
     };
+    // `block` on a link row (spec/surface §1.2, 4.11): the SOURCE block the link
+    // was written in — the blocks row `block_id` (the edge's `src_block`) names,
+    // in the source document (`__path` is already the block's document path) —
+    // mirroring `doc`; absent when the link has none (a frontmatter link).
+    const linkBlock = (row) => {
+        if (!row.src_block)
+            return undefined;
+        const load = () => one(`SELECT b.*, d.path AS __path FROM blocks b JOIN docs d ON d.doc_id = b.doc_id WHERE b.block_id = ?`, row.src_block);
+        if (typeof row.__path !== "string")
+            return tag(load(), "blocks");
+        return lazyOwner({ block_id: row.src_block, doc_id: row.src_doc, __path: row.__path }, "blocks", load);
+    };
     // ---- engine attributes -----------------------------------------------------
     // Bare, snake_case, winning on collision (see the name rule above; spec/surface
     // §1.2, 3.0). `path` (and the edge field `dst_path`) is the REFERENCE form
@@ -600,13 +612,10 @@ export function makeStoreContext(store, repoId, opts = {}) {
             return row[key];
         }
         const r = row;
-        // `$self` = the current row: run.ts rewrites row-scoped domain functions
-        // (text/semantic/under_*/…) to `$self.fn(…)` so they arrive via callMethod
-        // with the row as receiver (a free function sees no row). Any other `$`
-        // name is OQX's (resolved by the engine before the row) or unknown — never
-        // an omgbase attribute.
-        if (key === "$self")
-            return r;
+        // A `$` name is OQX's (`$it`, `$key`, … — resolved by the engine before
+        // the row) or unknown — never an omgbase attribute. Row-scoped domain
+        // functions (text/semantic/under_*/…) never arrive here: run.ts rewrites
+        // them to `$it.fn(…)`, so they reach callMethod with the row as receiver.
         // engine attributes win on collision (the name rule above).
         if (ATTRIBUTES[t].has(key))
             return attribute(r, t, key);
@@ -628,6 +637,8 @@ export function makeStoreContext(store, repoId, opts = {}) {
             return owningBlock(r) ?? ABSENT_SINGLE;
         if (t === "links" && key === "dst")
             return destinationDoc(r) ?? ABSENT_SINGLE;
+        if (t === "links" && key === "block")
+            return linkBlock(r) ?? ABSENT_SINGLE;
         // relations.
         const rels = rel[t];
         if (rels[key])
@@ -656,7 +667,7 @@ export function makeStoreContext(store, repoId, opts = {}) {
             return jattr(r, key);
         return undefined;
     };
-    // ---- domain functions (row-scoped, via callMethod on $self) ---------------
+    // ---- domain functions (row-scoped, via callMethod on `$it`) ---------------
     const method = (name, recv, args) => {
         const r = recv;
         const t = r?.[TARGET];

package/dist/src/oqx-js/names.js

@@ -41,7 +41,7 @@ export const HANDLES = {
     docs: { doc: "docs" },
     blocks: { block: "blocks", doc: "docs" },
     nodes: { section: "nodes", doc: "docs", block: "blocks" },
-    links: { doc: "docs", dst: "docs" },
+    links: { doc: "docs", dst: "docs", block: "blocks" },
     revisions: { doc: "docs" },
 };
 /** The kinds whose row shape is closed: no authored data reaches a row by bare name. */

package/dist/src/oqx-js/run.d.ts

@@ -69,6 +69,11 @@ export interface OqxOptions {
      * the default of the AST entry (`oqxRunQuery`), whose caller is the write
      * selector compiler, where a name no row carries would select every row. */
     unknownNames?: UnknownNames;
+    /** The `query` call as the caller received it (spec/surface 4.11): the
+     * arguments a corrected call is spelled from when a parse error can be fixed
+     * (`data.fix`, the bracket-list rule below). Absent, the message still gains
+     * its hint and no `fix` is composed. */
+    request?: Record<string, unknown>;
 }
 export declare function rootPathLiterals(e: Expr): Expr;
 export declare function checkRootSpellings(q: Query): void;
@@ -78,6 +83,9 @@ export declare function reservedAlias(items: readonly SelectItem[]): FilterInval
 export declare const BARE_NEEDS_SELECT_MESSAGE = "`bare` needs a `select` \u2014 without a projection a hit is only its envelope";
 export declare const BARE_WITH_VALUES_MESSAGE = "`bare` is redundant with `values` \u2014 `values` is already the bare-values form; drop one";
 export declare function oqxRun(store: Store, repoId: string, source: string, opts?: OqxOptions): OqxResult;
+export declare const TUPLE_HINT = "; a list is written as a tuple: (\u2026)";
+/** The source with the bracket list at the error's offset rewritten to a tuple, or null when the rule does not apply. */
+export declare function bracketListAsTuple(source: string, message: string): string | null;
 /**
  * The AST entry (4.1): run an already parsed query — the source path above
  * after `parse`, and the selector compiler (`mutate/select.ts`), which appends

package/dist/src/oqx-js/run.js

@@ -14,9 +14,11 @@ import { FilterInvalid } from "../search/cel/parser.js";
 import { float32ToBlob } from "../core/vec.js";
 import { encodeCursor as encodeKeyset, decodePathCursor } from "../core/cursor.js";
 import { referencePath } from "../core/paths.js";
+import { canonicalJson } from "../mutate/canonical.js";
 // Row-scoped domain functions: authored as free calls (`text("x")`) that
 // implicitly reference the current row. `@omgbase/oqx` free functions receive no
-// row, so we rewrite them to `$self.fn(…)` (a method whose receiver is the row)
+// row, so we rewrite them to `$it.fn(…)` (a method whose receiver is the row —
+// `$it` is the language's own name for the scope's row, spec/oqx SEMANTICS §2)
 // — one `transform` over the AST (spec/oqx/AST.md §5), every block included.
 // `refs(x)` is NOT here: it reads no row (its argument is the value), so it stays
 // a free function served by the context's `callFunction`. The planner treats
@@ -117,7 +119,7 @@ export function foldDates(e) {
     return build.lit(dateMethod(e.name, e.recv.value, args).value);
 }
 function rewriteQuery(q) {
-    return transform(q, (e) => (e.kind === "call" && e.recv === null && ROW_FNS.has(e.name) ? { ...e, recv: build.ident("$self") } : foldDates(rootPathLiterals(e))));
+    return transform(q, (e) => (e.kind === "call" && e.recv === null && ROW_FNS.has(e.name) ? { ...e, recv: build.ident("$it") } : foldDates(rootPathLiterals(e))));
 }
 // A top-level `limit`/`offset` on the collect path is applied by the runner (see
 // oqxRunInner), so it must be a plain number literal here — there is no row to
@@ -231,7 +233,7 @@ const VALUE_KEY = "__oqx_value";
 // Rows as values (spec/surface §1.4, 1.2). The engine hands back store rows
 // wherever the projection made a row a VALUE — a nested `collect { }` /
 // `first { }` / `single { }` with an empty projection ("the row itself",
-// spec/oqx §12), a `values` projection of `$it`/`$self`, a field bound to a
+// spec/oqx §12), a `values` projection of `$it`, a field bound to a
 // row — and a store row is not a wire shape (column names, `attrs` as a JSON
 // string, the `__path` join column, Buffers). Walk the projected value and
 // render every tagged row as `{ id, path }` — the hit envelope's own keys
@@ -312,10 +314,95 @@ export function oqxRun(store, repoId, source, opts = {}) {
     catch (e) {
         // Normalize the library's errors to omgbase's contract (filter_invalid).
         if (e instanceof OqxError)
-            throw new FilterInvalid(e.message, "OQX");
+            throw parseInvalid(source, e, opts.request);
         throw e;
     }
 }
+// ---- the bracket-list fix (spec/surface §4 "Error data", 4.11) ----------------------
+//
+// OQX has no list literal; a tuple `("a", "b")` is the collection (`spec/oqx`
+// SEMANTICS §3b), so `id in ["a", "b"]` — the SQL habit — is the parse error
+// `unexpected '[' — expected a value (at offset N)`. When the source at N opens a
+// bracketed comma list of LITERALS closed by `]` (two or more members, each a
+// string, number, `true`, `false` or `null`; nothing nested), the message gains
+// `; a list is written as a tuple: (…)` and, when the request is known, the
+// error carries `fix`: the same request with that `[…]` rewritten to `(…)`.
+// Anything else at N (an identifier member, a nested bracket, one member, an
+// unclosed list) is the parser's error as it stands.
+const BRACKET_ERROR = /^unexpected '\[' — expected a value \(at offset (\d+)\)$/;
+export const TUPLE_HINT = "; a list is written as a tuple: (…)";
+/** The source with the bracket list at the error's offset rewritten to a tuple, or null when the rule does not apply. */
+export function bracketListAsTuple(source, message) {
+    const m = BRACKET_ERROR.exec(message);
+    if (!m)
+        return null;
+    const cps = Array.from(source);
+    const open = Number(m[1]);
+    if (cps[open] !== "[")
+        return null;
+    let i = open + 1;
+    let members = 0;
+    for (;;) {
+        i = skipSpaces(cps, i);
+        const end = literalEnd(cps, i);
+        if (end === null)
+            return null;
+        members++;
+        i = skipSpaces(cps, end);
+        if (cps[i] === ",") {
+            i++;
+            continue;
+        }
+        if (cps[i] === "]")
+            break;
+        return null;
+    }
+    if (members < 2)
+        return null;
+    cps[open] = "(";
+    cps[i] = ")";
+    return cps.join("");
+}
+function skipSpaces(cps, i) {
+    while (i < cps.length && /\s/.test(cps[i]))
+        i++;
+    return i;
+}
+/** The index just past one OQX literal starting at `i` (a string in either quote with `\<c>` escapes, an unsigned number, `true`/`false`/`null`), or null. */
+function literalEnd(cps, i) {
+    const c = cps[i];
+    if (c === undefined)
+        return null;
+    if (c === '"' || c === "'") {
+        let j = i + 1;
+        while (j < cps.length) {
+            if (cps[j] === "\\")
+                j += 2;
+            else if (cps[j] === c)
+                return j + 1;
+            else
+                j++;
+        }
+        return null;
+    }
+    if (/[0-9]/.test(c)) {
+        const m = /^[0-9]+(\.[0-9]+)?([eE][+-]?[0-9]+)?/.exec(cps.slice(i).join(""));
+        return m ? i + Array.from(m[0]).length : null;
+    }
+    for (const word of ["true", "false", "null"]) {
+        if (cps.slice(i, i + word.length).join("") === word && !/[A-Za-z0-9_$]/.test(cps[i + word.length] ?? ""))
+            return i + word.length;
+    }
+    return null;
+}
+/** The surface's `filter_invalid` for a parse error: the library's message, plus the tuple hint and `fix` when the bracket rule applies. */
+function parseInvalid(source, e, request) {
+    const rewritten = bracketListAsTuple(source, e.message);
+    if (rewritten === null)
+        return new FilterInvalid(e.message, "OQX");
+    const fix = request !== undefined ? canonicalJson({ ...request, query: rewritten }) : undefined;
+    return new FilterInvalid(e.message + TUPLE_HINT, "OQX", fix);
+}
 function oqxRunInner(store, repoId, source, opts) {
     const raw = parse(source);
     const reserved = reservedAlias(raw.select);

package/dist/src/oqx-js/sql/translate.js

@@ -56,7 +56,7 @@ export const NON_PROPERTY_NAMES = {
     docs: new Set(["doc", "nodes", "blocks", "out_links", "in_links", "revisions", "data", "frontmatter", "inline"]),
     blocks: new Set(["block", "doc", "children", "nodes", "out_links", "section", "attrs"]),
     nodes: new Set(["section", "doc", "block", "blocks", "subsections", "children", "attrs"]),
-    links: new Set(["doc", "dst"]),
+    links: new Set(["doc", "dst", "block"]),
 };
 // ---- engine attributes ------------------------------------------------------
 // The engine attributes (spec/surface §1.2, 3.0: bare, snake_case, winning on
@@ -365,6 +365,26 @@ export function translateOperand(e, ctx) {
                     return text(`(SELECT bb.${k} FROM blocks bb WHERE bb.block_id = ${self}.block_id)`);
                 return null;
             }
+            // block.<x> reach-through from a link (spec/surface §1.2, 4.11): the SOURCE
+            // block, keyed by the row's own `src_block` — `block.id` is that FK column
+            // (NULL for a frontmatter link, exactly where `block` is absent in memory);
+            // everything else is a primary-key probe of the block row, NULL for the
+            // same rows (`block.path` reads the scan's joined source document inside
+            // the probe, so it too is NULL when there is no block). `raw`, `hash`,
+            // `updated_at`, `attrs` and the relations stay residual.
+            if (head === "block" && target === "links" && rest.length === 1) {
+                const k = rest[0];
+                const probe = (col) => text(`(SELECT ${col} FROM blocks bb WHERE bb.block_id = ${self}.src_block)`);
+                if (k === "id")
+                    return text(`${self}.src_block`);
+                if (k === "path")
+                    return probe(`'/' || ${doc}.path`);
+                if (k === "doc_id")
+                    return probe("bb.doc_id");
+                if (k === "type" || k === "text")
+                    return probe(`bb.${k}`);
+                return null;
+            }
             return null;
         }
         case "call": {

package/dist/src/search/cel/parser.d.ts

@@ -2,6 +2,8 @@ import type { Node } from "./ast.js";
 export declare class FilterInvalid extends Error {
     reason: string;
     hint: string;
-    constructor(reason: string, hint?: string);
+    /** (spec/surface 4.11) a literal corrected call, canonical JSON, when the surface can spell one (`data.fix`). */
+    fix: string | undefined;
+    constructor(reason: string, hint?: string, fix?: string);
 }
 export declare function parseFilter(src: string): Node;

package/dist/src/search/cel/parser.js

@@ -4,10 +4,13 @@ import { lex, LexError } from "./lexer.js";
 export class FilterInvalid extends Error {
     reason;
     hint;
-    constructor(reason, hint = "see query-language.md §3") {
+    /** (spec/surface 4.11) a literal corrected call, canonical JSON, when the surface can spell one (`data.fix`). */
+    fix;
+    constructor(reason, hint = "see query-language.md §3", fix) {
         super(reason);
         this.reason = reason;
         this.hint = hint;
+        this.fix = fix;
     }
 }
 const RELOPS = new Set(["==", "!=", "<", "<=", ">", ">="]);

package/dist/src/spec-versions.d.ts

@@ -2,13 +2,13 @@ export declare const SPEC_VERSIONS: {
     readonly oqx: "0.25";
     readonly format: "0.2";
     readonly reconcile: "2.3";
-    readonly store: "15.0";
-    readonly properties: "1.1";
+    readonly store: "16.0";
+    readonly properties: "1.2";
     readonly graph: "1.1";
     readonly search: "2.0";
-    readonly mutate: "3.5";
+    readonly mutate: "3.6";
     readonly sync: "2.2";
-    readonly surface: "4.10";
+    readonly surface: "4.11";
     readonly cli: "4.6";
 };
 export type SpecName = keyof typeof SPEC_VERSIONS;

package/dist/src/spec-versions.js

@@ -13,13 +13,13 @@ export const SPEC_VERSIONS = {
     oqx: LANGUAGE_VERSION,
     format: "0.2",
     reconcile: "2.3",
-    store: "15.0",
-    properties: "1.1",
+    store: "16.0",
+    properties: "1.2",
     graph: "1.1",
     search: "2.0",
-    mutate: "3.5",
+    mutate: "3.6",
     sync: "2.2",
-    surface: "4.10",
+    surface: "4.11",
     cli: "4.6",
 };
 //# sourceMappingURL=spec-versions.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omgbase/core",
-  "version": "0.24.0",
+  "version": "0.27.1",
   "description": "Open Markdown Graph Base — embedded engine",
   "license": "MIT",
   "repository": {