@omgbase/core 0.10.0 → 0.11.0

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

@@ -77,12 +77,19 @@ export interface ApplyRequest {
 export interface OpResult {
     ids: string[];
 }
+/** One touched document in an apply result (spec/mutate §4, 2.0): its row
+ *  attributes `id`, `path` (the storage form here; the surface roots it) and
+ *  `hash` — the hex sha256 of the rendered bytes, i.e. the hash the committed
+ *  revision carries (a dry run reports the hash it would carry). The same
+ *  three keys a `changes_since` revision carries. */
+export interface ApplyRevision {
+    id: string;
+    path: string;
+    hash: string;
+}
 export interface ApplyResult {
     results: OpResult[];
-    revisions: {
-        doc: string;
-        path: string;
-    }[];
+    revisions: ApplyRevision[];
     diffs?: Record<string, {
         before: string;
         after: string;

package/dist/src/mutate/apply.js

@@ -152,8 +152,9 @@ export function apply(store, req) {
     const revisions = [];
     const diffs = {};
     for (const [docId, d] of loaded) {
-        diffs[d.path] = { before: before.get(docId) ?? "", after: renderDoc(d) };
-        revisions.push({ doc: docId, path: d.path });
+        const after = renderDoc(d);
+        diffs[d.path] = { before: before.get(docId) ?? "", after };
+        revisions.push({ id: docId, path: d.path, hash: sha256(after).toString("hex") });
     }
     if (req.dryRun) {
         return { results, revisions, diffs, committed: false };

package/dist/src/mutate/docs.js

@@ -121,9 +121,9 @@ export function docsMove(store, ctx, docRef, toPath, opts = {}) {
             db.prepare("UPDATE edges SET dst_node = ? WHERE dst_node = ? AND to_commit IS NULL AND src_doc != ?").run(phantom, info.docId, info.docId);
             const selfEdge = db.prepare("UPDATE edges SET dst_node = ? WHERE dst_node = ? AND to_commit IS NULL AND src_doc = ? AND src_block = ? AND anchor IS ?");
             for (const l of inbound) {
-                if (l.doc !== info.docId || l.block === null)
+                if (l.doc_id !== info.docId || l.block_id === null)
                     continue;
-                selfEdge.run(phantom, info.docId, info.docId, l.block, l.anchor);
+                selfEdge.run(phantom, info.docId, info.docId, l.block_id, l.anchor);
                 affected.add(info.docId);
             }
             for (const d of affected)
@@ -172,8 +172,8 @@ function applyCtx(ctx) {
 function planInboundRetarget(store, docId, fromPath, toRel, inbound) {
     const byBlock = new Map();
     for (const l of inbound)
-        if (l.block !== null && !byBlock.has(l.block))
-            byBlock.set(l.block, l);
+        if (l.block_id !== null && !byBlock.has(l.block_id))
+            byBlock.set(l.block_id, l);
     // A container's raw includes its children's raw, so a link inside a list item
     // is reported for BOTH the list and the item. Rewrite the deepest block only:
     // updating the container would re-parse (and re-identify) its children, and
@@ -202,17 +202,17 @@ function planInboundRetarget(store, docId, fromPath, toRel, inbound) {
         // Match against the directory the link was RESOLVED in (the source's path at
         // extraction time); write relative forms against the source's CURRENT
         // directory — they differ only for links inside the moved doc itself.
-        const writeDir = src.doc === docId ? dirOf(toRel) : dirOf(src.path);
+        const writeDir = src.doc_id === docId ? dirOf(toRel) : dirOf(src.path);
         const newRaw = retargetLinksInRaw(row.bytes.toString("utf8"), dirOf(src.path), writeDir, fromPath, toRel);
         if (newRaw === null)
             continue;
         ops.push({ op: "update", block: blockId, markdown: newRaw, expect: { content_hash: row.raw_hash.toString("hex") } });
         blocks.push(blockId);
-        docs.add(src.doc);
+        docs.add(src.doc_id);
     }
     // Containers whose rewritten child covered them count as rewritten too.
     const rewritten = new Set([...blocks, ...containers]);
-    const dangling = inbound.filter((l) => l.block === null || !rewritten.has(l.block));
+    const dangling = inbound.filter((l) => l.block_id === null || !rewritten.has(l.block_id));
     return { ops, blocks, docs: [...docs], dangling };
 }
 /** docs_delete: mark a document deleted and remove its file (resurrection-poolable). */

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

@@ -28,8 +28,11 @@ export declare function listsInsertItem(anchor: string, at: "start" | "end" | {
 } | {
     after: string;
 }, markdown: string): Op[];
+/** One rewritten block of a retarget/repair (spec/surface §4, 3.0): the block's
+ *  `id`, its document's `path` (the storage form here; the surface roots it),
+ *  and the raw before/after. */
 export interface RetargetHit {
-    block: string;
+    id: string;
     /** repo-relative path of the block's document */
     path: string;
     oldRaw: string;

package/dist/src/mutate/macros.js

@@ -230,7 +230,7 @@ export function linksRepair(store, repoId, repairs, opts = {}) {
         c.tally.forEach((n, i) => { effective[i].hits += n; });
         const hash = rawHashOfBlock(store, blockId);
         ops.push({ op: "update", block: blockId, markdown: c.newRaw, ...(hash ? { expect: { content_hash: hash } } : {}) });
-        hits.push({ block: blockId, path: c.path, oldRaw: c.oldRaw, newRaw: c.newRaw });
+        hits.push({ id: blockId, path: c.path, oldRaw: c.oldRaw, newRaw: c.newRaw });
     }
     return { ops, hits, pairs };
 }

package/dist/src/mutate/ops.js

@@ -109,7 +109,7 @@ function checkContentHash(block, expect, opIndex) {
         throw new MutationError("stale_expectation", "expect.content_hash required", {
             op_index: opIndex,
             block: block.id,
-            current: { content_hash: rawHashHex(block.raw), markdown: block.raw },
+            current: { hash: rawHashHex(block.raw), markdown: block.raw },
             retriable: true,
         });
     }
@@ -119,7 +119,7 @@ function checkContentHash(block, expect, opIndex) {
             op_index: opIndex,
             block: block.id,
             expected_content_hash: expect.content_hash,
-            current: { content_hash: current, markdown: block.raw },
+            current: { hash: current, markdown: block.raw },
             retriable: true,
         });
     }

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

@@ -8,15 +8,18 @@ export type OpsetKind = "doc_update";
  * reproduce the proposed bytes exactly.
  */
 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. */
+/** 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;
+ *  `baseRevision` names a role and keeps its name. */
 export interface OpsetPrecondition {
     /** doc id the plan targets */
-    doc: 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 */
-    baseContentHash: 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 {
@@ -51,7 +54,7 @@ export interface Opset {
     version: 1;
     kind: OpsetKind;
     target: {
-        doc: string;
+        id: string;
         path: string;
     };
     precondition: OpsetPrecondition;

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

@@ -84,8 +84,8 @@ export function planUpdate(store, repoId, rootPath, docRef, content, opts = {})
     return {
         version: 1,
         kind: "doc_update",
-        target: { doc: docId, path },
-        precondition: { doc: docId, path, baseRevision: info.currentRev, baseContentHash },
+        target: { id: docId, path: path },
+        precondition: { id: docId, path: path, baseRevision: info.currentRev, hash: baseContentHash },
         matcherV: config.matcherV,
         ops,
         ...(fmChanged ? { frontmatter: { raw: targetFm } } : {}),
@@ -145,15 +145,16 @@ export function applyOpset(store, req) {
     }
     // Precondition: the document must still be at the revision/content the plan
     // was computed against.
-    const row = store.db.prepare("SELECT current_rev, lower(hex(file_hash)) fh FROM docs WHERE doc_id = ? AND deleted_commit IS NULL").get(opset.precondition.doc);
+    const docId = opset.precondition.id;
+    const row = store.db.prepare("SELECT current_rev, lower(hex(file_hash)) fh FROM docs WHERE doc_id = ? AND deleted_commit IS NULL").get(docId);
     if (!row)
-        throw new MutationError("doc_missing", `doc ${opset.precondition.doc} not found`, { doc: opset.precondition.doc });
-    const stale = (opset.precondition.baseRevision !== null && row.current_rev !== opset.precondition.baseRevision) || (row.fh !== null && row.fh !== opset.precondition.baseContentHash);
+        throw new MutationError("doc_missing", `doc ${docId} not found`, { doc: docId });
+    const stale = (opset.precondition.baseRevision !== null && row.current_rev !== opset.precondition.baseRevision) || (row.fh !== null && row.fh !== opset.precondition.hash);
     if (stale) {
         throw new MutationError("stale_plan", "document changed since the plan was computed; re-plan", {
-            doc: opset.precondition.doc,
+            doc: docId,
             expected_revision: opset.precondition.baseRevision,
-            current: { revision: row.current_rev, content_hash: row.fh },
+            current: { revision: row.current_rev, hash: row.fh },
             retriable: true,
         });
     }
@@ -166,7 +167,7 @@ export function applyOpset(store, req) {
         ...(req.dryRun !== undefined ? { dryRun: req.dryRun } : {}),
         ...(req.omgbaseDir !== undefined ? { omgbaseDir: req.omgbaseDir } : {}),
         ...(req.ts !== undefined ? { ts: req.ts } : {}),
-        ...(opset.frontmatter ? { setFrontmatter: [{ doc: opset.precondition.doc, raw: opset.frontmatter.raw }] } : {}),
+        ...(opset.frontmatter ? { setFrontmatter: [{ doc: docId, raw: opset.frontmatter.raw }] } : {}),
     });
 }
 /**

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

@@ -1,8 +1,20 @@
 import type { DataContext } from "@omgbase/oqx";
 import type { Store } from "../core/store/store.js";
 import type { SemanticVec } from "../search/cel/compile.js";
-export type Target = "docs" | "blocks" | "nodes" | "edges";
+export type Target = "docs" | "blocks" | "nodes" | "links";
 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>>>;
+/** 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>;
+/** The value of a statically SINGLE relation that has no row — `dst` on an
+ * external or dangling link, `block` on a node without one (oqx 0.20, SEMANTICS
+ * §3): an object the engine treats as one row with no rows, so `dst { title }`
+ * is absent rather than `[]`, while as a VALUE it is absent (`materialize`),
+ * so `dst == null`, `has(dst)` and `dst.title` read as before. */
+export declare const ABSENT_SINGLE: object;
 export interface StoreContextOptions {
     /** Pre-computed query vectors for `semantic("phrase")`, keyed by phrase (the
      * async runner fills this; the sync path leaves it empty and a semantic() with
@@ -22,9 +34,10 @@ export declare function makeStoreContext(store: Store, repoId: string, opts?: St
 export declare function tagRows(rows: Record<string, unknown>[], target: Target): 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 }` — its id column and its document's
- * path in the reference form (`/a.md`, §1 "Paths"), the same two keys every hit
- * carries — never the store row itself.
+ * values, 1.2) is rendered as `{ id, path }` (3.0) — its id column and its
+ * document's path in the reference form (`/a.md`, §1 "Paths"), the same two keys
+ * every hit carries, spelled as the attributes that read them — never the store
+ * row itself.
  * Returns undefined for anything that is not a tagged row (run.ts leaves those
  * alone).
  */