@omgbase/core 0.19.0 → 0.21.0

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

@@ -6,8 +6,9 @@
 // in-tree compiler, so every caller and the corpus are unchanged.
 import { parse, PlannedEngine, InMemoryEngine, OqxError, resolveAliases, transform, visit, build, semantics } from "@omgbase/oqx";
 import { makeStoreContext, rowRef } from "./context.js";
-import { SQLiteQueryPlanner, rootTarget } from "./planner.js";
-import { REPO_REMOVED_MESSAGE, TARGETS, bareTargetMessage, pastRootMessage, unknownTargetMessage } from "./root-row.js";
+import { SQLiteQueryPlanner } from "./planner.js";
+import { REPO_REMOVED_MESSAGE, ROOTS, bareTargetMessage, pastRootMessage, unknownTargetMessage } from "./root-row.js";
+import { checkNames } from "./names.js";
 import { FilterInvalid } from "../search/cel/parser.js";
 import { float32ToBlob } from "../core/vec.js";
 import { encodeCursor as encodeKeyset, decodePathCursor } from "../core/cursor.js";
@@ -72,8 +73,8 @@ export function rootPathLiterals(e) {
 export function checkRootSpellings(q) {
     // A top-level `from <name>` that is no collection (`from edges`, the links
     // target's name before 3.0) would scan an absent root and come back empty:
-    // refused, naming the four collections (root-row.ts).
-    if (q.source.kind === "ident" && !TARGETS.has(q.source.name))
+    // refused, naming the five collections (root-row.ts).
+    if (q.source.kind === "ident" && !ROOTS.has(q.source.name))
         throw new FilterInvalid(unknownTargetMessage(q.source.name), "OQX");
     visit(q, {
         enter(node, ctx) {
@@ -84,7 +85,7 @@ export function checkRootSpellings(q) {
             if (node.kind === "ident" && ctx.depth >= 1 && (node.name === "docs" || node.name === "links")) {
                 throw new FilterInvalid(bareTargetMessage(node.name, ctx.depth), "OQX");
             }
-            if (node.kind === "outer" && TARGETS.has(node.name) && node.levels > ctx.depth) {
+            if (node.kind === "outer" && ROOTS.has(node.name) && node.levels > ctx.depth) {
                 throw new FilterInvalid(pastRootMessage(node.name, node.levels), "OQX");
             }
         },
@@ -165,8 +166,9 @@ function envelopeCollision(items) {
     return null;
 }
 // A hit is a store row (spec/surface §1.4, 1.5). The engine's top-level rows
-// are store rows by construction when the source is a bare root scan and
-// nothing re-projects them; a `follow` destination (`follow before` over a
+// are store rows by construction when the source is a bare root scan (one of
+// the five collections, `revisions` included — the planner's `rootTarget` is
+// narrower: the four it can plan) and nothing re-projects them; a `follow` destination (`follow before` over a
 // frontmatter list of paths), a `from E` re-projection or any other source can
 // reach a scalar, which the injected `id`/`path` reads would render as the
 // junk hit `{ id: "undefined", path: "" }`. For those queries the row itself is
@@ -177,7 +179,7 @@ function envelopeCollision(items) {
 const SELF_KEY = "__oqx_self";
 const SELF_ITEM = build.field(SELF_KEY, build.ident("$it"));
 function mayReachNonRows(q) {
-    return q.follow !== null || q.from.length > 0 || rootTarget(q.source) === null;
+    return q.follow !== null || q.from.length > 0 || !(q.source.kind === "ident" && ROOTS.has(q.source.name));
 }
 function describeValue(v) {
     if (v === null || v === undefined)
@@ -195,7 +197,7 @@ function describeValue(v) {
     return "an object";
 }
 function notAStoreRow(v) {
-    return new FilterInvalid(`a hit must be a document, block, node or link row — the query reached ${describeValue(v)}; to follow document references held in a property use refs(<field>)`, "OQX");
+    return new FilterInvalid(`a hit must be a document, block, node, link or revision row — the query reached ${describeValue(v)}; to follow document references held in a property use refs(<field>)`, "OQX");
 }
 // The reserved key a top-level `values` projection's single item is renamed to,
 // so it rides through id/path injection, keyset paging, and distinct as an
@@ -294,19 +296,36 @@ function oqxRunInner(store, repoId, source, opts) {
     const reserved = reservedAlias(raw.select);
     if (reserved)
         throw reserved;
-    return oqxRunQuery(store, repoId, raw, opts);
+    // The source entry is every read: a tier-3 name on an open kind is a hint.
+    return oqxRunQuery(store, repoId, raw, { unknownNames: "hint", ...opts });
 }
 /**
  * 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
  * its slot items to the RAW tree so a user alias a template reads is inlined
  * by the alias resolution here. Errors are the library's own (`OqxError`);
- * `oqxRun` normalizes them, a caller of this entry does the same.
+ * `oqxRun` normalizes them, a caller of this entry does the same. Unknown
+ * names (4.6) default to `"refuse"` here: this entry's caller is the write
+ * selector, where a name no row carries would select every row; the source
+ * entry passes `"hint"`.
  */
 export function oqxRunQuery(store, repoId, raw, opts = {}) {
+    checkRootSpellings(raw);
+    // Unknown names (spec/surface §1.5): judged over the RAW tree — before alias
+    // resolution and the runner's own items — so an alias is never mistaken for
+    // a row property and the verdict never depends on the rows. The selector
+    // compiler's slot items (`__omg_sel_*`, the templates' expressions) are not
+    // the selector: an expression reading an absent property there is
+    // spec/mutate's `target_missing` / absent value, not an unknown name.
+    const own = { ...raw, select: raw.select.filter((it) => !RESERVED_ALIAS_PREFIXES.some((p) => it.name.startsWith(p))) };
+    const hints = checkNames(store, repoId, own, opts.unknownNames ?? "refuse");
+    const result = runResolved(store, repoId, raw, opts);
+    // `hints` is the last member, present only when there is something to say.
+    return hints.length === 0 ? result : { ...result, hints };
+}
+function runResolved(store, repoId, raw, opts) {
     // The query's `select` aliases are resolved HERE, once, before the runner
     // renames/injects items (an engine evaluates the query it is given).
-    checkRootSpellings(raw);
     const parsed = rewriteQuery(resolveAliases(raw));
     const consumer = parsed.consumer;
     const ctxOpts = opts.semanticVectors ? { semanticVectors: opts.semanticVectors } : {};

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

@@ -53,7 +53,7 @@ import { TARGETS } from "../root-row.js";
  * `translate.test.ts` asserts this set against the store context.
  */
 export const NON_PROPERTY_NAMES = {
-    docs: new Set(["doc", "nodes", "blocks", "out_links", "in_links", "data", "frontmatter", "inline"]),
+    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"]),

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

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

package/dist/src/sync/observe.js

@@ -189,9 +189,15 @@ function commitPrepared(store, repoId, prepared, ts, oldHashHex, newHashHex) {
     const conflicted = hasConflictMarkers(content);
     const resolveIds = makeReconcilingResolver(store, repoId, { ts, path, prepared });
     const res = ingestFile(store, repoId, path, content, { ts, origin: "observed", resolveIds, parsed: prepared.tree, conflicted });
-    const rows = store.db
-        .prepare("SELECT kind, count(*) n FROM dispositions WHERE commit_id = ? GROUP BY kind ORDER BY kind")
-        .all(res.commitId);
+    // The outcome counts every verdict the matcher produced, `same` included —
+    // it describes what the matcher saw; the `dispositions` table describes
+    // what changed (spec/store §5.4 step 10, 14.2: `same` is not persisted), so
+    // the counts come from the in-memory result, not the table. Kinds in
+    // bytewise order, as the table query listed them through 14.1.
+    const counts = new Map();
+    for (const d of prepared.result.dispositions)
+        counts.set(d.kind, (counts.get(d.kind) ?? 0) + 1);
+    const rows = [...counts].map(([kind, n]) => ({ kind, n })).sort((a, b) => (a.kind < b.kind ? -1 : a.kind > b.kind ? 1 : 0));
     return {
         docId: res.docId,
         path,

package/package.json

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