@dinoxx/dinox-cli 1.0.19 → 1.0.21

package/dist/commands/runtime.js

@@ -0,0 +1,76 @@
+import { hydrateResolvedAuthIdentity } from '../auth/userInfo.js';
+import { loadConfig } from '../config/store.js';
+import { resolveConfig } from '../config/resolve.js';
+import { connectPowerSync, waitForIdleDataFlow } from '../powersync/runtime.js';
+import { syncNoteTokenIndex } from '../powersync/tokenIndex.js';
+import { printHumanReadableLine } from '../utils/output.js';
+import { parseSyncTimeoutMs } from '../utils/syncTimeout.js';
+const PRE_SYNC_TIMEOUT_MS = 10_000;
+const POST_WRITE_IDLE_TIMEOUT_MS = 5_000;
+function isCommandExecutionContext(source) {
+    return typeof source === 'object' && source !== null && 'globals' in source;
+}
+function isCommanderCommand(source) {
+    return typeof source.optsWithGlobals === 'function';
+}
+function resolveGlobals(source) {
+    if (isCommandExecutionContext(source)) {
+        return source.globals;
+    }
+    if (isCommanderCommand(source)) {
+        return (source.optsWithGlobals?.() ?? {});
+    }
+    return source;
+}
+export function commandStale(runtime) {
+    return runtime.offline ? true : runtime.stale;
+}
+export async function withCommandRuntime(source, run) {
+    const globals = resolveGlobals(source);
+    const rawConfig = await loadConfig();
+    const baseConfig = resolveConfig(rawConfig);
+    const timeoutMs = parseSyncTimeoutMs(globals.syncTimeout) ?? baseConfig.sync.timeoutMs;
+    const offline = Boolean(globals.offline);
+    const { config } = offline
+        ? { config: baseConfig }
+        : await hydrateResolvedAuthIdentity(baseConfig, { timeoutMs });
+    const { db, stale } = await connectPowerSync({ config, offline, timeoutMs });
+    try {
+        return await run({
+            db,
+            config,
+            rawConfig,
+            offline,
+            timeoutMs,
+            stale,
+        });
+    }
+    finally {
+        await db.close().catch(() => undefined);
+    }
+}
+export async function syncBeforeCommand(runtime, options = {}) {
+    if (runtime.offline) {
+        return;
+    }
+    await waitForIdleDataFlow(runtime.db, Math.min(runtime.timeoutMs, options.timeoutMs ?? PRE_SYNC_TIMEOUT_MS));
+    if (options.syncTokenIndex) {
+        await syncNoteTokenIndex(runtime.db);
+    }
+}
+export async function waitForMutationUpload(runtime, options = {}) {
+    if (runtime.offline) {
+        return;
+    }
+    await waitForIdleDataFlow(runtime.db, Math.min(runtime.timeoutMs, options.timeoutMs ?? POST_WRITE_IDLE_TIMEOUT_MS));
+}
+export function printUploadDisabledWarning(runtime, message = 'warning: upload disabled (powersync.uploadBaseUrl is unset); changes are local-only for now') {
+    if (!runtime.offline && !runtime.config.powersync.uploadBaseUrl) {
+        printHumanReadableLine(message);
+    }
+}
+export function printStaleCacheWarning(runtime, message = 'warning: sync timed out; local cache may be stale') {
+    if (runtime.stale && !runtime.offline) {
+        printHumanReadableLine(message);
+    }
+}

package/dist/commands/schema/renderSkills.js

@@ -3,13 +3,14 @@ import path from 'node:path';
 import { listCommandSchemas } from './spec.js';
 const SECTION_ORDER = [
     { title: 'Auth', paths: ['auth.login', 'auth.logout', 'auth.status'] },
+    { title: 'Daemon', paths: ['daemon.start', 'daemon.status', 'daemon.restart', 'daemon.stop'] },
     { title: 'Sync', paths: ['sync'] },
     { title: 'Schema', paths: ['schema'] },
     { title: 'Update CLI', paths: ['update'] },
-    { title: 'Notes', paths: ['note.search', 'note.get', 'note.preview', 'note.detail', 'note.create', 'note.update', 'note.star', 'note.unstar', 'note.delete'] },
+    { title: 'Notes', paths: ['note.search', 'note.get', 'note.preview', 'note.detail', 'note.export', 'note.content-read', 'note.create', 'note.update', 'note.tag', 'note.move', 'note.patch', 'note.bulk', 'note.star', 'note.unstar', 'note.delete'] },
     { title: 'Todo', paths: ['todo.search', 'todo.append', 'todo.create', 'todo.update'] },
-    { title: 'Tags', paths: ['tag.list', 'tag.add'] },
-    { title: 'Card Boxes (Zettel Boxes)', paths: ['box.list', 'box.add'] },
+    { title: 'Tags', paths: ['tag.list', 'tag.tree', 'tag.stats', 'tag.add', 'tag.rename', 'tag.move', 'tag.merge', 'tag.suggest', 'tag.cleanup'] },
+    { title: 'Card Boxes (Zettel Boxes)', paths: ['box.list', 'box.add', 'box.tree', 'box.stats', 'box.rename', 'box.move', 'box.merge', 'box.cleanup'] },
     { title: 'Prompts', paths: ['prompt.list', 'prompt.add'] },
     { title: 'Storage', paths: ['storage.list', 'storage.test', 'storage.upload', 'storage.stats'] },
     { title: 'Config', paths: ['config.get', 'config.set'] },
@@ -52,18 +53,23 @@ const GENERATED_COMMAND_SECTIONS = {
     },
     'skill:dino-manage-tags': {
         title: 'Command Reference',
-        paths: ['tag.list', 'tag.add'],
+        paths: ['tag.list', 'tag.tree', 'tag.stats', 'tag.add', 'tag.rename', 'tag.move', 'tag.merge', 'tag.suggest', 'tag.cleanup'],
         intro: 'Use these commands as the canonical Dinox CLI interface for tag management.',
         notes: [
             'For writes, run the same command with `--dry-run` first.',
+            '`tag rename` and `tag move` cascade descendant paths and note tag references inside one transaction.',
+            '`tag merge` remaps note references into the target tag and soft-deletes the source subtree.',
+            'Inline `hashtag` nodes keep `attrs.id` as `c_tag_node.id`; `attrs.label` stores the canonical path.',
         ],
     },
     'skill:dino-manage-boxes': {
         title: 'Command Reference',
-        paths: ['box.list', 'box.add'],
+        paths: ['box.list', 'box.add', 'box.tree', 'box.stats', 'box.rename', 'box.move', 'box.merge', 'box.cleanup'],
         intro: 'Use these commands as the canonical Dinox CLI interface for box management.',
         notes: [
             'For writes, run the same command with `--dry-run` first.',
+            '`box rename` and `box move` cascade descendant paths inside one transaction.',
+            '`box merge` remaps note references into the target box and soft-deletes the source subtree.',
         ],
     },
     'skill:dino-storage': {
@@ -77,11 +83,13 @@ const GENERATED_COMMAND_SECTIONS = {
     },
     'ref:dino-note:search-and-read': {
         title: 'Command Surface',
-        paths: ['note.search', 'note.get', 'note.preview', 'note.detail'],
+        paths: ['note.search', 'note.get', 'note.preview', 'note.detail', 'note.export', 'note.content-read'],
         intro: 'Use these generated commands as the canonical interfaces for note search and read workflows.',
         notes: [
             'Use `--boxes` for public box filters.',
             'Prefer `--fields id,title,summary,tags,created_at,boxes,is_starred` when the user only needs search metadata.',
+            'Use `note export` for backup or migration; Markdown exports include frontmatter, JSON exports preserve note metadata and content JSON.',
+            'Use `note content-read` immediately before `note patch`; the returned readToken, content hash, block index, outline, and resolved hashtag paths are the required edit context.',
             '`--sql` remains storage-oriented and still uses the field name `zettel_boxes`.',
         ],
     },
@@ -97,10 +105,15 @@ const GENERATED_COMMAND_SECTIONS = {
     },
     'ref:dino-note:update-and-delete': {
         title: 'Command Surface',
-        paths: ['note.update', 'note.star', 'note.unstar', 'note.delete'],
+        paths: ['note.update', 'note.tag', 'note.move', 'note.patch', 'note.bulk', 'note.star', 'note.unstar', 'note.delete'],
         intro: 'Use these generated commands as the canonical interfaces for note mutation workflows.',
         notes: [
             '`--tags` and `--boxes` are full-replacement inputs.',
+            '`note update` is for explicit note ids and full metadata replacement. It is not an append command.',
+            '`note tag` and `note move` are explicit-id incremental organizers: add/remove preserves existing values, replace overwrites the whole list.',
+            '`note move` changes zettel box membership only; it does not move files or note content.',
+            '`note patch` is only for structured content edits. Run `note content-read` immediately before it, pass `--read-token` for real writes, and use `--allow-protected-replace` only after reviewing protected blocks.',
+            '`note bulk` is for filter-based batch metadata organization; it never accepts `--sql`, and real writes require `--confirm --expected-count <n>`.',
             'Prefer `note star` / `note unstar` for pure starring changes, and `note update` when multiple fields change together.',
             'Run the same command with `--dry-run --format json` first.',
         ],

package/dist/commands/schema/spec.d.ts

@@ -1,6 +1,5 @@
 import type { CommandSchema } from './types.js';
-export type { CommandSchema, CommandSchemaAuth, CommandSchemaMcp, CommandSchemaMcpProperty, CommandSchemaOutput, CommandSchemaRisk, } from './types.js';
+export type { CommandSchema, CommandSchemaAuth, CommandSchemaOutput, CommandSchemaRisk, } from './types.js';
 export declare const COMMAND_SCHEMAS: CommandSchema[];
 export declare function listCommandSchemas(): CommandSchema[];
 export declare function findCommandSchema(path: string): CommandSchema | null;
-export declare function listMcpCommandSchemas(): CommandSchema[];

package/dist/commands/schema/spec.js

@@ -3,6 +3,7 @@ import { boxCommandGroup } from '../boxes/index.js';
 import { commandSchemasFromGroupDescriptor } from '../descriptor/register.js';
 import { standaloneCommandSchemaFromDescriptor } from '../descriptor/register.js';
 import { configCommandGroup } from '../config/index.js';
+import { daemonCommandGroup } from '../../daemon/index.js';
 import { graphCommandGroup } from '../graph/index.js';
 import { infoCommandDescriptor } from '../info/index.js';
 import { noteCommandGroup } from '../notes/index.js';
@@ -16,6 +17,7 @@ import { updateCommandDescriptor } from '../update.js';
 export const COMMAND_SCHEMAS = [
     ...commandSchemasFromGroupDescriptor(authCommandGroup),
     ...commandSchemasFromGroupDescriptor(configCommandGroup),
+    ...commandSchemasFromGroupDescriptor(daemonCommandGroup),
     standaloneCommandSchemaFromDescriptor(syncCommandDescriptor),
     standaloneCommandSchemaFromDescriptor({ ...schemaCommandMetadata, action: async () => undefined }),
     standaloneCommandSchemaFromDescriptor(infoCommandDescriptor),
@@ -35,6 +37,3 @@ export function listCommandSchemas() {
 export function findCommandSchema(path) {
     return COMMAND_SCHEMA_MAP.get(path) ?? null;
 }
-export function listMcpCommandSchemas() {
-    return COMMAND_SCHEMAS.filter((schema) => schema.mcp);
-}

package/dist/commands/schema/types.d.ts

@@ -20,18 +20,6 @@ export type CommandSchemaOutput = {
     fields?: string[];
     metaFields?: string[];
 };
-export type CommandSchemaMcpProperty = {
-    name: string;
-    type: 'string' | 'number' | 'boolean' | 'string[]';
-    description: string;
-    required?: boolean;
-    enum?: string[];
-};
-export type CommandSchemaMcp = {
-    toolName: string;
-    description: string;
-    properties: CommandSchemaMcpProperty[];
-};
 export type CommandSchema = {
     path: string;
     command: string;
@@ -42,6 +30,5 @@ export type CommandSchema = {
     arguments?: CommandSchemaArgument[];
     options?: CommandSchemaOption[];
     output: CommandSchemaOutput;
-    mcp?: CommandSchemaMcp;
     examples: string[];
 };

package/dist/commands/storage/index.js

@@ -1,42 +1,20 @@
 import { resolveAuthIdentity } from '../../auth/userInfo.js';
-import { loadConfig } from '../../config/store.js';
-import { resolveConfig } from '../../config/resolve.js';
-import { connectPowerSync, waitForIdleDataFlow } from '../../powersync/runtime.js';
 import { registerCommandGroup } from '../descriptor/register.js';
 import { FORMAT_OPTIONS, OFFLINE_OPTIONS, SYNC_TIMEOUT_OPTIONS } from '../schema/globalOptions.js';
 import { buildStorageTestDryRunPreview, buildStorageUploadDryRunPreview } from '../writeDryRun.js';
 import { printDryRunPreview } from '../../utils/dryRun.js';
 import { DinoxError } from '../../utils/errors.js';
 import { getRequestedStructuredOutputFormat, printHumanReadableLine, printSuccess, } from '../../utils/output.js';
-import { parseSyncTimeoutMs } from '../../utils/syncTimeout.js';
+import { commandStale, printStaleCacheWarning, printUploadDisabledWarning, syncBeforeCommand, waitForMutationUpload, withCommandRuntime, } from '../runtime.js';
 import { getStorageStats, inspectStorageTest, inspectStorageUpload, listStorageConfigs, parseStorageUploadCategory, testStorageUpload, uploadFileToStorage, } from './repo.js';
 const STORAGE_GLOBAL_OPTIONS = [...FORMAT_OPTIONS, ...OFFLINE_OPTIONS, ...SYNC_TIMEOUT_OPTIONS];
-async function syncBeforeStorageCommand(db, offline, timeoutMs) {
-    if (offline) {
-        return;
-    }
-    await waitForIdleDataFlow(db, Math.min(timeoutMs, 10_000));
-}
-async function withStorageDb(context, run) {
-    const rawConfig = await loadConfig();
-    const config = resolveConfig(rawConfig);
-    const timeoutMs = parseSyncTimeoutMs(context.globals.syncTimeout) ?? config.sync.timeoutMs;
-    const offline = Boolean(context.globals.offline);
-    const { db, stale } = await connectPowerSync({ config, offline, timeoutMs });
-    try {
-        await run({ db, config, rawConfig, offline, timeoutMs, stale });
-    }
-    finally {
-        await db.close().catch(() => undefined);
-    }
-}
 async function runStorageList(context) {
-    await withStorageDb(context, async ({ db, config, rawConfig, offline, timeoutMs, stale }) => {
-        const identity = await resolveAuthIdentity(rawConfig, config);
-        await syncBeforeStorageCommand(db, offline, timeoutMs);
+    await withCommandRuntime(context, async (runtime) => {
+        const identity = await resolveAuthIdentity(runtime.config);
+        await syncBeforeCommand(runtime);
         printSuccess({
-            stale: offline ? true : stale,
-            ...(await listStorageConfigs(db, identity.userId)),
+            stale: commandStale(runtime),
+            ...(await listStorageConfigs(runtime.db, identity.userId)),
         });
     });
 }
@@ -48,9 +26,10 @@ async function runStorageUpload(context) {
     const options = context.options;
     const category = parseStorageUploadCategory(options.category ?? 'files');
     const structuredOutput = getRequestedStructuredOutputFormat() !== null;
-    await withStorageDb(context, async ({ db, config, rawConfig, offline, timeoutMs, stale }) => {
-        const identity = await resolveAuthIdentity(rawConfig, config);
-        await syncBeforeStorageCommand(db, offline, timeoutMs);
+    await withCommandRuntime(context, async (runtime) => {
+        const { db } = runtime;
+        const identity = await resolveAuthIdentity(runtime.config);
+        await syncBeforeCommand(runtime);
         const plan = await inspectStorageUpload(db, {
             userId: identity.userId,
             filePath,
@@ -60,8 +39,8 @@ async function runStorageUpload(context) {
         });
         if (options.dryRun) {
             printDryRunPreview(buildStorageUploadDryRunPreview({
-                config,
-                offline,
+                config: runtime.config,
+                offline: runtime.offline,
                 filePath: plan.filePath,
                 fileName: plan.fileName,
                 sizeBytes: plan.sizeBytes,
@@ -80,15 +59,11 @@ async function runStorageUpload(context) {
             storageId: options.storageId,
             key: options.key,
         });
-        if (!offline && !config.powersync.uploadBaseUrl) {
-            printHumanReadableLine('warning: upload disabled (powersync.uploadBaseUrl is unset); resource metadata is local-only for now');
-        }
-        if (!offline) {
-            await waitForIdleDataFlow(db, Math.min(timeoutMs, 5_000));
-        }
+        printUploadDisabledWarning(runtime, 'warning: upload disabled (powersync.uploadBaseUrl is unset); resource metadata is local-only for now');
+        await waitForMutationUpload(runtime);
         const payload = {
             ok: true,
-            stale: offline ? true : stale,
+            stale: commandStale(runtime),
             ...result,
         };
         if (structuredOutput) {
@@ -104,9 +79,7 @@ async function runStorageUpload(context) {
         if (result.thumbnailUrl) {
             printHumanReadableLine(`- thumbnail: ${result.thumbnailUrl}`);
         }
-        if (stale && !offline) {
-            printHumanReadableLine('warning: sync timed out; local cache may be stale');
-        }
+        printStaleCacheWarning(runtime);
     });
 }
 function formatBytes(bytes) {
@@ -123,17 +96,18 @@ function formatBytes(bytes) {
 async function runStorageTest(context) {
     const options = context.options;
     const structuredOutput = getRequestedStructuredOutputFormat() !== null;
-    await withStorageDb(context, async ({ db, config, rawConfig, offline, timeoutMs, stale }) => {
-        const identity = await resolveAuthIdentity(rawConfig, config);
-        await syncBeforeStorageCommand(db, offline, timeoutMs);
+    await withCommandRuntime(context, async (runtime) => {
+        const { db } = runtime;
+        const identity = await resolveAuthIdentity(runtime.config);
+        await syncBeforeCommand(runtime);
         const plan = await inspectStorageTest(db, {
             userId: identity.userId,
             storageId: options.storageId,
         });
         if (options.dryRun) {
             printDryRunPreview(buildStorageTestDryRunPreview({
-                config,
-                offline,
+                config: runtime.config,
+                offline: runtime.offline,
                 storage: plan.storage,
                 storageKey: plan.storageKey,
                 storageUrl: plan.storageUrl,
@@ -148,7 +122,7 @@ async function runStorageTest(context) {
         });
         const payload = {
             ok: true,
-            stale: offline ? true : stale,
+            stale: commandStale(runtime),
             ...result,
         };
         if (structuredOutput) {
@@ -162,20 +136,18 @@ async function runStorageTest(context) {
         if (result.isPrivate) {
             printHumanReadableLine('- note: the target bucket is private; direct reads may still require signed access.');
         }
-        if (stale && !offline) {
-            printHumanReadableLine('warning: sync timed out; local cache may be stale');
-        }
+        printStaleCacheWarning(runtime);
     });
 }
 async function runStorageStats(context) {
     const structuredOutput = getRequestedStructuredOutputFormat() !== null;
-    await withStorageDb(context, async ({ db, config, rawConfig, offline, timeoutMs, stale }) => {
-        const identity = await resolveAuthIdentity(rawConfig, config);
-        await syncBeforeStorageCommand(db, offline, timeoutMs);
-        const stats = await getStorageStats(db, identity.userId);
+    await withCommandRuntime(context, async (runtime) => {
+        const identity = await resolveAuthIdentity(runtime.config);
+        await syncBeforeCommand(runtime);
+        const stats = await getStorageStats(runtime.db, identity.userId);
         const payload = {
             ok: true,
-            stale: offline ? true : stale,
+            stale: commandStale(runtime),
             ...stats,
         };
         if (structuredOutput) {
@@ -191,9 +163,7 @@ async function runStorageStats(context) {
                 printHumanReadableLine(`- ${entry.label}: ${entry.fileCount} files, ${formatBytes(entry.totalBytes)}`);
             }
         }
-        if (stale && !offline) {
-            printHumanReadableLine('warning: sync timed out; local cache may be stale');
-        }
+        printStaleCacheWarning(runtime);
     });
 }
 export const storageCommandGroup = {

package/dist/commands/storage/repo.d.ts

@@ -151,7 +151,7 @@ export declare function inspectStorageTest(db: AbstractPowerSyncDatabase, input:
 export declare function testStorageUpload(db: AbstractPowerSyncDatabase, input: {
     userId: string;
     storageId?: string;
-}, deps?: Pick<UploadDeps, 'uploadBytes'>): Promise<StorageTestResult>;
+}, deps?: Pick<UploadDeps, 'deleteObject' | 'uploadBytes'>): Promise<StorageTestResult>;
 export declare function uploadFileToStorage(db: AbstractPowerSyncDatabase, input: {
     userId: string;
     filePath: string;

package/dist/commands/storage/repo.js

@@ -515,12 +515,13 @@ export async function getStorageStats(db, userId) {
       COUNT(1) AS file_count
     FROM c_resource
     WHERE (is_del IS NULL OR is_del = 0)
+      AND TRIM(COALESCE(user_id, '')) = ?
       AND TRIM(COALESCE(storage_provider, '')) <> ''
       AND TRIM(COALESCE(storage_provider, '')) <> 'local'
       AND TRIM(COALESCE(status, '')) = 'uploaded'
     GROUP BY storage_provider, bucket
     ORDER BY total_bytes DESC, provider ASC, bucket ASC
-    `, []);
+    `, [userId]);
     const configs = await listStoredCustomStorageConfigs(db, userId);
     const configsByKey = new Map();
     const configsByProvider = new Map();
@@ -639,6 +640,7 @@ export async function testStorageUpload(db, input, deps) {
         throw new DinoxError(`Storage config not found: ${plan.storage.id}`);
     }
     const uploadBytes = deps?.uploadBytes ?? defaultUploadBytes;
+    const deleteObject = deps?.deleteObject ?? defaultDeleteObject;
     const payload = Buffer.from(`dinox-cli storage test\nprovider=${storage.provider}\nuser=${input.userId}\ncreated_at=${new Date().toISOString()}\n`, 'utf8');
     await uploadBytes({
         body: payload,
@@ -647,6 +649,23 @@ export async function testStorageUpload(db, input, deps) {
         contentType: plan.contentType,
         storage,
     });
+    try {
+        await deleteObject({
+            bucket: storage.bucket,
+            key: plan.storageKey,
+            storage,
+        });
+    }
+    catch (error) {
+        throw new DinoxError('Storage test uploaded the temporary object but failed to clean it up.', {
+            cause: error,
+            code: 'STORAGE_TEST_CLEANUP_FAILED',
+            details: {
+                storageKey: plan.storageKey,
+                bucket: storage.bucket,
+            },
+        });
+    }
     return {
         storageConfigId: storage.id,
         aliasName: storage.aliasName,

package/dist/commands/sync.js

@@ -1,5 +1,6 @@
 import { loadConfig } from '../config/store.js';
 import { resolveConfig } from '../config/resolve.js';
+import { hydrateResolvedAuthIdentity } from '../auth/userInfo.js';
 import { registerStandaloneCommand } from './descriptor/register.js';
 import { FORMAT_OPTIONS, SYNC_TIMEOUT_OPTIONS } from './schema/globalOptions.js';
 import { getRequestedStructuredOutputFormat, printHumanReadableLine, printSuccess, } from '../utils/output.js';
@@ -22,9 +23,10 @@ export const syncCommandDescriptor = {
         examples: ['dino sync --format json', 'dino sync --sync-timeout 600000 --format json'],
     },
     action: async (context) => {
-        const config = resolveConfig(await loadConfig());
+        const baseConfig = resolveConfig(await loadConfig());
         const structuredOutput = getRequestedStructuredOutputFormat() !== null;
-        const timeoutMs = parseSyncTimeoutMs(context.globals.syncTimeout) ?? config.sync.timeoutMs;
+        const timeoutMs = parseSyncTimeoutMs(context.globals.syncTimeout) ?? baseConfig.sync.timeoutMs;
+        const { config } = await hydrateResolvedAuthIdentity(baseConfig, { timeoutMs });
         const { db, dbPath, stale } = await connectPowerSync({
             config,
             offline: false,

package/dist/commands/tags/content.d.ts

@@ -0,0 +1,32 @@
+export type NoteTagContentUpdate = {
+    tagsChanged: boolean;
+    contentJsonChanged: boolean;
+    contentMdChanged: boolean;
+    contentTextChanged: boolean;
+    tags: string[];
+    contentJson: string | null;
+    contentMd: string | null;
+    contentText: string | null;
+};
+export type TagReferenceLookup = {
+    idByPath: ReadonlyMap<string, string>;
+    pathById: ReadonlyMap<string, string>;
+};
+export declare function renameTagReferencesInNote(args: {
+    tags: string[];
+    contentJson: string | null;
+    contentMd: string | null;
+    contentText: string | null;
+    oldPrefix: string;
+    newPrefix: string;
+    lookup?: TagReferenceLookup;
+}): NoteTagContentUpdate;
+export declare function mergeTagReferencesInNote(args: {
+    tags: string[];
+    contentJson: string | null;
+    contentMd: string | null;
+    contentText: string | null;
+    oldPrefix: string;
+    newPrefix: string;
+    lookup?: TagReferenceLookup;
+}): NoteTagContentUpdate;