@omgbase/core 0.28.0 → 0.29.0

package/dist/src/mutate/sugar.js

@@ -4,8 +4,8 @@ import { canonicalDocPath, planInboundRetarget } from "./docs.js";
 import { resolveDocStore } from "./doc-store.js";
 import { MutationError } from "./tree.js";
 import { applyEffectsDetailed, stripEffectIndex } from "./plan.js";
-const documentTarget = (id) => ({ kind: "document", id });
-const blockTarget = (id) => ({ kind: "block", id });
+const documentTarget = (id) => ({ kind: "document", _id: id });
+const blockTarget = (id) => ({ kind: "block", _id: id });
 /** 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 function guardOf(e) {
     if (!e)
@@ -41,30 +41,30 @@ export function createEffects(path, markdown, frontmatter) {
 /** `docs_move` / `omg mv`: one `move { target: document, to, retarget_inbound }`; reason `move <from> -> <to>`. */
 export function moveDocEffects(doc, toPath, retargetInbound = true) {
     const to = canonicalDocPath(toPath);
-    return { effects: [{ op: "move", target: documentTarget(doc.id), to, ...(retargetInbound ? {} : { retarget_inbound: false }) }], reason: `move ${doc.path} -> ${to}` };
+    return { effects: [{ op: "move", target: documentTarget(doc._id), to, ...(retargetInbound ? {} : { retarget_inbound: false }) }], reason: `move ${doc._path} -> ${to}` };
 }
 /** `docs_delete` / `omg rm --doc`: one `remove { target: document }`; reason `delete <path>`. */
 export function deleteDocEffects(doc) {
-    return { effects: [{ op: "remove", target: documentTarget(doc.id) }], reason: `delete ${doc.path}` };
+    return { effects: [{ op: "remove", target: documentTarget(doc._id) }], reason: `delete ${doc._path}` };
 }
 /**
- * `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 function setMetaEffects(doc, set, unset) {
     const gone = unset ?? [];
-    const target = documentTarget(doc.id);
+    const target = documentTarget(doc._id);
     const effects = [
-        ...Object.entries(set ?? {}).filter(([k]) => !gone.includes(k)).map(([k, value]) => ({ op: "set", target, field: `frontmatter.${k}`, value })),
-        ...gone.map((k) => ({ op: "unset", target, field: `frontmatter.${k}` })),
+        ...Object.entries(set ?? {}).filter(([k]) => !gone.includes(k)).map(([k, value]) => ({ op: "set", target, field: `_frontmatter.${k}`, value })),
+        ...gone.map((k) => ({ op: "unset", target, field: `_frontmatter.${k}` })),
     ];
-    return { effects, reason: `set_meta ${doc.path}` };
+    return { effects, reason: `set_meta ${doc._path}` };
 }
 /** `docs_update` / `omg update <doc>`: one `set { document, content }`; the reason is the caller's. */
 export function updateContentEffects(doc, content, reason) {
-    return { effects: [{ op: "set", target: documentTarget(doc.id), field: "content", value: content }], ...(reason !== undefined ? { reason } : {}) };
+    return { effects: [{ op: "set", target: documentTarget(doc._id), field: "content", value: content }], ...(reason !== undefined ? { reason } : {}) };
 }
 // ---- the block-level tools (spec/surface §4) ----------------------------------------------
 /** `blocks_insert` / `omg insert`: `insert into <document|block> at …`; the caller's `expect` is the destination-parent CAS. */
@@ -73,7 +73,7 @@ export function insertEffects(into, at, markdown, expect) {
 }
 /**
  * `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).
@@ -85,7 +85,7 @@ export function updateBlockEffects(id, patch) {
     if (patch.markdown !== undefined)
         effects.push({ op: "set", target, field: "markdown", value: patch.markdown, ...expect });
     if (patch.checked !== undefined)
-        effects.push({ op: "set", target, field: "attrs.checked", value: patch.checked, ...(effects.length === 0 ? expect : {}) });
+        effects.push({ op: "set", target, field: "_attrs.checked", value: patch.checked, ...(effects.length === 0 ? expect : {}) });
     return { effects, reason: "blocks_update" };
 }
 /** `blocks_move` / `omg move`: one `move { targets, into, at, expect }`. */
@@ -104,13 +104,13 @@ export function splitEffects(id, at) {
 export function mergeEffects(ids, separator) {
     return { effects: [{ op: "merge", targets: ids.map(blockTarget), ...(separator !== undefined ? { separator } : {}) }], reason: "blocks_merge" };
 }
-/** `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 function checkEffects(ids, checked) {
-    return { effects: ids.map((id) => ({ op: "set", target: blockTarget(id), field: "attrs.checked", value: checked })), reason: "blocks_check" };
+    return { effects: ids.map((id) => ({ op: "set", target: blockTarget(id), field: "_attrs.checked", value: checked })), reason: "blocks_check" };
 }
 /** `nodes_set` / `omg node set`: one `set { node, field: prop, value }`. */
 export function nodeSetEffects(nodeId, prop, value) {
-    return { effects: [{ op: "set", target: { kind: "node", id: nodeId }, field: prop, value }], reason: "nodes_set" };
+    return { effects: [{ op: "set", target: { kind: "node", _id: nodeId }, field: prop, value }], reason: "nodes_set" };
 }
 /** `blocks_append` / `omg append`: `insert at end` into a heading's section or a container block (the caller decided which by the block's kind). */
 export function appendEffects(into, text) {
@@ -143,13 +143,13 @@ export function applySugar(store, request, sugar) {
 }
 /** `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. */
 export function createdDoc(receipt, path) {
-    const id = receipt.new_ids["$new.0"] ?? receipt.revisions[0]?.id;
+    const id = receipt.new_ids["$new.0"] ?? receipt.revisions[0]?._id;
     if (id === undefined)
         throw new Error("createdDoc: the receipt names no created document");
-    return { id, path, committed: true };
+    return { _id: id, _path: path, committed: true };
 }
-export function docOutcome(doc, path = doc.path) {
-    return { id: doc.id, path, committed: true };
+export function docOutcome(doc, path = doc._path) {
+    return { _id: doc._id, _path: path, committed: true };
 }
 /**
  * Who links to the document BY PATH as written, and what the move's retarget
@@ -158,10 +158,10 @@ export function docOutcome(doc, path = doc.path) {
  */
 export function moveLinks(store, repoId, doc, toPath, retargetInbound = true) {
     const to = canonicalDocPath(toPath);
-    const inbound = inboundLinksTo(store, repoId, doc.id, doc.path);
+    const inbound = inboundLinksTo(store, repoId, doc._id, doc._path);
     if (!retargetInbound || inbound.length === 0)
         return { dangling: inbound, retargeted: null };
-    const plan = planInboundRetarget(store, doc.id, doc.path, to, inbound);
+    const plan = planInboundRetarget(store, doc._id, doc._path, to, inbound);
     return { dangling: plan.dangling, retargeted: { blocks: plan.blocks, docs: plan.docs } };
 }
 //# sourceMappingURL=sugar.js.map

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

@@ -13,9 +13,13 @@ 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<Kind, ReadonlySet<string>>>;
-/** The source handles of a document (§1.2): `data` is the merged authored view
+/** 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 `properties.source` a handle narrows a read to: `_data` → both authored sources (null). */
+export declare function handleSource(handle: string): string | null;
+/** The reach-through handles per kind (§1.2) — each a statically single row of another kind. */
+export declare const REACH_THROUGHS: Readonly<Record<Kind, 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 }`
@@ -41,7 +45,7 @@ export declare function makeStoreContext(store: Store, repoId: string, opts?: St
 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
+ * values, 1.2) is rendered as `{ _id, _path }` (5.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.
@@ -49,7 +53,7 @@ export declare function tagRows(rows: Record<string, unknown>[], target: Kind):
  * alone).
  */
 export declare function rowRef(value: unknown): {
-    id: string;
-    path: string;
+    _id: string;
+    _path: string;
 } | undefined;
 export { TARGET };