@omgbase/core 0.28.0 → 0.29.0

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

@@ -68,15 +68,15 @@ 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
+/** One touched document in an apply result (spec/mutate §4, 2.0; 4.0 "underscore = engine"): 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;
+    _id: string;
+    _path: string;
+    _hash: string;
 }
 export interface ApplyResult {
     results: OpResult[];

package/dist/src/mutate/apply.js

@@ -265,7 +265,7 @@ export class ChangesetPlanner {
             // preconditions and its ingest is guarded by `path_taken` (`base: null`).
             const base = this.bases.get(docId) ?? null;
             diffs[d.path] = { before: this.before.get(docId) ?? "", after };
-            revisions.push({ id: docId, path: d.path, hash: sha256(after).toString("hex") });
+            revisions.push({ _id: docId, _path: d.path, _hash: sha256(after).toString("hex") });
             if (base)
                 preconditions.push({ id: docId, ...base });
             effects.push({ kind: "ingest_known", docId, path: d.path, rendered: after, mutDoc: d, priorIds: this.priorIds.get(docId) ?? new Set(), base });

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

@@ -19,7 +19,7 @@ export interface FixRequest {
 export declare function fixRequest(req: FixRequest): string;
 /** The `fix` naming another tool: `<tool> <canonical args>`. */
 export declare function fixTool(tool: string, args: unknown): string;
-/** The selector that names exactly one row: the request narrowed to `from <root> where id == "<id>"` with `expect.max: 1` (the fix of a cross-hit collision or an ambiguous target under a selector). */
+/** The selector that names exactly one row: the request narrowed to `from <root> where _id == "<id>"` with `expect.max: 1` (the fix of a cross-hit collision or an ambiguous target under a selector). */
 export declare function narrowedTo(root: "docs" | "blocks" | "nodes", id: string): string;
 /** The root a row id belongs to, by its prefix (`d_` / `b_` / `n_`). */
 export declare function rootOfId(id: string): "docs" | "blocks" | "nodes";

package/dist/src/mutate/canonical.js

@@ -110,9 +110,9 @@ export function fixRequest(req) {
 export function fixTool(tool, args) {
     return `${tool} ${canonicalJson(args)}`;
 }
-/** The selector that names exactly one row: the request narrowed to `from <root> where id == "<id>"` with `expect.max: 1` (the fix of a cross-hit collision or an ambiguous target under a selector). */
+/** The selector that names exactly one row: the request narrowed to `from <root> where _id == "<id>"` with `expect.max: 1` (the fix of a cross-hit collision or an ambiguous target under a selector). */
 export function narrowedTo(root, id) {
-    return `from ${root} where id == ${JSON.stringify(id)}`;
+    return `from ${root} where _id == ${JSON.stringify(id)}`;
 }
 /** The root a row id belongs to, by its prefix (`d_` / `b_` / `n_`). */
 export function rootOfId(id) {

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

@@ -9,8 +9,8 @@ import { type MutDoc } from "./tree.js";
  *  when the row has none) as one `SELECT` read them at plan time. Invariant I3
  *  (spec/store §8) makes `current_rev` the version vector of every live block,
  *  so the commit need not re-read blocks: a block cannot change without a new
- *  revision. The same triple the opset precondition `{ id, path, base_revision,
- *  hash }` freezes. */
+ *  revision. The same triple the opset precondition `{ _id, _path, base_revision,
+ *  _hash }` freezes. */
 export interface DocBase {
     path: string;
     currentRev: string | null;
@@ -140,7 +140,7 @@ export interface CommitTargets {
  * Commit `effects` as one request under `head` at `ts`. Throws `sync_conflict`
  * (retriable) when a document changed on disk — after ingesting those bytes as
  * an `observed` commit so a retry sees them — `stale_plan` (retriable, `{ doc,
- * expected_revision, current: { revision, hash } }`) when a document's row
+ * expected_revision, current: { revision, _hash } }`) when a document's row
  * moved since the plan, `doc_missing` / `path_taken` per effect, and otherwise
  * returns the shared commit id with the ingest results. The caller holds the
  * writer lock when it has a workspace.

package/dist/src/mutate/commit.js

@@ -17,7 +17,7 @@ export function readDocBase(db, docId) {
  * Commit `effects` as one request under `head` at `ts`. Throws `sync_conflict`
  * (retriable) when a document changed on disk — after ingesting those bytes as
  * an `observed` commit so a retry sees them — `stale_plan` (retriable, `{ doc,
- * expected_revision, current: { revision, hash } }`) when a document's row
+ * expected_revision, current: { revision, _hash } }`) when a document's row
  * moved since the plan, `doc_missing` / `path_taken` per effect, and otherwise
  * returns the shared commit id with the ingest results. The caller holds the
  * writer lock when it has a workspace.
@@ -261,7 +261,7 @@ function validate(db, repoId, effects, onDisk) {
             throw new MutationError("stale_plan", `document ${docId} changed since the request was planned; re-plan`, {
                 doc: docId,
                 expected_revision: expected.currentRev,
-                current: { revision: row.currentRev, hash: row.fileHash },
+                current: { revision: row.currentRev, _hash: row.fileHash },
                 retriable: true,
             });
         }
@@ -323,9 +323,9 @@ function movePath(db, e) {
     db.prepare("UPDATE edges SET dst_node = ? WHERE dst_node = ? AND to_commit IS NULL AND src_doc != ?").run(phantom, e.docId, e.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 e.inbound) {
-        if (l.doc_id !== e.docId || l.block_id === null)
+        if (l._doc_id !== e.docId || l._block_id === null)
             continue;
-        selfEdge.run(phantom, e.docId, e.docId, l.block_id, l.anchor);
+        selfEdge.run(phantom, e.docId, e.docId, l._block_id, l._anchor);
         affected.add(e.docId);
     }
     for (const d of affected)

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

@@ -8,7 +8,7 @@ export declare function canonicalDocPath(path: string): string;
  *  (spec/mutate §6 `docs_create`): the body with a trailing `\n` ensured; a
  *  non-empty frontmatter mapping becomes `---\n<yaml>\n---\n` followed by a
  *  blank line unless the body already starts with one. The effect planner's
- *  `set frontmatter.<k>` composes through this same function (§11.3), so its
+ *  `set _frontmatter.<k>` composes through this same function (§11.3), so its
  *  bytes equal `docs_set_meta`'s for the same patch. */
 export declare function composeFile(markdown: string, frontmatter?: Record<string, unknown>): string;
 /**

package/dist/src/mutate/docs.js

@@ -7,7 +7,7 @@ import { retargetLinksInRaw } from "../graph/inbound-links.js";
 // module held `docsCreate` / `docsMove` / `docsDelete` / `docsSetMeta`, library
 // functions that composed the internal commit effects themselves; since 3.0 the
 // operations are the effect builders of `sugar.ts` (`create`, `move document`,
-// `remove document`, `set`/`unset frontmatter.<k>`) planned and executed by the
+// `remove document`, `set`/`unset _frontmatter.<k>`) planned and executed by the
 // Effect layer (`plan.ts`), and what remains here is what the planner's
 // lowerings share with them: the path canonicalization, the file composition,
 // the parse of a created document, the inbound-link retarget plan and the
@@ -23,7 +23,7 @@ export function canonicalDocPath(path) {
  *  (spec/mutate §6 `docs_create`): the body with a trailing `\n` ensured; a
  *  non-empty frontmatter mapping becomes `---\n<yaml>\n---\n` followed by a
  *  blank line unless the body already starts with one. The effect planner's
- *  `set frontmatter.<k>` composes through this same function (§11.3), so its
+ *  `set _frontmatter.<k>` composes through this same function (§11.3), so its
  *  bytes equal `docs_set_meta`'s for the same patch. */
 export function composeFile(markdown, frontmatter) {
     const body = markdown.endsWith("\n") || markdown.length === 0 ? markdown : markdown + "\n";
@@ -69,8 +69,8 @@ export function parseNewDoc(symbol, path, source) {
 export function planInboundRetarget(store, docId, fromPath, toRel, inbound) {
     const byBlock = new Map();
     for (const l of inbound)
-        if (l.block_id !== null && !byBlock.has(l.block_id))
-            byBlock.set(l.block_id, 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
@@ -99,17 +99,17 @@ export 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_id === docId ? dirOf(toRel) : dirOf(src.path);
-        const newRaw = retargetLinksInRaw(row.bytes.toString("utf8"), dirOf(src.path), writeDir, fromPath, toRel);
+        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_id);
+        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_id === null || !rewritten.has(l.block_id));
+    const dangling = inbound.filter((l) => l._block_id === null || !rewritten.has(l._block_id));
     return { ops, blocks, docs: [...docs], dangling };
 }
 /** Split a file's bytes into (frontmatter object, body markdown) with

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

@@ -14,20 +14,20 @@ import { type FixRequest } from "./canonical.js";
  *  symbol table decides when the effect is resolved; it never reaches a resolved effect. */
 export type EffectTarget = {
     kind: "document";
-    id?: string;
-    path?: string;
+    _id?: string;
+    _path?: string;
 } | {
     kind: "block";
-    id: string;
+    _id: string;
 } | {
     kind: "node";
-    id: string;
+    _id: string;
 } | {
     kind: "section";
     heading_id: string;
 } | {
     kind: "symbol";
-    id: string;
+    _id: string;
 };
 export type EffectAt = At;
 /** Guards: the kernel's two CAS fields plus the document's `current_rev` at plan time. */
@@ -100,17 +100,17 @@ export declare const EFFECT_OPS: readonly ["create", "insert", "set", "unset", "
 /** `$new.<n>`: an identity an earlier effect of the same request creates (§11.1). */
 export declare const NEW_SYMBOL_RE: RegExp;
 export declare function isNewSymbol(s: string): boolean;
-/** A target with its document resolved to `{ id, path }` (path in the storage form; a `$new.n` document keeps its symbol). */
+/** A target with its document resolved to `{ _id, _path }` (path in the storage form; a `$new.n` document keeps its symbol). */
 export type ResolvedTarget = {
     kind: "document";
-    id: string;
-    path: string;
+    _id: string;
+    _path: string;
 } | {
     kind: "block";
-    id: string;
+    _id: string;
 } | {
     kind: "node";
-    id: string;
+    _id: string;
 } | {
     kind: "section";
     heading_id: string;
@@ -200,8 +200,8 @@ export declare function looksLikePath(s: string): boolean;
 export declare function isTargetId(s: string): boolean;
 /**
  * A bare string where a target object is expected (3.2, §11.8 "Sugar"): a
- * path-looking string → `{ kind: "document", path }`; a `b_`/`d_`/`n_` id →
- * that kind; `$new.n` → `{ kind: "symbol", id }` (its kind is the symbol
+ * path-looking string → `{ kind: "document", _path }`; a `b_`/`d_`/`n_` id →
+ * that kind; `$new.n` → `{ kind: "symbol", _id }` (its kind is the symbol
  * table's at resolution); a `#` locator → `filter_invalid` with a `fix`;
  * anything else is no target. A `-> ` leader never reaches here from the
  * planner (`select.ts` desugars it first); as a library input it is refused
@@ -219,8 +219,8 @@ export interface Focus {
     kind: "scalar" | "positional" | "identity";
     target: {
         kind: "document" | "block" | "node" | "path";
-        id?: string;
-        path?: string;
+        _id?: string;
+        _path?: string;
     };
     field?: string;
 }
@@ -347,13 +347,13 @@ export interface LoweringContext {
     /** `preview.summary` (3.3, §11.9): one line in words per resolved effect, in order */
     summary: string[];
 }
-/** Resolve a document target: an existing document's `{ id, path }`, or a `$new.n` document this plan creates. */
+/** Resolve a document target: an existing document's `{ _id, _path }`, or a `$new.n` document this plan creates. */
 export declare function resolveDocumentTarget(ctx: LoweringContext, t: Extract<EffectTarget, {
     kind: "document";
 }>): Extract<ResolvedTarget, {
     kind: "document";
 }>;
-/** An existing document's `{ id, path }` for a literal document target (`doc_missing`; `filter_invalid` when `id` and `path` disagree). */
+/** An existing document's `{ _id, _path }` for a literal document target (`doc_missing`; `filter_invalid` when `_id` and `_path` disagree). */
 export declare function findDocumentTarget(store: Store, repoId: string, t: Extract<EffectTarget, {
     kind: "document";
 }>): Extract<ResolvedTarget, {
@@ -361,7 +361,7 @@ export declare function findDocumentTarget(store: Store, repoId: string, t: Extr
 }>;
 /** `1 block` / `2 blocks` (an `s` on every noun of the table). */
 export declare function plural(n: number, noun: string): string;
-/** Resolve one validated effect's targets (§11.4): documents to `{ id, path }`, defaults made explicit; `i` names the effect in messages. */
+/** Resolve one validated effect's targets (§11.4): documents to `{ _id, _path }`, defaults made explicit; `i` names the effect in messages. */
 export declare function resolveEffect(ctx: LoweringContext, e: Effect, i?: number): ResolvedEffect;
 /** Shift a kernel op's `$n.ids[i]` placeholders by `offset` (an opset planned alone, spliced into a longer op list). */
 export declare function shiftPlaceholders(op: Op, offset: number): Op;