@omgbase/core 0.19.0 → 0.23.0

package/dist/src/mutate/effects.js

@@ -8,6 +8,7 @@ import { canonicalDocPath, composeFile, parseNewDoc, planInboundRetarget, splitF
 import { linksRepair, nodeSet } from "./macros.js";
 import { planUpdate } from "./plan-update.js";
 import { MutationError, rawHashHex, renderDoc } from "./tree.js";
+import { fixRequest, withMember } from "./canonical.js";
 export const EFFECT_OPS = ["create", "insert", "set", "unset", "move", "remove", "split", "merge", "retarget"];
 /** `$new.<n>`: an identity an earlier effect of the same request creates (§11.1). */
 export const NEW_SYMBOL_RE = /^\$new\.(0|[1-9][0-9]*)$/;
@@ -18,10 +19,86 @@ export function isNewSymbol(s) {
 function isRecord(v) {
     return typeof v === "object" && v !== null && !Array.isArray(v);
 }
-/** The argument-shape error of the surface, thrown from the planner: `filter_invalid { reason, hint: "arguments" }`. */
-export function effectInvalid(message) {
-    return new MutationError("filter_invalid", message, { reason: message, hint: "arguments" });
+/** The argument-shape error of the surface, thrown from the planner: `filter_invalid { reason, hint: "arguments" }` — with a `fix` (3.4, §8) when the shape check can spell the corrected call. */
+export function effectInvalid(message, fix) {
+    return new MutationError("filter_invalid", message, { reason: message, hint: "arguments", ...(fix !== undefined ? { fix } : {}) });
 }
+function fixerFor(ctx, i, v) {
+    if (ctx === undefined)
+        return undefined;
+    const list = Array.isArray(ctx.request.effects) ? ctx.request.effects : undefined;
+    const written = list !== undefined && isRecord(list[i]) ? list[i] : v;
+    return {
+        written,
+        build: (effect, expect) => fixRequest({
+            ...ctx.request,
+            effects: withMember(ctx.request.effects, [String(i)], effect),
+            ...(expect !== undefined ? { expect: expect.value } : {}),
+        }),
+        parentOf: ctx.parentOf,
+        request: ctx.request,
+    };
+}
+/** A record whose every value is a string. */
+function isStringRecord(v) {
+    return isRecord(v) && Object.values(v).every((x) => typeof x === "string");
+}
+/**
+ * §8 (3.4): an effect-level `expect.max` — the bound belongs to the request's
+ * top-level `expect`, beside `select`. The fix drops it from the effect (the
+ * rest of that `expect` stays; an emptied `expect` goes) and, when the request
+ * has a `select`, moves it to the top level unless a top-level `expect.max` is
+ * already there (then the top-level one is kept as written); without a
+ * `select` a top-level `expect` would itself be refused, so the fix only drops it.
+ */
+function effectLevelMax(v, here, f) {
+    const message = `${here}: \`expect.max\` bounds a selection — it is the request's top-level \`expect\`, beside \`select\`, not an effect's`;
+    if (f === undefined)
+        return effectInvalid(message);
+    const { max, ...rest } = v;
+    const effect = { ...f.written, expect: Object.keys(rest).length > 0 ? rest : undefined };
+    if (f.request.select === undefined)
+        return effectInvalid(message, f.build(effect));
+    const top = isRecord(f.request.expect) ? f.request.expect : {};
+    return effectInvalid(message, f.build(effect, { value: "max" in top ? top : { ...top, max } }));
+}
+/**
+ * §8 (3.4): `at` given as the bare string `"after"` / `"before"` with a block
+ * `into` — "right after block X" is `into: X's parent, at: { after: X }`. The
+ * fix needs the block's live row (its parent, or its document when it is top-
+ * level, spelled as the rooted path); a block the store does not know gets no fix.
+ */
+function bareAnchor(at, into, here, f) {
+    const message = `${here}: \`at\` must be "start", "end", { before: <block id> } or { after: <block id> } — "${at} block X" is into: X's parent (a block, or the document when X is top-level), at: { ${at}: X }`;
+    if (f === undefined || into.kind !== "block")
+        return effectInvalid(message);
+    const row = f.parentOf(into.id);
+    if (row === null)
+        return effectInvalid(message);
+    const parent = row.parent === null ? referencePath(row.path) : { kind: "block", id: row.parent };
+    return effectInvalid(message, f.build({ ...f.written, into: parent, at: { [at]: into.id } }));
+}
+/**
+ * §8 (3.4): a plural-target `expect` written as `{ content_hash: { <id>: <hash>, … } }`
+ * (every key a guard name, every value a map of strings) — the fix inverts the
+ * nesting to `{ <id>: { content_hash: <hash> }, … }`.
+ */
+function invertedExpectMap(v, here, f) {
+    const keys = Object.keys(v);
+    if (keys.length === 0 || !keys.every((k) => k === "content_hash" || k === "parent_children_hash") || !Object.values(v).every(isStringRecord))
+        return null;
+    const message = `${here}: a plural-target \`expect\` is keyed by block id — { <block id>: { content_hash?, parent_children_hash? }, … }`;
+    if (f === undefined)
+        return effectInvalid(message);
+    const inverted = {};
+    for (const [guard, byId] of Object.entries(v)) {
+        for (const [id, hash] of Object.entries(byId))
+            inverted[id] = { ...inverted[id], [guard]: hash };
+    }
+    return effectInvalid(message, f.build({ ...f.written, expect: inverted }));
+}
+/** §8 (3.4): the block-field misspellings the fix corrects to `markdown`. */
+const BLOCK_FIELD_ALIASES = new Set(["text", "content", "body", "raw"]);
 function onlyKeys(e, allowed, here) {
     const extra = Object.keys(e).filter((k) => !allowed.includes(k));
     if (extra.length > 0)
@@ -118,7 +195,7 @@ function validateTargets(v, here) {
         throw effectInvalid(`${here}: \`targets\` must be a non-empty array of block targets`);
     return v.map((t, i) => validateTarget(t, `${here}.targets[${i}]`, ["block"]));
 }
-function validateAt(v, here) {
+function validateAt(v, here, into, f) {
     if (v === undefined)
         return undefined;
     if (v === "start" || v === "end")
@@ -129,13 +206,17 @@ function validateAt(v, here) {
         if (typeof v.after === "string")
             return { after: v.after };
     }
+    if ((v === "before" || v === "after") && into !== undefined)
+        throw bareAnchor(v, into, here, f);
     throw effectInvalid(`${here}: \`at\` must be "start", "end", { before: <block id> } or { after: <block id> }`);
 }
-function validateExpect(v, here) {
+function validateExpect(v, here, f) {
     if (v === undefined)
         return undefined;
     if (!isRecord(v))
         throw effectInvalid(`${here}: \`expect\` must be an object`);
+    if ("max" in v)
+        throw effectLevelMax(v, here, f);
     onlyKeys(v, ["content_hash", "parent_children_hash", "revision"], `${here}.expect`);
     const out = {};
     for (const k of ["content_hash", "parent_children_hash", "revision"]) {
@@ -145,11 +226,16 @@ function validateExpect(v, here) {
     }
     return out;
 }
-function validateExpectMap(v, here) {
+function validateExpectMap(v, here, f) {
     if (v === undefined)
         return undefined;
     if (!isRecord(v))
         throw effectInvalid(`${here}: \`expect\` must be an object keyed by block id`);
+    if ("max" in v)
+        throw effectLevelMax(v, here, f);
+    const inverted = invertedExpectMap(v, here, f);
+    if (inverted !== null)
+        throw inverted;
     const out = {};
     for (const [id, x] of Object.entries(v)) {
         if (!isRecord(x))
@@ -166,13 +252,14 @@ function validateExpectMap(v, here) {
     }
     return out;
 }
-/** The shape check of one effect (§11.1). `i` names it in the message (`effects[i]`). */
-export function validateEffect(v, i) {
+/** The shape check of one effect (§11.1). `i` names it in the message (`effects[i]`); `fix` (3.4) lets the shape errors of §8 carry their corrected call. */
+export function validateEffect(v, i, fix) {
     const here = `effects[${i}]`;
     if (!isRecord(v) || typeof v.op !== "string")
         throw effectInvalid(`${here}: an effect is an object whose \`op\` is one of ${EFFECT_OPS.join("/")}`);
     if (!EFFECT_OPS.includes(v.op))
         throw effectInvalid(`${here}: \`op\` must be one of ${EFFECT_OPS.join("/")} (got "${v.op}")`);
+    const f = fixerFor(fix, i, v);
     switch (v.op) {
         case "create": {
             onlyKeys(v, ["op", "path", "markdown", "frontmatter"], here);
@@ -185,9 +272,9 @@ export function validateEffect(v, i) {
         case "insert": {
             onlyKeys(v, ["op", "into", "at", "markdown", "expect"], here);
             const into = validateTarget(v.into, `${here}.into`, ["document", "section", "block"]);
-            const at = validateAt(v.at, here);
+            const at = validateAt(v.at, here, into, f);
             const markdown = requireString(v, "markdown", here);
-            const expect = validateExpect(v.expect, here);
+            const expect = validateExpect(v.expect, here, f);
             return { op: "insert", into, ...(at !== undefined ? { at } : {}), markdown, ...(expect !== undefined ? { expect } : {}) };
         }
         case "set": {
@@ -197,8 +284,8 @@ export function validateEffect(v, i) {
             if (!("value" in v))
                 throw effectInvalid(`${here}: \`value\` is required`);
             if (target.kind !== "symbol")
-                checkField(target.kind, field, here, "set");
-            const expect = validateExpect(v.expect, here);
+                checkField(target.kind, field, here, "set", f);
+            const expect = validateExpect(v.expect, here, f);
             return { op: "set", target, field, value: v.value, ...(expect !== undefined ? { expect } : {}) };
         }
         case "unset": {
@@ -207,7 +294,7 @@ export function validateEffect(v, i) {
             const field = requireString(v, "field", here);
             if (target.kind !== "symbol")
                 checkField(target.kind, field, here, "unset");
-            const expect = validateExpect(v.expect, here);
+            const expect = validateExpect(v.expect, here, f);
             return { op: "unset", target, field, ...(expect !== undefined ? { expect } : {}) };
         }
         case "move": {
@@ -215,8 +302,8 @@ export function validateEffect(v, i) {
                 onlyKeys(v, ["op", "targets", "into", "at", "expect"], here);
                 const targets = validateTargets(v.targets, here);
                 const into = validateTarget(v.into, `${here}.into`, ["document", "section", "block"]);
-                const at = validateAt(v.at, here);
-                const expect = validateExpect(v.expect, here);
+                const at = validateAt(v.at, here, into, f);
+                const expect = validateExpect(v.expect, here, f);
                 return { op: "move", targets, into, ...(at !== undefined ? { at } : {}), ...(expect !== undefined ? { expect } : {}) };
             }
             onlyKeys(v, ["op", "target", "to", "retarget_inbound"], here);
@@ -230,7 +317,7 @@ export function validateEffect(v, i) {
             if ("targets" in v) {
                 onlyKeys(v, ["op", "targets", "expect"], here);
                 const targets = validateTargets(v.targets, here);
-                const expect = validateExpectMap(v.expect, here);
+                const expect = validateExpectMap(v.expect, here, f);
                 return { op: "remove", targets, ...(expect !== undefined ? { expect } : {}) };
             }
             onlyKeys(v, ["op", "target"], here);
@@ -241,14 +328,14 @@ export function validateEffect(v, i) {
             const target = validateTarget(v.target, `${here}.target`, ["block"]);
             if (!Array.isArray(v.at) || v.at.some((n) => typeof n !== "number" || !Number.isInteger(n) || n < 0))
                 throw effectInvalid(`${here}: \`at\` must be an array of byte offsets`);
-            const expect = validateExpect(v.expect, here);
+            const expect = validateExpect(v.expect, here, f);
             return { op: "split", target, at: v.at, ...(expect !== undefined ? { expect } : {}) };
         }
         case "merge": {
             onlyKeys(v, ["op", "targets", "separator", "expect"], here);
             const targets = validateTargets(v.targets, here);
             const separator = optionalString(v, "separator", here);
-            const expect = validateExpectMap(v.expect, here);
+            const expect = validateExpectMap(v.expect, here, f);
             return { op: "merge", targets, ...(separator !== undefined ? { separator } : {}), ...(expect !== undefined ? { expect } : {}) };
         }
         case "retarget": {
@@ -267,16 +354,16 @@ export function validateEffect(v, i) {
     }
 }
 /** The whole list; a non-array or an empty list is a shape error too. */
-export function validateEffects(v) {
+export function validateEffects(v, fix) {
     if (!Array.isArray(v))
         throw effectInvalid("`effects` must be an array of effects");
     if (v.length === 0)
         throw effectInvalid("`effects` must name at least one effect");
-    return v.map((e, i) => validateEffect(e, i));
+    return v.map((e, i) => validateEffect(e, i, fix));
 }
 // §11.2: the `field` spellings per target kind.
 export const FRONTMATTER_FIELD = /^frontmatter\.(.+)$/;
-function checkField(kind, field, here, op) {
+function checkField(kind, field, here, op, f) {
     if (kind === "document") {
         if (FRONTMATTER_FIELD.test(field) || (op === "set" && field === "content"))
             return;
@@ -285,7 +372,9 @@ function checkField(kind, field, here, op) {
     if (kind === "block") {
         if (field === "markdown" || field === "attrs.checked")
             return;
-        throw effectInvalid(`${here}: a block's \`field\` is \`markdown\` or \`attrs.checked\` (got "${field}")`);
+        // (3.4, §8) `text` / `content` / `body` / `raw` on a block: the fix spells `markdown`.
+        const fix = f !== undefined && BLOCK_FIELD_ALIASES.has(field) ? f.build({ ...f.written, field: "markdown" }) : undefined;
+        throw effectInvalid(`${here}: a block's \`field\` is \`markdown\` or \`attrs.checked\` (got "${field}")`, fix);
     }
     // node: the adapter's editable props (`node_not_editable` names them when unknown)
     if (field === "" || field.includes("."))

package/dist/src/mutate/known-ids.d.ts

@@ -1,4 +1,5 @@
 import type { Store } from "../core/store/store.js";
+import type { TreeInputBlock } from "../core/store/writers.js";
 import type { IdResolver } from "../core/ingest.js";
 import type { MutDoc } from "./tree.js";
 /**
@@ -10,3 +11,21 @@ import type { MutDoc } from "./tree.js";
 export declare function makeKnownIdResolver(store: Store, repoId: string, doc: MutDoc, priorIds: Set<string>, opts?: {
     path?: string;
 }): IdResolver;
+/** A carried block's live row, as spec/reconcile §2's carry classification reads it. */
+interface PriorRow {
+    parent: string | null;
+    ordinal: number;
+    rawHashHex: string;
+}
+/**
+ * spec/reconcile §2 "Classifying a carry", applied to the api path's known ids:
+ * `moved` = the parent or the sibling index differs from the live row,
+ * `content_equal` = the raw bytes hash the same; `same` / `moved` / `edited` /
+ * `edited_moved` follow. An id with no prior row (new to this document — a
+ * mint or a cross-document arrival) is `inserted`. Pre-order over the tree.
+ */
+export declare function classifyCarries(blocks: TreeInputBlock[], prior: Map<string, PriorRow>, priorIds: Set<string>): {
+    id: string;
+    kind: string;
+}[];
+export {};

package/dist/src/mutate/known-ids.js

@@ -1,4 +1,5 @@
 import { mintId } from "../core/ids.js";
+import { sha256 } from "../core/hash.js";
 import { extractFromBlock, extractFromFrontmatter, resolveRelativePath } from "../graph/extract.js";
 import { resolveExternal, resolveDocPath } from "../core/store/edges.js";
 import { adapterForPath } from "../format/index.js";
@@ -79,12 +80,19 @@ export function makeKnownIdResolver(store, repoId, doc, priorIds, opts = {}) {
         const assigned = assignFromMut(rest, byKey);
         const nowIds = collectIds(assigned);
         const nowSet = new Set(nowIds);
-        // Dispositions are INTENT, not inference: a carried id that existed before is
-        // `same`/`edited` (confidence 1.0); an id new this commit is `inserted`; a
-        // prior id no longer present is `deleted`.
-        const dispositions = nowIds.map((id) => ({
-            blockId: id,
-            kind: priorIds.has(id) ? "edited" : "inserted",
+        // Dispositions are INTENT, not inference (confidence 1.0, reason `api`): an
+        // id new this commit is `inserted`; a prior id no longer present is
+        // `deleted` (pooled, no row); a carried id is classified exactly as
+        // spec/reconcile §2 classifies a carry — `same` when its raw bytes, parent
+        // and sibling index are those of its live row, else `edited` / `moved` /
+        // `edited_moved` — so a block the changeset did not touch is `same` and
+        // (spec/store §5.4 step 10, 14.2) never persisted: a one-paragraph edit
+        // moves that paragraph's `updated_at`, not its siblings'. Through store
+        // 14.1 every carried block was stamped `edited`.
+        const prior = docId === null ? new Map() : priorRows(db, docId);
+        const dispositions = classifyCarries(assigned, prior, priorIds).map((c) => ({
+            blockId: c.id,
+            kind: c.kind,
             confidence: 1,
             reason: "api",
             matcherV: null,
@@ -121,10 +129,42 @@ export function makeKnownIdResolver(store, repoId, doc, priorIds, opts = {}) {
             }
             return out;
         };
-        void docId;
         return { assigned, dispositions, deleted, crossDocIds, extractEdges };
     };
 }
+function priorRows(db, docId) {
+    const rows = db
+        .prepare("SELECT block_id, parent_block, ordinal, raw_hash FROM blocks WHERE doc_id = ? AND deleted_commit IS NULL")
+        .all(docId);
+    return new Map(rows.map((r) => [r.block_id, { parent: r.parent_block, ordinal: r.ordinal, rawHashHex: r.raw_hash.toString("hex") }]));
+}
+/**
+ * spec/reconcile §2 "Classifying a carry", applied to the api path's known ids:
+ * `moved` = the parent or the sibling index differs from the live row,
+ * `content_equal` = the raw bytes hash the same; `same` / `moved` / `edited` /
+ * `edited_moved` follow. An id with no prior row (new to this document — a
+ * mint or a cross-document arrival) is `inserted`. Pre-order over the tree.
+ */
+export function classifyCarries(blocks, prior, priorIds) {
+    const out = [];
+    const walk = (list, parent) => {
+        list.forEach((b, index) => {
+            const row = priorIds.has(b.blockId) ? prior.get(b.blockId) : undefined;
+            if (!row) {
+                out.push({ id: b.blockId, kind: "inserted" });
+            }
+            else {
+                const moved = row.parent !== parent || row.ordinal !== index;
+                const contentEqual = row.rawHashHex === sha256(b.raw).toString("hex");
+                out.push({ id: b.blockId, kind: contentEqual ? (moved ? "moved" : "same") : moved ? "edited_moved" : "edited" });
+            }
+            if (b.children.length > 0)
+                walk(b.children, b.blockId);
+        });
+    };
+    walk(blocks, null);
+    return out;
+}
 // Edge resolution — mirrors reconciling-ingest's resolvers (block-anchor targets
 // resolve to the document node in v1; the anchor is preserved on the edge).
 function resolveEdge(db, repoId, srcDoc, e, docDir) {

package/dist/src/mutate/ops.d.ts

@@ -35,6 +35,7 @@ export declare function opRemove(doc: MutDoc, blockIds: string[], opIndex: numbe
 export declare function opSplit(doc: MutDoc, blockId: string, at: number[], opIndex: number, expect?: Expect): {
     ids: string[];
 };
+export declare function trimCutEdges(pieces: readonly string[]): string[];
 export declare function opMerge(doc: MutDoc, blockIds: string[], opIndex: number, separator?: string, expectPer?: Record<string, Expect>): {
     ids: string[];
     mergedInto: string[];

package/dist/src/mutate/ops.js

@@ -505,7 +505,7 @@ export function opSplit(doc, blockId, at, opIndex, expect) {
     const pieces = [];
     for (let i = 1; i < cuts.length; i++)
         pieces.push(raw.slice(cuts[i - 1], cuts[i]));
-    const nonEmpty = pieces.filter((p) => p.trim().length > 0);
+    const nonEmpty = trimCutEdges(pieces).filter((p) => p.trim().length > 0);
     if (nonEmpty.length < 2)
         throw new MutationError("type_mismatch", "split must yield ≥2 non-empty fragments");
     // First fragment carries the id (authored intent, 04 §1); rest minted.
@@ -533,6 +533,25 @@ export function opSplit(doc, blockId, at, opIndex, expect) {
     markContainerDirty(doc, found.siblings);
     return { ids: [blockId, ...newBlocks.map((b) => b.id)] };
 }
+// spec/mutate §2.5 (3.5): the pieces of a split are trimmed at the CUT edges
+// only — every piece but the last loses its trailing whitespace, every piece
+// but the first its leading whitespace — so an offset on either side of a
+// space (or inside the run, a `\n`, a hard break's `  \n`) yields the same
+// pieces and no piece ends in a stray space. The raw's own start and end are
+// not cut edges and stay as authored (a last piece keeps the raw's trailing
+// spaces). The whitespace set is the format's trim set (`spec/format` §4.1
+// step 4) — exactly what JavaScript's `trimStart`/`trimEnd` remove.
+export function trimCutEdges(pieces) {
+    const last = pieces.length - 1;
+    return pieces.map((p, i) => {
+        let out = p;
+        if (i < last)
+            out = out.trimEnd();
+        if (i > 0)
+            out = out.trimStart();
+        return out;
+    });
+}
 export function opMerge(doc, blockIds, opIndex, separator = " ", expectPer) {
     if (blockIds.length < 2)
         throw new MutationError("not_contiguous", "merge requires ≥2 blocks");

package/dist/src/mutate/select.d.ts

@@ -75,15 +75,4 @@ export declare function desugarEffect(raw: unknown, index: number, request?: Fix
 export declare function compileSelection(store: Store, repoId: string, select: unknown, expectRaw: unknown, templatesRaw: unknown): CompiledSelection;
 /** The query a selector request compiles to (admission + rewrite, before any row is read) — `print` it to see what runs. */
 export declare function selectionQuery(select: unknown, templates: unknown): Query;
-/**
- * Compile a plain `effects` list (no selector): desugar the `-> ` leaders,
- * then — when nothing is an expression — the shape check as before (3.0
- * byte-identical). Otherwise each effect with expressions is admitted as a
- * template over its own primary target's row: the effects are grouped by that
- * row's identity, one synthetic query per identity — `from <root> where id ==
- * "<id>"` with the slot items appended, named `__omg_sel_<effectIndex>_<slot>`
- * — runs, and the row binds the slots exactly as a selector's hit would. The
- * concrete effects feed the lowering unchanged; `templates` is the list as
- * written, for the intent record.
- */
 export declare function compilePlain(store: Store, repoId: string, raw: unknown): CompiledPlain;

package/dist/src/mutate/select.js

@@ -294,7 +294,7 @@ function containsOqx(v) {
  * defaults to a hit, and its primary target may not be an expression (the
  * primary target IS the row the expressions read).
  */
-function admitTemplate(raw, index, root, plain) {
+function admitTemplate(raw, index, root, plain, fix) {
     const here = `effects[${index}]`;
     if (!isRecord(raw) || typeof raw.op !== "string")
         throw selectionInvalid(`${here}: a template is an effect object whose \`op\` is one of ${EFFECT_OPS.filter((o) => o !== "retarget").join("/")}`);
@@ -501,8 +501,8 @@ function admitTemplate(raw, index, root, plain) {
         if (containsOqx(raw[key]))
             throw selectionInvalid(`${here}.${key}: \`{ oqx }\` is not allowed here`);
     }
-    // The shape, with a probe in every slot (the §11.1 messages, naming `effects[i]`).
-    validateEffect(probe, index);
+    // The shape, with a probe in every slot (the §11.1 messages, naming `effects[i]`; the §8 shape fixes rewrite the template as written).
+    validateEffect(probe, index, fix);
     return { index, base, slots, defaultTarget };
 }
 /** The `id`/`path` member a bound identity value supplies: a string as given, a row ref by its id. */
@@ -527,7 +527,7 @@ function validateExpect(v) {
 /**
  * The fix of a refused selector source (3.3): the same request over an
  * admitted root — `links` becomes `blocks` (a link lives in a block), any other
- * source `docs` — spliced over the source's span of the written query.
+ * source (`revisions` included) `docs` — spliced over the source's span of the written query.
  */
 function rootFix(select, source, request) {
     if (request === undefined)
@@ -560,6 +560,9 @@ function admitSelector(select, request) {
     if (raw.values)
         throw selectionInvalid("select: a selector yields rows, not `values`");
     const root = rootTarget(raw.source);
+    if (root === null && raw.source.kind === "ident" && raw.source.name === "revisions") {
+        throw selectionInvalid("select: `revisions` rows have no effect target — select docs, blocks or nodes", rootFix(select, raw.source, request));
+    }
     if (root === null)
         throw selectionInvalid("select: a selector scans a root collection — `from docs`, `from blocks` or `from nodes`", rootFix(select, raw.source, request));
     if (root === "links")
@@ -583,6 +586,10 @@ function runQuery(store, repoId, q, limit) {
     catch (e) {
         if (e instanceof OqxError)
             throw new FilterInvalid(e.message, "OQX");
+        // An unknown name (spec/surface §1.5) is refused before any row is read; a
+        // selector's refusal wears the admission prefix and hint like every other.
+        if (e instanceof FilterInvalid)
+            throw selectionInvalid(`select: ${e.message}`);
         throw e;
     }
 }
@@ -639,7 +646,9 @@ function admitRequest(select, templatesRaw, request) {
     if (templatesRaw.length === 0)
         throw selectionInvalid("`effects` must name at least one template");
     const { raw, root } = admitSelector(select, request);
-    const templates = templatesRaw.map((t, i) => admitTemplate(desugarEffect(t, i, request), i, root, false));
+    // Under a selector a template's `into` is bound per hit, so the anchor fix (a parent lookup) does not apply: `parentOf` finds nothing.
+    const fix = request === undefined ? undefined : { request, parentOf: () => null };
+    const templates = templatesRaw.map((t, i) => admitTemplate(desugarEffect(t, i, request), i, root, false, fix));
     // The rewrite: the slot items, named `__omg_sel_<t>_<slot>`, appended after
     // the user's items on the raw tree (so a user alias resolves into them).
     const items = [];
@@ -826,28 +835,43 @@ function scopeOf(store, repoId, e, i) {
  * concrete effects feed the lowering unchanged; `templates` is the list as
  * written, for the intent record.
  */
+/**
+ * The live-row lookup behind the anchor fix (§8, 3.4): a block's parent id
+ * (`null` at the top level) and its document's path, from the `blocks` row
+ * that is not deleted; `null` for an id the store does not know (a `$new.n`,
+ * a typo) — then there is no fix.
+ */
+function parentLookup(store) {
+    return (id) => {
+        const row = store.db
+            .prepare("SELECT b.parent_block AS parent, d.path AS path FROM blocks b JOIN docs d ON d.doc_id = b.doc_id WHERE b.block_id = ? AND b.deleted_commit IS NULL")
+            .get(id);
+        return row === undefined ? null : { parent: row.parent, path: row.path };
+    };
+}
 export function compilePlain(store, repoId, raw) {
     if (!Array.isArray(raw))
         throw effectInvalid("`effects` must be an array of effects");
     if (raw.length === 0)
         throw effectInvalid("`effects` must name at least one effect");
     const request = { effects: raw };
+    const fix = { request, parentOf: parentLookup(store) };
     const desugared = raw.map((e, i) => desugarEffect(e, i, request));
     if (!desugared.some(containsOqx))
-        return { effects: desugared.map((e, i) => validateEffect(e, i)), origins: [] };
+        return { effects: desugared.map((e, i) => validateEffect(e, i, fix)), origins: [] };
     const effects = [];
     const origins = [];
     const scopes = new Map();
     desugared.forEach((e, i) => {
         if (!containsOqx(e) || !isRecord(e)) {
-            effects[i] = validateEffect(e, i);
+            effects[i] = validateEffect(e, i, fix);
             return;
         }
         const scope = scopeOf(store, repoId, e, i);
-        const t = admitTemplate(e, i, scope.root, true);
+        const t = admitTemplate(e, i, scope.root, true, fix);
         if (t.slots.length === 0) {
             // `{ oqx }` only inside data (a nested `value`): literal, as for a template.
-            effects[i] = validateEffect(e, i);
+            effects[i] = validateEffect(e, i, fix);
             return;
         }
         const key = `${scope.root}:${scope.id}`;

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

@@ -1,11 +1,18 @@
 import type { DataContext } from "@omgbase/oqx";
+import { type Root } from "./root-row.js";
 import type { Store } from "../core/store/store.js";
 import type { SemanticVec } from "../search/cel/compile.js";
 export type Target = "docs" | "blocks" | "nodes" | "links";
+/** Every row kind the context tags (spec/surface §1.1): the four targets and
+ * `revisions` (4.7) — the history target, whose rows are the `revisions` ×
+ * `commits` join. `Target` stays the four kinds the unknown-names pass judges
+ * (names.ts keys its tables by it); everything that tags, scans or renders a
+ * row is keyed by `Kind`. */
+export type Kind = Root;
 declare const TARGET: unique symbol;
 /** The engine attributes per kind (spec/surface §1.2 table). Exported so the
  * translator's tests pin the two against each other. */
-export declare const ATTRIBUTES: Readonly<Record<Target, ReadonlySet<string>>>;
+export declare const ATTRIBUTES: Readonly<Record<Kind, ReadonlySet<string>>>;
 /** The source handles of a document (§1.2): `data` is the merged authored view
  * (frontmatter + inline), the other two one source each. */
 export declare const SOURCE_HANDLES: ReadonlySet<string>;
@@ -31,7 +38,7 @@ export interface StoreContextOptions {
 export declare function makeStoreContext(store: Store, repoId: string, opts?: StoreContextOptions): DataContext;
 /** Tag SQL rows with their target so the store context resolves them (used by the
  * tier-3 planner to hand produced rows back for residual evaluation). */
-export declare function tagRows(rows: Record<string, unknown>[], target: Target): unknown[];
+export declare function tagRows(rows: Record<string, unknown>[], target: Kind): unknown[];
 /**
  * A store row surfacing as a VALUE in a result (spec/surface §1.4, rows as
  * values, 1.2) is rendered as `{ id, path }` (3.0) — its id column and its