@omgbase/core 0.27.1 → 0.29.0

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

@@ -10,16 +10,16 @@ export type OpsetKind = "doc_update";
 export type PlanDisposition = "same" | "edited" | "moved" | "edited_moved" | "inserted" | "deleted" | "split_from" | "merged_into" | "copied_from" | "resurrected" | "bulk_rewrite" | "retiled";
 /** State the opset was planned against; applying against different state
  *  fails. The document is named by its row attributes (spec/surface §1.2,
- *  3.0): `id`, `path`, and `hash` — its current hash at plan time;
+ *  5.0 "underscore = engine"): `_id`, `_path`, and `_hash` — its current hash at plan time;
  *  `baseRevision` names a role and keeps its name. */
 export interface OpsetPrecondition {
     /** doc id the plan targets */
-    id: string;
-    path: string;
+    _id: string;
+    _path: string;
     /** the document's current revision id at plan time (null for a doc with no committed revision yet) */
     baseRevision: string | null;
-    /** sha256 hex of the document's current rendered bytes (docs.file_hash) at plan time — its `hash` */
-    hash: string;
+    /** sha256 hex of the document's current rendered bytes (docs.file_hash) at plan time — its `_hash` */
+    _hash: string;
 }
 /** One kernel op plus the identity consequence the planner attributes to it. */
 export interface PlanOp {
@@ -54,8 +54,8 @@ export interface Opset {
     version: 1;
     kind: OpsetKind;
     target: {
-        id: string;
-        path: string;
+        _id: string;
+        _path: string;
     };
     precondition: OpsetPrecondition;
     /** matcher version that produced the identity decisions (reproducibility) */

package/dist/src/mutate/plan-update.js

@@ -86,8 +86,8 @@ export function planUpdate(store, repoId, rootPath, docRef, content, opts = {})
     return {
         version: 1,
         kind: "doc_update",
-        target: { id: docId, path: path },
-        precondition: { id: docId, path: path, baseRevision: info.currentRev, hash: baseContentHash },
+        target: { _id: docId, _path: path },
+        precondition: { _id: docId, _path: path, baseRevision: info.currentRev, _hash: baseContentHash },
         matcherV: config.matcherV,
         ops,
         ...(fmChanged ? { frontmatter: { raw: targetFm } } : {}),

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

@@ -24,18 +24,18 @@ export type WireOp = Exclude<Op, {
 };
 /** The lowered form `execute` replays (§11.4): every key present, `[]` when empty. */
 export interface PlanOpset {
-    /** `create` → the composed file, its document symbol and the index of the first kernel op planned after it (3.0; a later `set frontmatter.<k>` on the symbol is a head below) */
+    /** `create` → the composed file, its document symbol and the index of the first kernel op planned after it (3.0; a later `set _frontmatter.<k>` on the symbol is a head below) */
     creates: CreateEntry[];
     /** `move document` → the row/file rename (its retarget updates are in `ops`) */
     moves: {
-        id: string;
+        _id: string;
         from: string;
         to: string;
     }[];
     /** `remove document` */
     tombstones: {
-        id: string;
-        path: string;
+        _id: string;
+        _path: string;
     }[];
     /** per document, the file head — everything before the first block (frontmatter incl. fences and separator) */
     set_frontmatter: {
@@ -48,14 +48,14 @@ export interface PlanOpset {
 export interface PlanPreconditions {
     /** the row triples (`spec/mutate` §4 step 5) of every document the plan touches, loaded ones first in load order */
     docs: {
-        id: string;
-        path: string;
+        _id: string;
+        _path: string;
         base_revision: string | null;
-        hash: string | null;
+        _hash: string | null;
     }[];
     /** every block content hash the plan pins (caller-given or pinned from the live row), first-pin order */
     blocks: {
-        id: string;
+        _id: string;
         content_hash: string;
     }[];
     /** the caller's destination-parent CAS pins */

package/dist/src/mutate/plan.js

@@ -116,19 +116,19 @@ export function planEffects(store, req) {
         const changeset = planner.finish();
         const opset = {
             creates: ctx.creates,
-            moves: ctx.moves.map((m) => ({ id: m.id, from: m.from, to: m.to })),
-            tombstones: ctx.tombstones.map((t) => ({ id: t.id, path: t.path })),
+            moves: ctx.moves.map((m) => ({ _id: m.id, from: m.from, to: m.to })),
+            tombstones: ctx.tombstones.map((t) => ({ _id: t.id, _path: t.path })),
             set_frontmatter: [...ctx.heads].map(([doc, raw]) => ({ doc, raw })),
             ops: ctx.ops.map(wireOp),
         };
-        const docs = changeset.preconditions.map((p) => ({ id: p.id, path: p.path, base_revision: p.currentRev, hash: p.fileHash }));
+        const docs = changeset.preconditions.map((p) => ({ _id: p.id, _path: p.path, base_revision: p.currentRev, _hash: p.fileHash }));
         for (const [id, base] of ctx.docBases) {
-            if (!docs.some((d) => d.id === id))
-                docs.push({ id, path: base.path, base_revision: base.currentRev, hash: base.fileHash });
+            if (!docs.some((d) => d._id === id))
+                docs.push({ _id: id, _path: base.path, base_revision: base.currentRev, _hash: base.fileHash });
         }
         const preconditions = {
             docs,
-            blocks: [...ctx.pins].map(([id, content_hash]) => ({ id, content_hash })),
+            blocks: [...ctx.pins].map(([id, content_hash]) => ({ _id: id, content_hash })),
             parents: ctx.parents,
             absent_paths: ctx.absentPaths,
         };
@@ -151,9 +151,9 @@ export function planEffects(store, req) {
         for (const t of ctx.tombstones)
             diffs[t.path] = { before: docStore.read(t.path) ?? "", after: "" };
         for (const r of revisions) {
-            const moved = ctx.moves.find((m) => m.id === r.id);
+            const moved = ctx.moves.find((m) => m.id === r._id);
             if (moved)
-                r.path = moved.to;
+                r._path = moved.to;
         }
         const preview = { results: changeset.results, revisions, diffs, summary: ctx.summary };
         if (ctx.identity.size > 0)
@@ -171,7 +171,7 @@ function requestOf(req) {
 /**
  * `conflicting_effects`: keep the later effect — the request minus the earlier
  * one; under a selector, a cross-hit collision narrows the selector to the
- * later hit (`from <root> where id == …`, `expect.max: 1`) and a same-hit
+ * later hit (`from <root> where _id == …`, `expect.max: 1`) and a same-hit
  * collision drops the earlier template. `stale_plan` at plan time (an
  * `expect.revision` that no longer holds): the same request with the current
  * revision in that guard. `target_missing { symbol }` for a `$new.n` no earlier
@@ -191,8 +191,8 @@ function planningFix(err, i, req, origins, symbols) {
         const ob = origins[b];
         if (oa === undefined || ob === undefined || oa.template_index === undefined)
             return undefined;
-        if (oa.row.id !== ob.row.id)
-            return fixRequest({ select: narrowedTo(rootOfId(ob.row.id), ob.row.id), effects, expect: { max: 1 } });
+        if (oa.row._id !== ob.row._id)
+            return fixRequest({ select: narrowedTo(rootOfId(ob.row._id), ob.row._id), effects, expect: { max: 1 } });
         return fixRequest({ ...requestOf(req), effects: effects.filter((_, k) => k !== oa.template_index) });
     }
     if (err.code === "stale_plan" && isRecord(err.data.current) && typeof err.data.current.revision === "string") {
@@ -386,14 +386,14 @@ function underLock(req, fn) {
  */
 function executeAdmitted(store, req, plan, docStore) {
     for (const d of plan.preconditions.docs) {
-        const row = readDocBase(store.db, d.id);
+        const row = readDocBase(store.db, d._id);
         if (!row)
-            throw new MutationError("doc_missing", `doc ${d.id} no longer exists`, { doc: d.id });
-        if (row.path !== d.path || row.currentRev !== d.base_revision || row.fileHash !== d.hash) {
-            throw new MutationError("stale_plan", `document ${d.id} changed since the plan was made; re-plan`, {
-                doc: d.id,
+            throw new MutationError("doc_missing", `doc ${d._id} no longer exists`, { doc: d._id });
+        if (row.path !== d._path || row.currentRev !== d.base_revision || row.fileHash !== d._hash) {
+            throw new MutationError("stale_plan", `document ${d._id} changed since the plan was made; re-plan`, {
+                doc: d._id,
                 expected_revision: d.base_revision,
-                current: { revision: row.currentRev, hash: row.fileHash },
+                current: { revision: row.currentRev, _hash: row.fileHash },
                 retriable: true,
                 fix: replanFix(plan),
             });
@@ -418,7 +418,7 @@ function executeAdmitted(store, req, plan, docStore) {
         }),
     };
     const stat = req.omgbaseDir !== undefined;
-    const moved = new Map(plan.opset.moves.map((m) => [m.id, m]));
+    const moved = new Map(plan.opset.moves.map((m) => [m._id, m]));
     const blockSymbols = plan.new_ids.filter((s) => s.kind === "block").map((s) => s.symbol);
     const planner = new ChangesetPlanner(store, req.repoId, req.omgbaseDir);
     const { effects, outcome } = observeMints((prefix, id) => {
@@ -459,8 +459,8 @@ function executeAdmitted(store, req, plan, docStore) {
         const effects = [];
         for (const m of plan.opset.moves) {
             const bytes = docStore.read(m.from) ?? "";
-            const rev = readDocBase(store.db, m.id)?.currentRev ?? null;
-            effects.push({ kind: "move_path", docId: m.id, from: m.from, to: m.to, currentRev: rev, inbound: inboundLinksTo(store, req.repoId, m.id, m.from), bytes });
+            const rev = readDocBase(store.db, m._id)?.currentRev ?? null;
+            effects.push({ kind: "move_path", docId: m._id, from: m.from, to: m.to, currentRev: rev, inbound: inboundLinksTo(store, req.repoId, m._id, m.from), bytes });
             if (stat)
                 effects.push({ kind: "clear_stat", path: m.from }, { kind: "record_stat", path: m.to, bytes });
         }
@@ -477,10 +477,10 @@ function executeAdmitted(store, req, plan, docStore) {
                 effects.push(e);
         }
         for (const t of plan.opset.tombstones) {
-            const rev = readDocBase(store.db, t.id)?.currentRev ?? null;
-            effects.push({ kind: "tombstone", docId: t.id, path: t.path, currentRev: rev, pool: false });
+            const rev = readDocBase(store.db, t._id)?.currentRev ?? null;
+            effects.push({ kind: "tombstone", docId: t._id, path: t._path, currentRev: rev, pool: false });
             if (stat)
-                effects.push({ kind: "clear_stat", path: t.path });
+                effects.push({ kind: "clear_stat", path: t._path });
         }
         const outcome = commitChangeset(store, req.repoId, head, effects, ts, { docStore, ...(req.omgbaseDir !== undefined ? { omgbaseDir: req.omgbaseDir } : {}) });
         return { effects, outcome };
@@ -491,9 +491,9 @@ function executeAdmitted(store, req, plan, docStore) {
     let j = 0;
     for (const e of effects) {
         if (e.kind === "ingest_reconciled")
-            revisions.push({ id: outcome.ingests[j++].docId, path: e.path, hash: sha256(e.source).toString("hex") });
+            revisions.push({ _id: outcome.ingests[j++].docId, _path: e.path, _hash: sha256(e.source).toString("hex") });
         else if (e.kind === "ingest_known")
-            revisions.push({ id: outcome.ingests[j++].docId, path: e.path, hash: sha256(e.rendered).toString("hex") });
+            revisions.push({ _id: outcome.ingests[j++].docId, _path: e.path, _hash: sha256(e.rendered).toString("hex") });
     }
     // `$new.n` → minted id: the i-th block symbol is the i-th `b` the replay
     // minted (all before the transaction, in the plan's order — the aliases

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

@@ -22,8 +22,8 @@ export interface Selection {
 export interface EffectOrigin {
     template_index?: number;
     row: {
-        id: string;
-        path: string;
+        _id: string;
+        _path: string;
     };
 }
 export interface CompiledSelection {
@@ -56,8 +56,8 @@ export declare function desugarLeader(v: string, here: string): unknown;
  * Desugar one effect or template as written (§11.8 "Sugar"), before the shape
  * check and the admission: in every slot that admits an expression — the
  * strings `markdown`, `to`, `path`, `separator`, `at.before` / `at.after`,
- * the JSON `value`, each top-level `create.frontmatter` value, a target's `id`
- * / `path`, and a whole target (`into`, `target`, `targets[k]`) — a string
+ * the JSON `value`, each top-level `create.frontmatter` value, a target's `_id`
+ * / `_path`, and a whole target (`into`, `target`, `targets[k]`) — a string
  * beginning `-> ` becomes `{ oqx }` (or folds to its literal); a `-> ` string
  * anywhere else (`expect`, `field`, `op`, a section's `heading_id`, …) is
  * refused. Every other string is literal data, with no escaping and no `${`

package/dist/src/mutate/select.js

@@ -42,9 +42,9 @@ function isRecord(v) {
 function isOqx(v) {
     return isRecord(v) && Object.keys(v).length === 1 && typeof v.oqx === "string";
 }
-/** A row rendered as a value by the runner (`{ id, path }` and nothing else, spec/surface §1.4). */
+/** A row rendered as a value by the runner (`{ _id, _path }` and nothing else, spec/surface §1.4). */
 function isRowRef(v) {
-    return isRecord(v) && Object.keys(v).length === 2 && typeof v.id === "string" && typeof v.path === "string";
+    return isRecord(v) && Object.keys(v).length === 2 && typeof v._id === "string" && typeof v._path === "string";
 }
 function describeValue(v) {
     if (v === null || v === undefined)
@@ -144,8 +144,8 @@ function refuseLeader(v, here, path, fix) {
  * Desugar one effect or template as written (§11.8 "Sugar"), before the shape
  * check and the admission: in every slot that admits an expression — the
  * strings `markdown`, `to`, `path`, `separator`, `at.before` / `at.after`,
- * the JSON `value`, each top-level `create.frontmatter` value, a target's `id`
- * / `path`, and a whole target (`into`, `target`, `targets[k]`) — a string
+ * the JSON `value`, each top-level `create.frontmatter` value, a target's `_id`
+ * / `_path`, and a whole target (`into`, `target`, `targets[k]`) — a string
  * beginning `-> ` becomes `{ oqx }` (or folds to its literal); a `-> ` string
  * anywhere else (`expect`, `field`, `op`, a section's `heading_id`, …) is
  * refused. Every other string is literal data, with no escaping and no `${`
@@ -174,11 +174,11 @@ export function desugarEffect(raw, index, request) {
         if (isLeader(t))
             out[key] = desugarLeader(t, `${here}.${key}`);
         else if (isRecord(t)) {
-            for (const member of ["id", "path"])
+            for (const member of ["_id", "_path"])
                 if (isLeader(t[member]))
                     t[member] = desugarLeader(t[member], `${here}.${key}.${member}`);
             for (const k of Object.keys(t))
-                if (k !== "id" && k !== "path")
+                if (k !== "_id" && k !== "_path")
                     refuse(t[k], `${here}.${key}.${k}`, [key, k]);
         }
     };
@@ -191,10 +191,10 @@ export function desugarEffect(raw, index, request) {
             if (isLeader(t))
                 list[k] = desugarLeader(t, `${here}.targets[${k}]`);
             else if (isRecord(t)) {
-                if (isLeader(t.id))
-                    t.id = desugarLeader(t.id, `${here}.targets[${k}].id`);
+                if (isLeader(t._id))
+                    t._id = desugarLeader(t._id, `${here}.targets[${k}]._id`);
                 for (const m of Object.keys(t))
-                    if (m !== "id")
+                    if (m !== "_id")
                         refuse(t[m], `${here}.targets[${k}].${m}`, ["targets", String(k), m]);
             }
         });
@@ -328,7 +328,7 @@ function admitTemplate(raw, index, root, plain, fix) {
         probe[key] = null;
         slots.push({ name: key, kind: "json", here: `${here}.${key}`, path: [key], expression: src, item: expr(src, key), put: (e, v) => { e[key] = v; } });
     };
-    // A target member: `{ kind, id: { oqx } }` or `{ kind: "document", path: { oqx } }`, or (3.2) the whole target
+    // A target member: `{ kind, _id: { oqx } }` or `{ kind: "document", _path: { oqx } }`, or (3.2) the whole target
     // `{ oqx }` — the identity the value names; absent → the hit when `defaultable` (never on a plain effect).
     // `probeKind` is a kind the slot admits, standing in for the whole-target expression's unknown kind.
     const targetSlot = (key, defaultable, probeKind, primary) => {
@@ -337,7 +337,7 @@ function admitTemplate(raw, index, root, plain, fix) {
         if (t === undefined) {
             if (!defaultable || plain)
                 return null;
-            probe[key] = { kind: HIT_KIND[root], id: "$sel" };
+            probe[key] = { kind: HIT_KIND[root], _id: "$sel" };
             return { key, list: false };
         }
         if (isOqx(t)) {
@@ -345,19 +345,19 @@ function admitTemplate(raw, index, root, plain, fix) {
                 throw needsSelector(`${here}.${key}`);
             const src = t.oqx;
             delete base[key];
-            probe[key] = { kind: probeKind, id: "$sel" };
+            probe[key] = { kind: probeKind, _id: "$sel" };
             slots.push({ name: key, kind: "target", here: `${here}.${key}`, path: [key], expression: src, item: expr(src, key), put: (e, v) => { e[key] = v; } });
             return null;
         }
         if (isRecord(t)) {
-            const idX = isOqx(t.id);
-            const pathX = isOqx(t.path);
+            const idX = isOqx(t._id);
+            const pathX = isOqx(t._path);
             if (idX && pathX)
-                throw selectionInvalid(`${here}.${key}: give \`id\` or \`path\` as an expression, not both`);
+                throw selectionInvalid(`${here}.${key}: give \`_id\` or \`_path\` as an expression, not both`);
             if (idX || pathX) {
                 if (plain && primary)
                     throw needsSelector(`${here}.${key}`);
-                const member = idX ? "id" : "path";
+                const member = idX ? "_id" : "_path";
                 const src = t[member].oqx;
                 const literal = { ...t };
                 delete literal[member];
@@ -369,12 +369,12 @@ function admitTemplate(raw, index, root, plain, fix) {
                 });
             }
             for (const k of Object.keys(t))
-                if (k !== "id" && k !== "path" && containsOqx(t[k]))
+                if (k !== "_id" && k !== "_path" && containsOqx(t[k]))
                     throw selectionInvalid(`${here}.${key}.${k}: \`{ oqx }\` is not allowed here`);
         }
         return null;
     };
-    // A `targets` list: each element `{ kind: "block", id: { oqx } }` (or, 3.2, a whole `{ oqx }`) yields one block;
+    // A `targets` list: each element `{ kind: "block", _id: { oqx } }` (or, 3.2, a whole `{ oqx }`) yields one block;
     // absent → `[the hit]` when `defaultable`. The list is always the primary target of its op.
     const targetsSlot = (defaultable) => {
         slotKeys.add("targets");
@@ -382,7 +382,7 @@ function admitTemplate(raw, index, root, plain, fix) {
         if (list === undefined) {
             if (!defaultable || plain)
                 return null;
-            probe.targets = [{ kind: HIT_KIND[root], id: "$sel" }];
+            probe.targets = [{ kind: HIT_KIND[root], _id: "$sel" }];
             return { key: "targets", list: true };
         }
         if (Array.isArray(list)) {
@@ -392,7 +392,7 @@ function admitTemplate(raw, index, root, plain, fix) {
                         throw needsSelector(`${here}.targets[${k}]`);
                     const src = t.oqx;
                     base.targets[k] = {};
-                    probe.targets[k] = { kind: "block", id: "$sel" };
+                    probe.targets[k] = { kind: "block", _id: "$sel" };
                     slots.push({
                         name: `targets_${k}`, kind: "target", here: `${here}.targets[${k}]`, path: ["targets", String(k)], expression: src, item: expr(src, `targets[${k}]`),
                         put: (e, v) => { e.targets[k] = v; },
@@ -401,23 +401,23 @@ function admitTemplate(raw, index, root, plain, fix) {
                 }
                 if (!isRecord(t))
                     return;
-                if (isOqx(t.path))
-                    throw selectionInvalid(`${here}.targets[${k}]: a block target has \`id\`, not \`path\``);
-                if (isOqx(t.id)) {
+                if (isOqx(t._path))
+                    throw selectionInvalid(`${here}.targets[${k}]: a block target has \`_id\`, not \`_path\``);
+                if (isOqx(t._id)) {
                     if (plain)
-                        throw needsSelector(`${here}.targets[${k}].id`);
-                    const src = t.id.oqx;
+                        throw needsSelector(`${here}.targets[${k}]._id`);
+                    const src = t._id.oqx;
                     const literal = { ...t };
-                    delete literal.id;
+                    delete literal._id;
                     base.targets[k] = literal;
-                    probe.targets[k].id = "$sel";
+                    probe.targets[k]._id = "$sel";
                     slots.push({
-                        name: `targets_${k}`, kind: "identity", here: `${here}.targets[${k}].id`, path: ["targets", String(k), "id"], expression: src, item: expr(src, `targets[${k}].id`),
-                        put: (e, v) => { const arr = e.targets; arr[k] = { ...arr[k], ...identityMember("id", v) }; },
+                        name: `targets_${k}`, kind: "identity", here: `${here}.targets[${k}]._id`, path: ["targets", String(k), "_id"], expression: src, item: expr(src, `targets[${k}]._id`),
+                        put: (e, v) => { const arr = e.targets; arr[k] = { ...arr[k], ...identityMember("_id", v) }; },
                     });
                 }
                 for (const key of Object.keys(t))
-                    if (key !== "id" && containsOqx(t[key]))
+                    if (key !== "_id" && containsOqx(t[key]))
                         throw selectionInvalid(`${here}.targets[${k}].${key}: \`{ oqx }\` is not allowed here`);
             });
         }
@@ -505,10 +505,10 @@ function admitTemplate(raw, index, root, plain, fix) {
     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. */
+/** The `_id`/`_path` member a bound identity value supplies: a string as given, a row ref by its id. */
 function identityMember(member, v) {
     if (isRowRef(v))
-        return { id: v.id };
+        return { _id: v._id };
     return { [member]: v };
 }
 // ---- the request ---------------------------------------------------------------------
@@ -624,7 +624,7 @@ export function compileSelection(store, repoId, select, expectRaw, templatesRaw)
     }
     // Row → effects: hits in result order × templates in order (k = h·T + t). A
     // selector with `flatten` (oqx 0.25; §11.8) fans out per FLATTENED row: each
-    // hit is the parent row (its `id`/`path`), the slot items read the bound name
+    // hit is the parent row (its `_id`/`_path`), the slot items read the bound name
     // (`-> tag`) in the flattened scope, and `expect.max` — the page bound above —
     // counts the flattened hits.
     const effects = [];
@@ -632,7 +632,7 @@ export function compileSelection(store, repoId, select, expectRaw, templatesRaw)
     hits.forEach((hit) => {
         for (const t of templates) {
             const k = effects.length;
-            const row = { id: hit.id, path: hit.path };
+            const row = { _id: hit._id, _path: hit._path };
             const origin = { template_index: t.index, row };
             effects.push(bind(hit, t, k, origin, root, request));
             origins.push(origin);
@@ -643,7 +643,7 @@ export function compileSelection(store, repoId, select, expectRaw, templatesRaw)
         ...(expect !== undefined ? { expect } : {}),
         templates: templatesRaw,
         cardinality: hits.length,
-        identities: hits.map((h) => h.id),
+        identities: hits.map((h) => h._id),
     };
     return { effects, selection, origins };
 }
@@ -682,20 +682,20 @@ function slotName(t, slot) {
  */
 function ambiguousFix(request, t, s, hit, root, list) {
     const head = list[0];
-    const first = isRowRef(head) ? head.id : head;
+    const first = isRowRef(head) ? head._id : head;
     if (typeof first !== "string")
         return {};
     const effects = withMember(request.effects, [String(t.index), ...s.path], first);
     if (request.select === undefined)
         return { fix: fixRequest({ effects }) };
-    return { fix: fixRequest({ select: narrowedTo(root, hit.id), effects, expect: { max: 1 } }) };
+    return { fix: fixRequest({ select: narrowedTo(root, hit._id), effects, expect: { max: 1 } }) };
 }
 /** One hit × one template → the concrete effect (the binding table of §11.8). */
 function bind(hit, t, k, origin, root, request) {
     const e = clone(t.base);
     const data = { effect_index: k, ...(origin.template_index !== undefined ? { template_index: origin.template_index } : {}), row: origin.row };
     if (t.defaultTarget !== null) {
-        const target = { kind: HIT_KIND[root], id: hit.id };
+        const target = { kind: HIT_KIND[root], _id: hit._id };
         e[t.defaultTarget.key] = t.defaultTarget.list ? [target] : target;
     }
     for (const s of t.slots) {
@@ -705,10 +705,10 @@ function bind(hit, t, k, origin, root, request) {
             case "identity":
             case "target": {
                 if (absent || (Array.isArray(v) && v.length === 0)) {
-                    throw new MutationError("target_missing", `${s.here}: the expression yielded no identity for row ${hit.id}`, { ...data, expression: s.expression });
+                    throw new MutationError("target_missing", `${s.here}: the expression yielded no identity for row ${hit._id}`, { ...data, expression: s.expression });
                 }
                 if (Array.isArray(v)) {
-                    throw new MutationError("ambiguous_target", `${s.here}: the expression yielded ${v.length} identities for row ${hit.id}; a target resolves to exactly one`, { ...data, expression: s.expression, count: v.length, ...ambiguousFix(request, t, s, hit, root, v) });
+                    throw new MutationError("ambiguous_target", `${s.here}: the expression yielded ${v.length} identities for row ${hit._id}; a target resolves to exactly one`, { ...data, expression: s.expression, count: v.length, ...ambiguousFix(request, t, s, hit, root, v) });
                 }
                 if (typeof v !== "string" && !isRowRef(v))
                     throw selectionInvalid(`${s.here}: the expression yielded ${describeValue(v)}, not an identity (a string or a row)`, { ...data, expression: s.expression });
@@ -717,7 +717,7 @@ function bind(hit, t, k, origin, root, request) {
                     break;
                 }
                 // (3.2) a whole target: a row by its id's prefix, a string as a bare target (a path → document, an id → its kind).
-                const ref = isRowRef(v) ? v.id : v;
+                const ref = isRowRef(v) ? v._id : v;
                 if (!isRowRef(v) && !looksLikePath(ref) && !isTargetId(ref) && !isNewSymbol(ref)) {
                     throw selectionInvalid(`${s.here}: the expression yielded ${describeValue(v)}, not an identity (a document path, an id or a row)`, { ...data, expression: s.expression });
                 }
@@ -726,14 +726,14 @@ function bind(hit, t, k, origin, root, request) {
             }
             case "string":
                 if (absent)
-                    throw selectionInvalid(`${s.here}: the expression yielded absent for row ${hit.id}`, { ...data, expression: s.expression });
+                    throw selectionInvalid(`${s.here}: the expression yielded absent for row ${hit._id}`, { ...data, expression: s.expression });
                 if (typeof v !== "string")
                     throw selectionInvalid(`${s.here}: the expression yielded ${describeValue(v)}, expected a string`, { ...data, expression: s.expression });
                 s.put(e, v);
                 break;
             case "json":
                 if (absent)
-                    throw selectionInvalid(`${s.here}: the expression yielded absent for row ${hit.id}${s.name === "value" ? " — use `unset` to remove a key" : ""}`, { ...data, expression: s.expression });
+                    throw selectionInvalid(`${s.here}: the expression yielded absent for row ${hit._id}${s.name === "value" ? " — use `unset` to remove a key" : ""}`, { ...data, expression: s.expression });
                 s.put(e, v);
                 break;
         }
@@ -813,25 +813,25 @@ function scopeOf(store, repoId, e, i) {
             validateEffect(e, i); // an unknown op (or `retarget`): the shape check refuses it
             throw effectInvalid(`${here}: \`op\` ${JSON.stringify(e.op)} is not row-shaped`);
     }
-    if (isOqx(v) || (isRecord(v) && (isOqx(v.id) || isOqx(v.path))))
+    if (isOqx(v) || (isRecord(v) && (isOqx(v._id) || isOqx(v._path))))
         throw needsSelector(`${here}.${key}`);
     const t = validateTarget(v, `${here}.${key}`, kinds);
     switch (t.kind) {
         case "symbol":
-            throw selectionInvalid(`${here}.${key}: ${t.id} has no row yet — it is created by this plan; use a literal target or a selector`);
+            throw selectionInvalid(`${here}.${key}: ${t._id} has no row yet — it is created by this plan; use a literal target or a selector`);
         case "document": {
             const d = findDocumentTarget(store, repoId, t);
-            return { root: "docs", id: d.id, missing: () => new MutationError("doc_missing", `doc ${d.id} not found`, { doc: d.id }) };
+            return { root: "docs", id: d._id, missing: () => new MutationError("doc_missing", `doc ${d._id} not found`, { doc: d._id }) };
         }
         case "block":
             return {
-                root: "blocks", id: t.id,
-                missing: () => (placement ? new MutationError("parent_missing", `parent ${t.id} not found`) : new MutationError("block_missing", `block ${t.id} not found`, { block: t.id })),
+                root: "blocks", id: t._id,
+                missing: () => (placement ? new MutationError("parent_missing", `parent ${t._id} not found`) : new MutationError("block_missing", `block ${t._id} not found`, { block: t._id })),
             };
         case "section":
             return { root: "blocks", id: t.heading_id, missing: () => new MutationError("parent_missing", `parent ${t.heading_id} not found`) };
         case "node":
-            return { root: "nodes", id: t.id, missing: () => new MutationError("block_missing", `node ${t.id} not found`, {}) };
+            return { root: "nodes", id: t._id, missing: () => new MutationError("block_missing", `node ${t._id} not found`, {}) };
     }
 }
 /**
@@ -839,7 +839,7 @@ function scopeOf(store, repoId, e, i) {
  * 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 ==
+ * 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
@@ -893,7 +893,7 @@ export function compilePlain(store, repoId, raw) {
         g.members.push(t);
     });
     for (const g of scopes.values()) {
-        const q = parse(`from ${g.root} where id == ${JSON.stringify(g.id)}`);
+        const q = parse(`from ${g.root} where _id == ${JSON.stringify(g.id)}`);
         const items = [];
         for (const t of g.members)
             for (const s of t.slots)
@@ -903,7 +903,7 @@ export function compilePlain(store, repoId, raw) {
         if (hit === undefined)
             throw g.missing();
         for (const t of g.members) {
-            const origin = { row: { id: hit.id, path: hit.path } };
+            const origin = { row: { _id: hit._id, _path: hit._path } };
             effects[t.index] = bind(hit, t, t.index, origin, g.root, request);
             origins[t.index] = origin;
         }

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

@@ -8,10 +8,10 @@ export interface Sugar {
     effects: Effect[];
     reason?: string;
 }
-/** A live document as the builders address it: its id and its storage-form path (the reasons spell the path). */
+/** A live document as the builders address it: its row attributes `_id` and `_path` (the storage-form path; the reasons spell it). */
 export interface SugarDoc {
-    id: string;
-    path: string;
+    _id: string;
+    _path: string;
 }
 /** A caller's guard as an effect guard: absent stays absent, an empty object stays an empty guard (the planner then pins what it needs). */
 export declare function guardOf(e: {
@@ -40,21 +40,21 @@ export declare function moveDocEffects(doc: SugarDoc, toPath: string, retargetIn
 /** `docs_delete` / `omg rm --doc`: one `remove { target: document }`; reason `delete <path>`. */
 export declare function deleteDocEffects(doc: SugarDoc): Sugar;
 /**
- * `docs_set_meta` / `omg meta`: one `set`/`unset frontmatter.<k>` per key, `unset`
+ * `docs_set_meta` / `omg meta`: one `set`/`unset _frontmatter.<k>` per key, `unset`
  * winning a key named in both (the legacy merge spread `set` then deleted `unset`);
  * reason `set_meta <path>`. An empty patch yields no effect — the caller refuses
  * it (`filter_invalid` "pass `set` and/or `unset`", spec/surface §9).
  */
 export declare function setMetaEffects(doc: SugarDoc, set: Record<string, unknown> | undefined, unset: readonly string[] | undefined): Sugar;
 /** `docs_update` / `omg update <doc>`: one `set { document, content }`; the reason is the caller's. */
-export declare function updateContentEffects(doc: Pick<SugarDoc, "id">, content: string, reason?: string): Sugar;
+export declare function updateContentEffects(doc: Pick<SugarDoc, "_id">, content: string, reason?: string): Sugar;
 /** `blocks_insert` / `omg insert`: `insert into <document|block> at …`; the caller's `expect` is the destination-parent CAS. */
 export declare function insertEffects(into: EffectTarget, at: EffectAt, markdown: string, expect?: {
     parent_children_hash?: string | undefined;
 }): Sugar;
 /**
  * `blocks_update` / `omg update <block>` / `omg edit`: `set markdown` and/or `set
- * attrs.checked`. The caller's `expect` guards the FIRST effect (the content CAS
+ * _attrs.checked`. The caller's `expect` guards the FIRST effect (the content CAS
  * is checked once, against the bytes the caller saw); a second effect is pinned
  * by the planner to the block as the first left it. Nothing to set → no effect
  * (the caller refuses it).
@@ -77,7 +77,7 @@ export declare function removeBlocksEffects(ids: readonly string[]): Sugar;
 export declare function splitEffects(id: string, at: readonly number[]): Sugar;
 /** `blocks_merge` / `omg merge`: one `merge { targets, separator? }`. */
 export declare function mergeEffects(ids: readonly string[], separator?: string): Sugar;
-/** `blocks_check` / `omg done`: N × `set attrs.checked` (a block named twice is one write — the planner drops the duplicate). */
+/** `blocks_check` / `omg done`: N × `set _attrs.checked` (a block named twice is one write — the planner drops the duplicate). */
 export declare function checkEffects(ids: readonly string[], checked: boolean): Sugar;
 /** `nodes_set` / `omg node set`: one `set { node, field: prop, value }`. */
 export declare function nodeSetEffects(nodeId: string, prop: string, value: string): Sugar;
@@ -108,10 +108,10 @@ export declare function applySugar(store: Store, request: SugarRequest & {
     plan: Plan;
     receipt?: Receipt;
 };
-/** The document-operation result the `omg` document verbs and the fixture `docs` step record (`spec/mutate` §9): `{ id, path, committed }`, the path in the storage form. */
+/** The document-operation result the `omg` document verbs and the fixture `docs` step record (`spec/mutate` §9): `{ _id, _path, committed }`, the path in the storage form. */
 export interface DocOpOutcome {
-    id: string;
-    path: string;
+    _id: string;
+    _path: string;
     committed: true;
 }
 /** `docs_create`'s document is the receipt's first revision (`new_ids["$new.0"]` is the same id); every other operation's is the one addressed. */