@omgbase/core 0.21.0 → 0.24.0

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

@@ -165,6 +165,14 @@ function kindOfPath(on, path) {
             cur = seg;
             continue;
         }
+        // At a group scope `rows` yields the grouped rows (their kind); a key is a
+        // value the language built, not a row of any kind.
+        if (typeof cur === "object") {
+            if (seg !== "rows" || i !== 0)
+                return null;
+            cur = cur.group;
+            continue;
+        }
         if (seg === "$it" && i === 0)
             continue;
         const next = HANDLES[cur][seg] ?? RELATIONS[cur][seg];
@@ -172,7 +180,7 @@ function kindOfPath(on, path) {
             return null;
         cur = next;
     }
-    return cur === "root" ? null : cur;
+    return cur === "root" || typeof cur === "object" ? null : cur;
 }
 /** The kind of the frontier rows of a walk: the seeds' kind when every destination yields rows of that same kind, else unknown. */
 function kindOfFrontier(seed, f, readDepth, byDepth) {
@@ -194,13 +202,16 @@ export function kindOfScope(steps) {
     for (const step of steps) {
         const e = step.expr;
         if (e.kind === "follow")
-            cur = kindOfFrontier(cur === "root" ? null : cur, e, readDepth, byDepth);
+            cur = kindOfFrontier(cur === "root" || typeof cur === "object" ? null : cur, e, readDepth, byDepth);
+        // A `group by` step (oqx 0.24): the rows at this depth become groups of them.
+        else if (e.kind === "groupBy")
+            cur = { group: cur === "root" || typeof cur === "object" ? null : cur };
         else
             cur = kindOfExpr(e, cur, readDepth, byDepth);
         byDepth.set(step.depth, cur);
         readDepth = step.depth;
     }
-    return cur === "root" ? null : cur;
+    return cur === "root" || typeof cur === "object" ? null : cur;
 }
 /** Judge a dotted name read on rows of `target`; null = known. */
 function judge(store, repoId, target, path) {

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

@@ -91,6 +91,15 @@ function subMayRaise(s, target) {
         return true;
     if (s.follow && followMayRaise(s.follow, target))
         return true;
+    // A grouped block (oqx 0.24) evaluates its keys, `having` and its aggregates
+    // (`sum` over a string raises) per group.
+    if (s.groupBy?.keys.some((k) => exprMayRaise(k.expr, target, false)))
+        return true;
+    if (s.having && whereMayRaise(s.having, target, false))
+        return true;
+    // A flattened block (oqx 0.25) evaluates each `flatten` expression per row.
+    if (s.flatten.some((f) => exprMayRaise(f.expr, target, false)))
+        return true;
     if (s.limit && exprMayRaise(s.limit, target, false))
         return true;
     if (s.offset && exprMayRaise(s.offset, target, false))
@@ -133,6 +142,9 @@ function exprMayRaise(e, target, root) {
         // a record is an eval error only the data decides, so with any interpolation
         // it may raise.
         case "template": return e.parts.some((p) => typeof p !== "string");
+        // An aggregate (oqx 0.24) raises on a non-number under `sum`/`avg`, which
+        // only the data decides; a grouped query is never planned anyway (below).
+        case "aggregate": return true;
         case "lit":
         case "binding": return false;
     }
@@ -148,8 +160,15 @@ export class SQLiteQueryPlanner {
         this.ctxOpts = ctxOpts;
     }
     plan(query, params) {
-        // Only simple top-level scans: no follow, no `from E` re-projection.
-        if (query.follow || query.from.length > 0)
+        // Only simple top-level scans: no follow, no `from E` re-projection, no
+        // `group by` (oqx 0.24), no `flatten` (oqx 0.25). A grouped or flattened
+        // query is declined whole: its `where` conjuncts could be pushed (the fan-out
+        // and the grouping happen after them, so the residual would flatten and
+        // group the produced rows correctly), but a pushed conjunct that empties the
+        // scan would hide an eval error a `flatten` expression, an aggregate or
+        // `having` raises in memory (`x!`, `sum` over a string) — decline (c)
+        // extended to the post-where clauses. SQL pushdown of either is a later round.
+        if (query.follow || query.from.length > 0 || query.groupBy || query.flatten.length > 0)
             return null;
         const target = rootTarget(query.source);
         if (!target)

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

@@ -72,6 +72,7 @@ export interface OqxOptions {
 }
 export declare function rootPathLiterals(e: Expr): Expr;
 export declare function checkRootSpellings(q: Query): void;
+export declare function foldDates(e: Expr): Expr;
 export declare function collectSemanticPhrases(source: string): string[];
 export declare function reservedAlias(items: readonly SelectItem[]): FilterInvalid | null;
 export declare const BARE_NEEDS_SELECT_MESSAGE = "`bare` needs a `select` \u2014 without a projection a hit is only its envelope";

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

@@ -9,6 +9,7 @@ import { makeStoreContext, rowRef } from "./context.js";
 import { SQLiteQueryPlanner } from "./planner.js";
 import { REPO_REMOVED_MESSAGE, ROOTS, bareTargetMessage, pastRootMessage, unknownTargetMessage } from "./root-row.js";
 import { checkNames } from "./names.js";
+import { DATE_FUNCTIONS, DATE_METHODS, dateFunction, dateMethod } from "./dates.js";
 import { FilterInvalid } from "../search/cel/parser.js";
 import { float32ToBlob } from "../core/vec.js";
 import { encodeCursor as encodeKeyset, decodePathCursor } from "../core/cursor.js";
@@ -91,8 +92,32 @@ export function checkRootSpellings(q) {
         },
     });
 }
+// Dates over literals fold to literals (spec/surface §1.3 "Dates and
+// durations", 4.8): `date("today")`, `dur("30 days")`, and a date method whose
+// receiver and arguments are literals (`date("today").minus(dur("30 days"))`,
+// folded inside-out since `transform` maps children first) become the string /
+// number / null they evaluate to — by the SAME functions the context runs, so
+// nothing changes in meaning — before the planner sees the tree. So `where
+// updated_at < date("today")` is a text-vs-text comparison the translator
+// pushes down (a call is otherwise an unconditional decline), and a named point
+// is resolved ONCE per query. A call with the wrong arity is left in place: it
+// raises when evaluated, and an empty source never evaluates it (spec/oqx §11).
+const isLit = (e) => e.kind === "lit";
+export function foldDates(e) {
+    if (e.kind !== "call" || !e.args.every(isLit))
+        return e;
+    const args = e.args.map((a) => a.value);
+    if (e.recv === null) {
+        if (!Object.hasOwn(DATE_FUNCTIONS, e.name) || DATE_FUNCTIONS[e.name] !== args.length)
+            return e;
+        return build.lit(dateFunction(e.name, args).value);
+    }
+    if (!isLit(e.recv) || !Object.hasOwn(DATE_METHODS, e.name) || DATE_METHODS[e.name] !== args.length)
+        return 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") } : rootPathLiterals(e)));
+    return transform(q, (e) => (e.kind === "call" && e.recv === null && ROW_FNS.has(e.name) ? { ...e, recv: build.ident("$self") } : 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
@@ -347,6 +372,33 @@ function runResolved(store, repoId, raw, opts) {
         const res = engine.run(parsed, []);
         return { hits: [], truncated: false, cursor: null, consumer: "none", none: res.consumer === "none" ? res.none : true };
     }
+    // A grouped query (oqx 0.24, SEMANTICS §24) yields GROUPS, not store rows:
+    // the envelope does not apply — there is no `id`/`path` to inject and no
+    // keyset to page by — so a hit is the group's projection as the query wrote
+    // it (`{ layer, n }`), exactly what `bare` yields for a row query; `bare` is
+    // accepted and changes nothing. Rows that surface as values (`rows collect {
+    // }` with an empty projection, `collect(doc)`) render as `{ id, path }` refs
+    // like every row-as-value. Paging is by position: the query's own
+    // `limit`/`offset` define the set, the tool's `limit` takes the first page,
+    // `truncated` says whether more groups follow, the cursor is always null (as
+    // under a custom `order by`). `distinct` cannot occur (a parse error).
+    if (parsed.groupBy)
+        return runGrouped(engine, parsed, consumer, opts);
+    // A flattened query (oqx 0.25, SEMANTICS §25) yields the parent rows, one per
+    // element: a hit is still a store row, so the envelope is injected as usual
+    // and repeats per element (Dataview's `TABLE … FLATTEN`). What changes is
+    // uniqueness — `(path, id)` no longer names one hit — so the keyset cursor
+    // cannot land inside a document's elements: a flattened query pages
+    // positionally with a null cursor, as a grouped query and a custom `order by`
+    // do (a keyset extended with the flatten ordinal is a later round). A bound
+    // name of `id` or `path` would shadow the envelope's own reads (the name
+    // shadows a same-named row property on the flattened row): refused, like a
+    // projection that collides with the envelope.
+    const flattened = parsed.flatten.length > 0;
+    for (const f of parsed.flatten) {
+        if (ENVELOPE_KEYS.has(f.name))
+            throw new FilterInvalid(`flatten \`as ${f.name}\` collides with the hit envelope — a flattened row is still the row, whose \`${f.name}\` the envelope reads; bind another name`, "OQX");
+    }
     // collect / first / single: inject id + path so every hit carries them. A
     // top-level `select distinct` is applied HERE, not in the engine: the injected
     // id/path are unique per row and would defeat the engine's projection dedup, so
@@ -400,7 +452,7 @@ function runResolved(store, repoId, raw, opts) {
     const limit = constBound(topLimit, "limit");
     if (offset || limit != null)
         rows = rows.slice(offset, limit == null ? undefined : offset + limit);
-    const custom = !!parsed.orderBy && parsed.orderBy.length > 0;
+    const custom = (!!parsed.orderBy && parsed.orderBy.length > 0) || flattened;
     const cap = opts.limit ?? 50;
     let page = rows;
     if (!custom && opts.cursor) {
@@ -417,6 +469,34 @@ function runResolved(store, repoId, raw, opts) {
         return { hits: [], truncated, cursor, consumer: "collect", values: page.map((s) => s.proj[VALUE_KEY]) };
     return { hits: page.map(render), truncated, cursor, consumer: "collect" };
 }
+// The collect/first/single path of a grouped query (see `runResolved`).
+function runGrouped(engine, parsed, consumer, opts) {
+    const topValues = parsed.values;
+    // A `values` projection rides as a record under VALUE_KEY and is peeled off
+    // the page, as on the row path.
+    const select = topValues ? [{ ...parsed.select[0], name: VALUE_KEY }] : parsed.select;
+    const { limit: topLimit, offset: topOffset } = parsed;
+    const base = consumer === "collect" ? { ...parsed, limit: null, offset: null } : parsed;
+    const res = engine.run({ ...base, values: false, select }, []);
+    const project = (row) => renderValue(row);
+    if (consumer === "first" || consumer === "single") {
+        const row = res.consumer === "first" || res.consumer === "single" ? res.row : null;
+        if (topValues)
+            return { hits: [], truncated: false, cursor: null, consumer, values: row == null ? [] : [project(row)[VALUE_KEY]] };
+        return { hits: row == null ? [] : [project(row)], truncated: false, cursor: null, consumer };
+    }
+    let groups = (res.consumer === "collect" ? res.rows : []).map(project);
+    const offset = constBound(topOffset, "offset") ?? 0;
+    const limit = constBound(topLimit, "limit");
+    if (offset || limit != null)
+        groups = groups.slice(offset, limit == null ? undefined : offset + limit);
+    const cap = opts.limit ?? 50;
+    const truncated = groups.length > cap;
+    const page = groups.slice(0, cap);
+    if (topValues)
+        return { hits: [], truncated, cursor: null, consumer: "collect", values: page.map((g) => g[VALUE_KEY]) };
+    return { hits: page, truncated, cursor: null, consumer: "collect" };
+}
 export async function oqxRunAsync(store, repoId, source, opts = {}, embedQuery) {
     const phrases = collectSemanticPhrases(source);
     if (phrases.length === 0)

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

@@ -60,14 +60,16 @@ export const NON_PROPERTY_NAMES = {
 };
 // ---- engine attributes ------------------------------------------------------
 // The engine attributes (spec/surface §1.2, 3.0: bare, snake_case, winning on
-// collision — `id`, `path`, `raw`, `hash`, `updated_at` on docs and blocks,
-// `title`/`tags` on docs, `id`/`path` on nodes and edges) → a param-free SQL
+// collision — `id`, `path`, `raw`, `hash`, `updated_at`, `created_at` on docs
+// and blocks, `title`/`tags` on docs, `id`/`path` on nodes and edges) → a param-free SQL
 // scalar, per target, with its kind. The structural columns and foreign keys are
 // translated in `translateOperand`. Anything not mapped (`raw`, reconstructed or
 // a blob; `title`, computed; `tags`, the union of the authored list and the
 // computed hashtags) returns null → residual, and the caller must NOT fall
 // through to a property read of the same name (the attribute wins in memory).
-// `updated_at` is a correlated subquery. `path` (and the edge field `dst_path`)
+// `updated_at` and `created_at` (4.10) are correlated subqueries over the
+// document's revisions (`current_rev` / `seq = 1`); a block's are residual, as
+// before. `path` (and the edge field `dst_path`)
 // is the REFERENCE form on the surface (spec/surface §1 "Paths", 2.0) — `'/' ||
 // <storage column>` in SQL — so every comparison, `startsWith`, `contains`,
 // `lower()`… sees exactly the string the in-memory attribute yields;
@@ -79,8 +81,8 @@ export function pathColumn(col) {
 /** The identity/bytes/time attributes per kind — the names `attributeSql` owns
  * (the structural columns are handled per target in `translateOperand`). */
 export const ROW_ATTRIBUTES = {
-    docs: new Set(["id", "path", "raw", "hash", "updated_at", "title", "tags"]),
-    blocks: new Set(["id", "path", "raw", "hash", "updated_at"]),
+    docs: new Set(["id", "path", "raw", "hash", "updated_at", "created_at", "title", "tags"]),
+    blocks: new Set(["id", "path", "raw", "hash", "updated_at", "created_at"]),
     nodes: new Set(["id", "path"]),
     links: new Set(["id", "path"]),
 };
@@ -93,6 +95,7 @@ function attributeSql(name, ctx) {
             case "path": return pathColumn(`${doc}.path`);
             case "hash": return text(`lower(hex(${self}.file_hash))`);
             case "updated_at": return text(`(SELECT c.ts FROM revisions r JOIN commits c ON c.commit_id = r.commit_id WHERE r.rev_id = ${self}.current_rev)`);
+            case "created_at": return text(`(SELECT c.ts FROM revisions r JOIN commits c ON c.commit_id = r.commit_id WHERE r.doc_id = ${self}.doc_id AND r.seq = 1)`);
         }
     else if (target === "blocks")
         switch (name) {
@@ -300,6 +303,8 @@ export function translateOperand(e, ctx) {
                     return text(`lower(hex(${doc}.file_hash))`);
                 if (k === "updated_at")
                     return text(`(SELECT c.ts FROM revisions r JOIN commits c ON c.commit_id = r.commit_id WHERE r.rev_id = ${doc}.current_rev)`);
+                if (k === "created_at")
+                    return text(`(SELECT c.ts FROM revisions r JOIN commits c ON c.commit_id = r.commit_id WHERE r.doc_id = ${doc}.doc_id AND r.seq = 1)`);
                 if (k === "format")
                     return text(`${doc}.format`);
                 if (k.startsWith("$"))
@@ -334,6 +339,8 @@ export function translateOperand(e, ctx) {
                     return probe("lower(hex(dd.file_hash))");
                 if (k === "updated_at")
                     return probe("(SELECT c.ts FROM revisions r JOIN commits c ON c.commit_id = r.commit_id WHERE r.rev_id = dd.current_rev)");
+                if (k === "created_at")
+                    return probe("(SELECT c.ts FROM revisions r JOIN commits c ON c.commit_id = r.commit_id WHERE r.doc_id = dd.doc_id AND r.seq = 1)");
                 if (k === "format")
                     return probe("dd.format");
                 if (k.startsWith("$"))

package/dist/src/oqx-js/store-index.js

@@ -79,7 +79,7 @@ function probeFor(target, path) {
     // relation / handle (`out_links`, `data`, `frontmatter`, …), not the `format` column
     // (not indexed), not an OQX `$` name, and of the engine attributes only
     // `title` (the computed `$title` row, a scalar property the author's `title:`
-    // never reaches — `data.title` does): `raw`, `hash`, `updated_at` and `tags`
+    // never reaches — `data.title` does): `raw`, `hash`, `updated_at`, `created_at` and `tags`
     // (authored ∪ hashtags) have no index and are never property probes.
     if (key === "title")
         return { kind: "property", key: "$title", source: "computed" };

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

@@ -1,14 +1,14 @@
 export declare const SPEC_VERSIONS: {
-    readonly oqx: "0.23";
+    readonly oqx: "0.25";
     readonly format: "0.2";
     readonly reconcile: "2.3";
-    readonly store: "14.2";
+    readonly store: "15.0";
     readonly properties: "1.1";
     readonly graph: "1.1";
     readonly search: "2.0";
     readonly mutate: "3.5";
     readonly sync: "2.2";
-    readonly surface: "4.7";
-    readonly cli: "4.5";
+    readonly surface: "4.10";
+    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: "14.2",
+    store: "15.0",
     properties: "1.1",
     graph: "1.1",
     search: "2.0",
     mutate: "3.5",
     sync: "2.2",
-    surface: "4.7",
-    cli: "4.5",
+    surface: "4.10",
+    cli: "4.6",
 };
 //# sourceMappingURL=spec-versions.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omgbase/core",
-  "version": "0.21.0",
+  "version": "0.24.0",
   "description": "Open Markdown Graph Base — embedded engine",
   "license": "MIT",
   "repository": {
@@ -55,7 +55,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.30.0",
-    "@omgbase/oqx": "^0.23.0",
+    "@omgbase/oqx": "^0.25.0",
     "better-sqlite3": "^13.0.3",
     "mdast-util-from-markdown": "^2.0.2",
     "mdast-util-frontmatter": "^2.0.1",