@omgbase/core 0.11.1 → 0.19.0

package/dist/src/sync/writer-lock.js

@@ -1,5 +1,5 @@
-import { openSync, closeSync, readFileSync, writeFileSync, unlinkSync, existsSync, mkdirSync } from "node:fs";
-import { join } from "node:path";
+import { openSync, closeSync, readFileSync, writeFileSync, unlinkSync, existsSync, mkdirSync, realpathSync } from "node:fs";
+import { join, resolve } from "node:path";
 // Cross-process writer lock (11 §3.2). The write protocol's per-repo writer
 // mutex (04 §6 step 1) generalizes to an advisory lock on
 // <workspace>/.omgbase/writer.lock, held for steps 2–7. All writers — one-shot
@@ -72,33 +72,120 @@ const SLEEP_CELL = new Int32Array(new SharedArrayBuffer(4));
 function sleepSync(ms) {
     Atomics.wait(SLEEP_CELL, 0, 0, ms);
 }
-/**
- * Run fn while holding the workspace writer lock. Blocks (polling) until the
- * lock is free or the timeout elapses, then releases the lock even if fn throws.
- */
-export function withWriterLock(omgbaseDir, fn, opts = {}) {
+// Re-entrancy (one acquire per host write, spec/sync §7). The lock is a
+// per-PROCESS claim — the record names a pid and liveness is the pid's — so a
+// second `withWriterLock` on the same directory from the holder must not poll
+// against itself (it would see its own live pid and time out). The process
+// keeps a depth per lock path: the first entry acquires the file, nested
+// entries run their fn directly, and the exit that brings the depth back to
+// zero releases. Nesting happens by design — a tool-boundary lock around a
+// whole MCP call (`mcp/server.ts`) encloses the kernel's own commit-phase lock
+// (`mutate/apply.ts`), and a watcher checkpoint may run while a verb holds the
+// lock — and since the file is one claim per process, the depth also lets an
+// async holder (a checkpoint awaiting the adapter) and a tool call interleave
+// on the event loop without either releasing the other's claim. Cross-process
+// semantics are unchanged: a foreign live holder is waited for, never stolen.
+const held = new Map();
+// The depth is keyed by the directory's real path, so two spellings of one
+// workspace (relative/absolute, a symlinked tree) are one claim; a directory
+// that does not exist yet (a probe before the first write) keys by its resolved path.
+function lockPathOf(omgbaseDir) {
+    let dir;
+    try {
+        dir = realpathSync.native(omgbaseDir);
+    }
+    catch {
+        dir = resolve(omgbaseDir);
+    }
+    return join(dir, LOCK_NAME);
+}
+// Process-wide defaults for the wait (spec/sync §7: 5 s, polled every 25 ms).
+// A host may override them for the whole process — the CLI's
+// `OMGBASE_WRITER_LOCK_TIMEOUT_MS` test seam does, so a verb's kernel-level lock
+// and `omg mcp`'s tool-boundary lock shorten together, like the Rust binary's.
+// Per-call `opts` still win.
+let defaults = { timeoutMs: 5000, pollMs: 25 };
+/** Override the process-wide wait defaults (a test seam; the poll never outlasts the timeout). */
+export function setWriterLockDefaults(opts) {
     const timeoutMs = opts.timeoutMs ?? 5000;
-    const pollMs = opts.pollMs ?? 25;
-    mkdirSync(omgbaseDir, { recursive: true });
-    const lockPath = join(omgbaseDir, LOCK_NAME);
+    defaults = { timeoutMs, pollMs: Math.min(opts.pollMs ?? 25, timeoutMs) };
+}
+/** The process-wide wait defaults in force. */
+export function writerLockDefaults() {
+    return { ...defaults };
+}
+function acquire(lockPath, opts) {
+    const timeoutMs = opts.timeoutMs ?? defaults.timeoutMs;
+    const pollMs = opts.pollMs ?? defaults.pollMs;
     const deadline = Date.now() + timeoutMs;
     while (!tryAcquire(lockPath)) {
         if (Date.now() >= deadline)
             throw new WriterLockTimeout(lockPath, readHolderPid(lockPath));
         sleepSync(pollMs);
     }
+}
+function release(lockPath) {
+    try {
+        if (existsSync(lockPath))
+            unlinkSync(lockPath);
+    }
+    catch {
+        /* best-effort release */
+    }
+}
+/** Enter the lock: acquire the file at depth 0, otherwise just deepen. */
+function enter(omgbaseDir, opts) {
+    mkdirSync(omgbaseDir, { recursive: true });
+    const lockPath = lockPathOf(omgbaseDir);
+    const depth = held.get(lockPath) ?? 0;
+    if (depth === 0)
+        acquire(lockPath, opts);
+    held.set(lockPath, depth + 1);
+    return lockPath;
+}
+/** Leave the lock: shallow, and release the file when the depth reaches 0. */
+function exit(lockPath) {
+    const depth = (held.get(lockPath) ?? 1) - 1;
+    if (depth > 0) {
+        held.set(lockPath, depth);
+        return;
+    }
+    held.delete(lockPath);
+    release(lockPath);
+}
+/**
+ * Run fn while holding the workspace writer lock. Blocks (polling) until the
+ * lock is free or the timeout elapses, then releases the lock even if fn throws.
+ * Re-entrant within the process: a nested call on the same directory runs fn
+ * directly and the outermost exit releases.
+ */
+export function withWriterLock(omgbaseDir, fn, opts = {}) {
+    const lockPath = enter(omgbaseDir, opts);
     try {
         return fn();
     }
     finally {
-        try {
-            if (existsSync(lockPath))
-                unlinkSync(lockPath);
-        }
-        catch {
-            /* best-effort release */
-        }
+        exit(lockPath);
+    }
+}
+/**
+ * The async form: the lock is held until the promise `fn` returns settles (a
+ * sync `withWriterLock` around an async fn would release at the first await).
+ * Acquisition still polls synchronously — the wait is the same bounded
+ * contention window as the sync form's. Same re-entrancy.
+ */
+export async function withWriterLockAsync(omgbaseDir, fn, opts = {}) {
+    const lockPath = enter(omgbaseDir, opts);
+    try {
+        return await fn();
     }
+    finally {
+        exit(lockPath);
+    }
+}
+/** True while THIS process holds the lock (at any depth) — a test seam for "ran under the lock". */
+export function writerLockHeld(omgbaseDir) {
+    return (held.get(lockPathOf(omgbaseDir)) ?? 0) > 0;
 }
 /** True if no live writer holds the lock (probe without acquiring). */
 export function writerLockFree(omgbaseDir) {

package/dist/src/version.d.ts

@@ -1,5 +1,6 @@
 import type { Store } from "./core/store/store.js";
 import { SPEC_VERSIONS } from "./spec-versions.js";
+import type { ToolsProfile } from "./mcp/server.js";
 export interface HostInfo {
     /** the serving binary's own version — `omgbase`'s package.json (what `--version` prints) */
     version: string;
@@ -25,6 +26,8 @@ export interface VersionInfo {
     runtime: string;
     commit: string | null;
     built: string | null;
+    /** the catalog profile the server serves (spec/surface §4 "Profiles", 4.3): `omg version` itself reports `full` */
+    profile: ToolsProfile;
 }
 /** The omgbase packages the reference binary is built from (spec/surface §4). */
 export declare const COMPONENT_PACKAGES: readonly ["omgbase", "@omgbase/core", "@omgbase/oqx", "@omgbase/sync", "@omgbase/fs-adapter"];
@@ -34,6 +37,8 @@ export declare function nearestPackageVersion(fromUrl: string, name: string): st
 export declare function coreVersion(): string;
 /**
  * The `version` result. `store` supplies `schema`; `host` the binary's own
- * version, build info and resolution anchor (see the module comment).
+ * version, build info and resolution anchor (see the module comment);
+ * `profile` the catalog profile served (the MCP server's `--tools`; the CLI's
+ * own `version` verb is the full library and says `full`).
  */
-export declare function versionInfo(store?: Store | null, host?: HostInfo): VersionInfo;
+export declare function versionInfo(store?: Store | null, host?: HostInfo, profile?: ToolsProfile): VersionInfo;

package/dist/src/version.js

@@ -73,9 +73,11 @@ export function coreVersion() {
 }
 /**
  * The `version` result. `store` supplies `schema`; `host` the binary's own
- * version, build info and resolution anchor (see the module comment).
+ * version, build info and resolution anchor (see the module comment);
+ * `profile` the catalog profile served (the MCP server's `--tools`; the CLI's
+ * own `version` verb is the full library and says `full`).
  */
-export function versionInfo(store, host) {
+export function versionInfo(store, host, profile = "full") {
     const anchors = [...(host?.resolveFrom ? [host.resolveFrom] : []), import.meta.url];
     const components = {};
     for (const name of COMPONENT_PACKAGES) {
@@ -98,6 +100,7 @@ export function versionInfo(store, host) {
         runtime: `node ${process.versions.node}`,
         commit: host?.commit ?? null,
         built: host?.built ?? null,
+        profile,
     };
 }
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omgbase/core",
-  "version": "0.11.1",
+  "version": "0.19.0",
   "description": "Open Markdown Graph Base — embedded engine",
   "license": "MIT",
   "repository": {
@@ -55,7 +55,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.30.0",
-    "@omgbase/oqx": "^0.20.0",
+    "@omgbase/oqx": "^0.21.0",
     "better-sqlite3": "^13.0.3",
     "mdast-util-from-markdown": "^2.0.2",
     "mdast-util-frontmatter": "^2.0.1",