omgbase 0.11.0 → 0.13.0

package/dist/build-info.json

@@ -1,4 +1,4 @@
 {
-  "commit": "0145153",
-  "built": "2026-10-12T05:05:42.833Z"
+  "commit": "48b355b",
+  "built": "2026-10-12T21:39:26.285Z"
 }

package/dist/src/cmd/_mutate.d.ts

@@ -1,4 +1,4 @@
-import { type Op } from "@omgbase/core";
+import { type EffectTarget, type Plan, type Receipt, type Sugar } from "@omgbase/core";
 import type { Cli } from "../context.js";
 import type { RepoRow } from "@omgbase/core";
 import type { Workspace } from "@omgbase/core";
@@ -25,30 +25,65 @@ export declare function readStdin(): string;
 export declare function readIdsFromStdin(): string[];
 /** Expand a block-list argument list, substituting stdin ids for a bare "-". */
 export declare function expandBlockArgs(args: string[]): string[];
-export interface RunOpsOptions {
+export declare function defaultActor(): string;
+export interface RunOpts {
     reason?: string;
     actor?: string;
 }
 /**
- * Apply a set of kernel ops as one changeset and render the outcome. Honors
- * cli.flags.dryRun (per-file unified diffs to stdout, nothing committed) and
- * cli.flags.mode (--json emits ApplyResult verbatim). Typed conflicts are
- * rendered by the caller's catch via the output contract; we let apply throw.
+ * Run a builder's effects as one request (`applySugar`: plan + execute under the
+ * writer flock, the sugar's reason unless `--reason` overrides it) and render the
+ * outcome. Honors cli.flags.dryRun — the Plan: per-file unified diffs to stdout,
+ * nothing minted, nothing committed (§3.6) — and cli.flags.mode (--json emits
+ * the Receipt, or the Plan on a dry run, verbatim). An empty effect list is
+ * `  nothing to do`.
  */
-export declare function runOps(cli: Cli, ws: Workspace, repo: RepoRow, ops: Op[], opts?: RunOpsOptions): number;
+export declare function runSugar(cli: Cli, ws: Workspace, repo: RepoRow, sugar: Sugar, opts?: RunOpts): number;
 /**
- * Remote peer of runOps: call the changeset-producing tool that mirrors this
- * command (blocks_insert, blocks_check, …) against the `--server` engine — the
- * server resolves refs + pins CAS + applies — then render the returned
- * ApplyResult with the SAME renderers as local. --dry-run is threaded as the
- * tool's dry_run so the preview comes back without committing.
+ * Remote peer of runSugar: call the sugar tool that mirrors this command
+ * (blocks_insert, blocks_check, …) against the `--server` engine — the server
+ * resolves refs + pins CAS + applies — and render the returned Receipt with the
+ * SAME renderers as local. The global --dry-run is the `plan` tool over the
+ * effects the verb would build (`effects` composes them from the refs as given:
+ * an id names its row, anything else a document path — the server resolves);
+ * no tool takes `dry_run` since surface 4.0.
  */
-export declare function runOpsRemote(cli: Cli, tool: string, toolArgs: Record<string, unknown>): Promise<number>;
+export declare function runSugarRemote(cli: Cli, tool: string, toolArgs: Record<string, unknown>, effects: () => unknown[] | Promise<unknown[]>): Promise<number>;
+/** A ref as an effect target for a remote `plan`: a `b_` id is the block, a `d_` id the document, anything else a document path. */
+export declare function targetOf(ref: string): EffectTarget;
+/**
+ * `apply` given `{ effects }`: plan + execute as one transaction
+ * (`applyEffects`, spec/mutate §11.7) under the writer flock, rendered as a
+ * Receipt. `--dry-run` plans only and renders the Plan (§3.6: planning runs
+ * under the symbolic minter and the ids it reports are `$new.n`). An empty
+ * list is `nothing to do`.
+ */
+export declare function runEffects(cli: Cli, ws: Workspace, repo: RepoRow, effects: unknown[], opts?: RunOpts): number;
+/** Remote peer of `runEffects`: the `apply` tool with `effects` (the Receipt), or on a dry run the `plan` tool (the Plan). */
+export declare function runEffectsRemote(cli: Cli, effects: unknown[], reason?: string): Promise<number>;
+/** `execute`: commit exactly a Plan (the plan form, spec/mutate §11.7 — admission, then the one transaction), rendered as a Receipt. */
+export declare function runExecutePlan(cli: Cli, ws: Workspace, repo: RepoRow, plan: unknown, opts?: RunOpts): number;
+/** Remote peer of `runExecutePlan`: the `execute` tool's plan form. */
+export declare function runExecutePlanRemote(cli: Cli, plan: unknown, reason?: string): Promise<number>;
+/** A Plan, dry-run style: `--json` the Plan verbatim (what `execute` takes back); human the §3.6 note and the per-file diffs of its preview. */
+export declare function renderPlan(cli: Cli, plan: Plan): number;
+/**
+ * A Receipt (any write tool's result since 4.0 — a `links_*` result carries its
+ * `hits`/`pairs` beside the receipt's keys): `--json` verbatim; human the
+ * commit confirmation of §4 (one revision per touched document) and, on
+ * stdout, the ids the write names — the plan's `preview.results[].ids` with
+ * every `$new.n` realized from `new_ids` when the plan is at hand with its
+ * preview (a local write, any `execute`); else (a plan echoed without
+ * `preview`, a remote write) every id the plan minted, the `new_ids` values in
+ * order — which includes the discarded mints of a re-parse (`spec/mutate` §10),
+ * ids that name no row.
+ */
+export declare function renderReceipt(cli: Cli, receipt: Receipt, plan?: unknown): number;
+export declare function receiptIds(receipt: Receipt, plan: unknown): string[];
 /**
  * The dry-run rendering every write verb shares (spec/cli §3.6): the note on
- * stderr, then per changed file the path, the unified diff of before → after
- * (`spec/surface` §3) and an empty line. Document verbs hand their
- * `DocOpResult.diffs` here; block verbs their `ApplyResult.diffs`.
+ * stderr, then per changed file of the Plan's `preview.diffs` the path, the
+ * unified diff of before → after (`spec/surface` §3) and an empty line.
  */
 export declare function renderDiffs(cli: Cli, diffs: Record<string, {
     before: string;

package/dist/src/cmd/_mutate.js

@@ -1,13 +1,17 @@
 import { readFileSync, readSync } from "node:fs";
 import { userInfo } from "node:os";
-import { apply, unifiedDiff, surfaceApplyResult } from "@omgbase/core";
+import { applyEffectsDetailed, applySugar, executePlan, isValidId, substituteSymbols, unifiedDiff, surfacePlan, surfaceReceipt } from "@omgbase/core";
 import { CliUsageError, EXIT_OK, EXIT_ERROR } from "../output.js";
 import { remoteCall } from "./_remote.js";
-// Shared plumbing for every write command (11 §5.6, §5.7). Sugar commands build
-// their kernel Ops, then hand them here: this sets origin.actor (human:$USER by
-// default, override --actor), runs under the writer flock (omgbaseDir), threads
-// --dry-run (validate + render diffs, commit nothing), and renders results or
-// typed conflicts uniformly.
+// Shared plumbing for every write command (spec/cli §3.6, §4; ADR-021's
+// retirement release, cli 4.0). The sugar verbs build their effects with the
+// shared builders of `@omgbase/core` (`mutate/sugar.ts` — the same table the
+// MCP tools use), then hand them here: this sets origin.actor (human:$USER by
+// default, override --actor), runs under the writer flock (omgbaseDir),
+// threads the global --dry-run as a `plan` (render the preview's diffs, mint
+// nothing, commit nothing), and renders the Receipt or the Plan uniformly.
+// Typed conflicts are rendered by the caller's catch via the output contract;
+// we let the planner throw.
 /** Read markdown content from -m, -f (file, or "-" = stdin), or bare stdin. */
 export function readContent(values, allowStdin = true) {
     if (values.m !== undefined)
@@ -108,7 +112,7 @@ export function expandBlockArgs(args) {
     }
     return out;
 }
-function defaultActor() {
+export function defaultActor() {
     try {
         return `human:${userInfo().username}`;
     }
@@ -117,61 +121,149 @@ function defaultActor() {
     }
 }
 /**
- * Apply a set of kernel ops as one changeset and render the outcome. Honors
- * cli.flags.dryRun (per-file unified diffs to stdout, nothing committed) and
- * cli.flags.mode (--json emits ApplyResult verbatim). Typed conflicts are
- * rendered by the caller's catch via the output contract; we let apply throw.
+ * Run a builder's effects as one request (`applySugar`: plan + execute under the
+ * writer flock, the sugar's reason unless `--reason` overrides it) and render the
+ * outcome. Honors cli.flags.dryRun — the Plan: per-file unified diffs to stdout,
+ * nothing minted, nothing committed (§3.6) — and cli.flags.mode (--json emits
+ * the Receipt, or the Plan on a dry run, verbatim). An empty effect list is
+ * `  nothing to do`.
  */
-export function runOps(cli, ws, repo, ops, opts = {}) {
-    if (ops.length === 0) {
+export function runSugar(cli, ws, repo, sugar, opts = {}) {
+    if (sugar.effects.length === 0) {
         cli.io.err(cli.style.dim("  nothing to do"));
         return EXIT_OK;
     }
-    const req = {
+    const { plan, receipt } = applySugar(ws.store, {
         repoId: repo.repoId,
         ...(repo.rootPath ? { rootPath: repo.rootPath } : {}),
-        ops,
-        origin: { actor: opts.actor ?? defaultActor(), ...(opts.reason ? { reason: opts.reason } : {}) },
         omgbaseDir: ws.omgbaseDir,
+        actor: opts.actor ?? defaultActor(),
+        ...(opts.reason ? { reason: opts.reason } : {}),
         ...(cli.flags.dryRun ? { dryRun: true } : {}),
-    };
-    // The reference form on every printed path (spec/surface §1 "Paths"): the
-    // kernel's result is re-shaped exactly as the MCP server re-shapes it.
-    const result = surfaceApplyResult(apply(ws.store, req));
-    return renderApply(cli, result);
+    }, sugar);
+    if (!receipt)
+        return renderPlan(cli, surfacePlan(plan));
+    return renderReceipt(cli, surfaceReceipt(receipt), plan);
+}
+/**
+ * Remote peer of runSugar: call the sugar tool that mirrors this command
+ * (blocks_insert, blocks_check, …) against the `--server` engine — the server
+ * resolves refs + pins CAS + applies — and render the returned Receipt with the
+ * SAME renderers as local. The global --dry-run is the `plan` tool over the
+ * effects the verb would build (`effects` composes them from the refs as given:
+ * an id names its row, anything else a document path — the server resolves);
+ * no tool takes `dry_run` since surface 4.0.
+ */
+export async function runSugarRemote(cli, tool, toolArgs, effects) {
+    if (cli.flags.dryRun)
+        return renderPlan(cli, await remoteCall(cli, "plan", { effects: await effects() }));
+    return renderReceipt(cli, await remoteCall(cli, tool, toolArgs));
+}
+/** A ref as an effect target for a remote `plan`: a `b_` id is the block, a `d_` id the document, anything else a document path. */
+export function targetOf(ref) {
+    if (isValidId(ref, "b"))
+        return { kind: "block", id: ref };
+    if (isValidId(ref, "d"))
+        return { kind: "document", id: ref };
+    return { kind: "document", path: ref };
 }
+// ---- the Effect layer (ADR-021; spec/cli 3.2 `apply -f { effects }`, `execute`) ----
 /**
- * Remote peer of runOps: call the changeset-producing tool that mirrors this
- * command (blocks_insert, blocks_check, …) against the `--server` engine — the
- * server resolves refs + pins CAS + applies — then render the returned
- * ApplyResult with the SAME renderers as local. --dry-run is threaded as the
- * tool's dry_run so the preview comes back without committing.
+ * `apply` given `{ effects }`: plan + execute as one transaction
+ * (`applyEffects`, spec/mutate §11.7) under the writer flock, rendered as a
+ * Receipt. `--dry-run` plans only and renders the Plan (§3.6: planning runs
+ * under the symbolic minter and the ids it reports are `$new.n`). An empty
+ * list is `nothing to do`.
  */
-export async function runOpsRemote(cli, tool, toolArgs) {
-    const result = await remoteCall(cli, tool, {
-        ...toolArgs,
-        ...(cli.flags.dryRun ? { dry_run: true } : {}),
+export function runEffects(cli, ws, repo, effects, opts = {}) {
+    if (effects.length === 0) {
+        cli.io.err(cli.style.dim("  nothing to do"));
+        return EXIT_OK;
+    }
+    const req = {
+        repoId: repo.repoId,
+        ...(repo.rootPath ? { rootPath: repo.rootPath } : {}),
+        effects,
+        origin: { actor: opts.actor ?? defaultActor(), ...(opts.reason ? { reason: opts.reason } : {}) },
+        omgbaseDir: ws.omgbaseDir,
+    };
+    const { plan, receipt } = applyEffectsDetailed(ws.store, { ...req, ...(cli.flags.dryRun ? { dryRun: true } : {}) });
+    if (!receipt)
+        return renderPlan(cli, surfacePlan(plan));
+    return renderReceipt(cli, surfaceReceipt(receipt), plan);
+}
+/** Remote peer of `runEffects`: the `apply` tool with `effects` (the Receipt), or on a dry run the `plan` tool (the Plan). */
+export async function runEffectsRemote(cli, effects, reason) {
+    if (cli.flags.dryRun)
+        return renderPlan(cli, await remoteCall(cli, "plan", { effects }));
+    return renderReceipt(cli, await remoteCall(cli, "apply", { effects, ...(reason ? { reason } : {}) }));
+}
+/** `execute`: commit exactly a Plan (the plan form, spec/mutate §11.7 — admission, then the one transaction), rendered as a Receipt. */
+export function runExecutePlan(cli, ws, repo, plan, opts = {}) {
+    const receipt = executePlan(ws.store, {
+        repoId: repo.repoId,
+        ...(repo.rootPath ? { rootPath: repo.rootPath } : {}),
+        plan,
+        origin: { actor: opts.actor ?? defaultActor(), ...(opts.reason ? { reason: opts.reason } : {}) },
+        omgbaseDir: ws.omgbaseDir,
     });
-    return renderApply(cli, result);
+    return renderReceipt(cli, surfaceReceipt(receipt), plan);
 }
-/** Capture + render an ApplyResult (shared by the local and remote paths). */
-function renderApply(cli, result) {
-    cli.capture?.(result); // shell: ApplyResult — its minted/affected ids are the frame
+/** Remote peer of `runExecutePlan`: the `execute` tool's plan form. */
+export async function runExecutePlanRemote(cli, plan, reason) {
+    return renderReceipt(cli, await remoteCall(cli, "execute", { plan, ...(reason ? { reason } : {}) }), plan);
+}
+/** A Plan, dry-run style: `--json` the Plan verbatim (what `execute` takes back); human the §3.6 note and the per-file diffs of its preview. */
+export function renderPlan(cli, plan) {
+    cli.capture?.(plan);
     if (cli.flags.mode !== "human") {
-        cli.io.out(JSON.stringify(result));
+        cli.io.out(JSON.stringify(plan));
         return EXIT_OK;
     }
-    return cli.flags.dryRun ? renderDryRun(cli, result) : renderCommitted(cli, result);
+    renderDiffs(cli, plan.preview?.diffs ?? {});
+    return EXIT_OK;
 }
-function renderDryRun(cli, result) {
-    renderDiffs(cli, result.diffs ?? {});
+/**
+ * A Receipt (any write tool's result since 4.0 — a `links_*` result carries its
+ * `hits`/`pairs` beside the receipt's keys): `--json` verbatim; human the
+ * commit confirmation of §4 (one revision per touched document) and, on
+ * stdout, the ids the write names — the plan's `preview.results[].ids` with
+ * every `$new.n` realized from `new_ids` when the plan is at hand with its
+ * preview (a local write, any `execute`); else (a plan echoed without
+ * `preview`, a remote write) every id the plan minted, the `new_ids` values in
+ * order — which includes the discarded mints of a re-parse (`spec/mutate` §10),
+ * ids that name no row.
+ */
+export function renderReceipt(cli, receipt, plan) {
+    const ids = receiptIds(receipt, plan);
+    cli.capture?.({ ...receipt, ids }); // shell: the ids the write names are the frame
+    if (cli.flags.mode !== "human") {
+        cli.io.out(JSON.stringify(receipt));
+        return EXIT_OK;
+    }
+    const { render, style, io } = cli;
+    const n = receipt.revisions.length;
+    io.err(style.dim(`  ${style.ok(render.g.ok)} committed · ${n} document${n === 1 ? "" : "s"} touched`));
+    for (const id of ids)
+        io.out(id);
     return EXIT_OK;
 }
+export function receiptIds(receipt, plan) {
+    const results = plan?.preview?.results;
+    if (!Array.isArray(results))
+        return Object.values(receipt.new_ids);
+    const ids = [];
+    for (const r of results)
+        if (Array.isArray(r.ids))
+            for (const id of r.ids)
+                if (typeof id === "string")
+                    ids.push(id);
+    return substituteSymbols(ids, receipt.new_ids);
+}
 /**
  * The dry-run rendering every write verb shares (spec/cli §3.6): the note on
- * stderr, then per changed file the path, the unified diff of before → after
- * (`spec/surface` §3) and an empty line. Document verbs hand their
- * `DocOpResult.diffs` here; block verbs their `ApplyResult.diffs`.
+ * stderr, then per changed file of the Plan's `preview.diffs` the path, the
+ * unified diff of before → after (`spec/surface` §3) and an empty line.
  */
 export function renderDiffs(cli, diffs) {
     const { style, io } = cli;
@@ -194,16 +286,5 @@ export function unifiedDiffLines(cli, before, after) {
         return style.dim(line);
     });
 }
-function renderCommitted(cli, result) {
-    const { render, style, io } = cli;
-    const g = render.g;
-    const n = result.revisions.length;
-    io.err(style.dim(`  ${style.ok(g.ok)} committed · ${n} document${n === 1 ? "" : "s"} touched`));
-    // stdout stays useful for pipes: the ids minted/affected, one per line.
-    const ids = result.results.flatMap((r) => r.ids);
-    for (const id of ids)
-        io.out(id);
-    return EXIT_OK;
-}
 export { EXIT_OK, EXIT_ERROR };
 //# sourceMappingURL=_mutate.js.map

package/dist/src/cmd/edit.js

@@ -3,13 +3,14 @@ import { spawnSync } from "node:child_process";
 import { writeFileSync, readFileSync, mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { resolveRef, nodesGet } from "@omgbase/core";
+import { resolveRef, nodesGet, updateBlockEffects } from "@omgbase/core";
 import { CliUsageError, EngineErrorLike, EXIT_OK, renderHelp } from "../output.js";
-import { runOps } from "./_mutate.js";
+import { runSugar } from "./_mutate.js";
 // `omg edit <block>` (11 §5.6, §5.7): read the block's raw markdown → open it in
-// $EDITOR → update with the PRE-READ hash pinned as CAS. A mid-edit change by
-// someone else lands as a clean stale_expectation (with current truth), never a
-// lost write. The human structural-edit loop.
+// $EDITOR → `set markdown` with the PRE-READ hash pinned as `expect.content_hash`
+// (the `blocks_update` builder; cli 4.0). A mid-edit change by someone else
+// lands as a clean stale_expectation (with current truth), never a lost write.
+// The human structural-edit loop.
 function rawHashOf(ws, blockId) {
     const row = ws.store.db
         .prepare("SELECT lower(hex(raw_hash)) h FROM blocks WHERE block_id = ? AND deleted_commit IS NULL")
@@ -63,8 +64,7 @@ function runEdit(cli, args) {
             cli.io.err(cli.style.dim("  no changes"));
             return EXIT_OK;
         }
-        const op = { op: "update", block: blockId, markdown: after, ...(preHash ? { expect: { content_hash: preHash } } : {}) };
-        return runOps(cli, ws, repo, [op], values.actor ? { actor: values.actor } : {});
+        return runSugar(cli, ws, repo, updateBlockEffects(blockId, { markdown: after, ...(preHash ? { expect: { content_hash: preHash } } : {}) }), values.actor ? { actor: values.actor } : {});
     }
     finally {
         rmSync(dir, { recursive: true, force: true });

package/dist/src/cmd/help.js

@@ -7,7 +7,7 @@ const GROUPS = [
     { title: "orient & read", names: ["status", "ls", "outline", "cat", "show", "find"] },
     { title: "query", names: ["query", "run"] },
     { title: "history & links", names: ["log", "hist", "diff", "links"] },
-    { title: "mutate", names: ["apply", "insert", "update", "edit", "move", "rm", "done", "append", "retarget", "split", "merge", "node"] },
+    { title: "mutate", names: ["apply", "execute", "insert", "update", "edit", "move", "rm", "done", "append", "retarget", "split", "merge", "node"] },
     { title: "documents", names: ["new", "mv", "meta"] },
     { title: "session", names: ["shell"] },
     { title: "sync & serve", names: ["sync", "mcp"] },

package/dist/src/cmd/mcp.js

@@ -1,7 +1,7 @@
 import { parseArgs } from "node:util";
-import { serveStdio, Watcher, WatchLease, watchLeaseLive, freshnessSweep, awaitReady, WATCH_READY_PATIENCE_MS, EmbedDrainer, EngineError } from "@omgbase/core";
+import { serveStdio, Watcher, WatchLease, watchLeaseLive, freshnessSweep, withWriterLock, awaitReady, WATCH_READY_PATIENCE_MS, EmbedDrainer, EngineError } from "@omgbase/core";
 import { EngineErrorLike, EXIT_OK, renderHelp } from "../output.js";
-import { installSpecSeams } from "../seams.js";
+import { installSpecSeams, WRITER_LOCK_TIMEOUT_ENV } from "../seams.js";
 import { loadEmbedding } from "./_embed.js";
 import { openRepoSource } from "./_source.js";
 import { hostInfo } from "../build.js";
@@ -26,6 +26,9 @@ function announceSpecSeams(cli) {
     if (seams.clock !== null) {
         cli.io.err(cli.style.dim(`[mcp] spec seam: clock pinned to ${seams.clock} (OMGBASE_SPEC_CLOCK) — conformance run, not for production`));
     }
+    if (seams.writerLockTimeoutMs !== null) {
+        cli.io.err(cli.style.dim(`[mcp] test seam: writer lock waits ${seams.writerLockTimeoutMs} ms (${WRITER_LOCK_TIMEOUT_ENV}) — not for production`));
+    }
 }
 async function runMcp(cli, args) {
     const { values } = parseArgs({
@@ -115,7 +118,11 @@ async function runMcp(cli, args) {
             // is primed is caught by the sweep, one after it by the feed.
             source = await openRepoSource(ws.store, repo);
             if (source) {
+                // Every checkpoint and the priming sweep run under the workspace writer
+                // lock (spec/sync §7), as the Rust watcher's do: a verb in another
+                // process waits for the ingest instead of racing its file-CAS.
                 watcher = new Watcher(ws.store, repo.repoId, source, {
+                    omgbaseDir: ws.omgbaseDir,
                     onCheckpoint: (r) => {
                         if (r.ingested.length > 0 || r.deleted.length > 0) {
                             cli.io.err(cli.style.dim(`[watch] checkpoint: +${r.ingested.length} -${r.deleted.length}`));
@@ -129,8 +136,9 @@ async function runMcp(cli, args) {
                 if (!(await awaitReady(watcher.ready(), WATCH_READY_PATIENCE_MS))) {
                     cli.io.err(cli.style.dim(`[watch] the fs adapter did not report ready within ${WATCH_READY_PATIENCE_MS / 1000}s — proceeding as if ready`));
                 }
-                if (repo.rootPath)
-                    freshnessSweep(ws.store, repo.repoId, repo.rootPath); // prime: anything that landed before the feed was ready
+                const root = repo.rootPath;
+                if (root)
+                    withWriterLock(ws.omgbaseDir, () => freshnessSweep(ws.store, repo.repoId, root)); // prime: anything that landed before the feed was ready
                 cli.io.err(cli.style.dim(`[mcp] serving ${repo.slug} on stdio · watcher live`));
             }
             else {
@@ -161,9 +169,13 @@ async function runMcp(cli, args) {
         : failed
             ? (_text) => Promise.reject(failed)
             : undefined;
+    // The workspace dir makes every write tool take the writer lock for its whole
+    // call (spec/sync §7) — `omg` verbs, the Rust `omgbase mcp` and the watcher
+    // all lock the same file, so the server must too.
     const handle = await serveStdio({
         store: ws.store,
         repoId: repo.repoId,
+        omgbaseDir: ws.omgbaseDir,
         ...(repo.rootPath ? { rootPath: repo.rootPath } : {}),
         ...(drainer ? { onMutation: () => drainer.schedule() } : {}),
         ...(embedQuery ? { embedQuery } : {}),

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

@@ -1,5 +1,6 @@
 import type { Command } from "../commands.js";
 export declare const cmdApply: Command;
+export declare const cmdExecute: Command;
 export declare const cmdInsert: Command;
 export declare const cmdUpdate: Command;
 export declare const cmdMove: Command;