@dinoxx/dinox-cli 1.1.1 → 2.1.0

package/dist/commands/notes/contentPatch.d.ts

@@ -1,5 +1,6 @@
 import type { AbstractPowerSyncDatabase } from '@powersync/common';
 import { type NoteContentBlockDescriptor, type NoteContentOutlineItem } from './contentEngine.js';
+export type NoteContentReadScope = 'structural-metadata' | 'full-content';
 export type NoteContentPatchOperation = {
     kind: 'appendSection';
     heading: string;
@@ -24,6 +25,7 @@ export type NoteContentReadResult = {
     title: string;
     readToken: string;
     readTokenExpiresAt: string;
+    readTokenScope: NoteContentReadScope;
     base: {
         contentHash: string;
         updatedAt: string | null;
@@ -72,7 +74,9 @@ export declare function planMarkdownPatch(input: {
     contentMd: string;
     operation: NoteContentPatchOperation;
 }): NoteContentPatchPlan;
-export declare function readNoteContentForPatch(db: AbstractPowerSyncDatabase, id: string, databaseScope: string, userId: string): Promise<NoteContentReadResult>;
+export declare function readNoteContentForPatch(db: AbstractPowerSyncDatabase, id: string, databaseScope: string, userId: string, options?: {
+    includeContent?: boolean;
+}): Promise<NoteContentReadResult>;
 export declare function planNoteContentPatch(db: AbstractPowerSyncDatabase, input: {
     id: string;
     userId: string;

package/dist/commands/notes/contentPatch.js

@@ -154,6 +154,7 @@ async function rememberReadToken(input) {
             contentHash: input.contentHash,
             updatedAt: input.updatedAt,
             version: input.version,
+            reviewScope: input.reviewScope,
             createdAt: new Date(nowMs).toISOString(),
             expiresAt,
         };
@@ -296,7 +297,7 @@ export function planMarkdownPatch(input) {
     });
     return plan;
 }
-export async function readNoteContentForPatch(db, id, databaseScope, userId) {
+export async function readNoteContentForPatch(db, id, databaseScope, userId, options = {}) {
     const row = await readNoteContentRow(db, id);
     const tagLookup = await loadTagReferenceLookup(db, userId);
     const document = parseStoredNoteDocument({
@@ -308,18 +309,23 @@ export async function readNoteContentForPatch(db, id, databaseScope, userId) {
     });
     const contentHash = getNoteContentHash(document);
     const version = normalizeVersion(row.version);
+    const readTokenScope = options.includeContent === true
+        ? 'full-content'
+        : 'structural-metadata';
     const token = await rememberReadToken({
         databaseScope,
         noteId: row.id,
         contentHash,
         updatedAt: row.updated_at ?? null,
         version,
+        reviewScope: readTokenScope,
     });
     return {
         noteId: row.id,
         title: row.title?.trim() ?? '',
         readToken: token.token,
         readTokenExpiresAt: token.expiresAt,
+        readTokenScope,
         base: {
             contentHash,
             updatedAt: row.updated_at ?? null,
@@ -353,6 +359,11 @@ export async function applyNoteContentPatch(db, input) {
     if (token.databaseScopeFingerprint !== fingerprintDatabaseScope(input.databaseScope)) {
         throw new DinoxError('read token was issued for a different local account database. Run `dino note content-read <id>` again.');
     }
+    if ('allowProtectedReplace' in input.operation
+        && input.operation.allowProtectedReplace === true
+        && token.reviewScope !== 'full-content') {
+        throw new DinoxError('Protected content replacement requires a full-content read token. Run `dino note content-read <id> --include-content --format json`, review the affected protected blocks, and retry with the new token.');
+    }
     const result = await withPowerSyncWriteTransaction(db, async (tx) => {
         const tagLookup = await loadTagReferenceLookup(tx, input.userId);
         const row = await readNoteContentRow(tx, input.id);

package/dist/commands/notes/contentPatchCommand.d.ts

@@ -1,3 +1,6 @@
 import type { CommandExecutionContext } from '../descriptor/types.js';
+import type { NoteContentBlockDescriptor } from './contentEngine.js';
+export type PublicNoteContentBlockDescriptor = Pick<NoteContentBlockDescriptor, 'anchorId' | 'hasStableAnchor' | 'nodeIndex' | 'nodeRange' | 'type' | 'editMode' | 'level' | 'textHash' | 'nodeHash' | 'charCount'>;
+export declare function toPublicNoteContentBlocks(blocks: NoteContentBlockDescriptor[]): PublicNoteContentBlockDescriptor[];
 export declare function runNoteContentRead({ command, options, args }: CommandExecutionContext): Promise<void>;
 export declare function runNotePatch({ command, options, args }: CommandExecutionContext): Promise<void>;

package/dist/commands/notes/contentPatchCommand.js

@@ -7,6 +7,20 @@ import { commandStale, printStaleCacheWarning, resolveWriteDurabilityForRuntime,
 import { readNoteWriteReceipt } from './writeReceipt.js';
 import { applyNoteContentPatch, planNoteContentPatch, readNoteContentForPatch, } from './contentPatch.js';
 import { parseStringInput, syncBeforeNoteCommand, withNoteDatabase, } from './runtime.js';
+export function toPublicNoteContentBlocks(blocks) {
+    return blocks.map((block) => ({
+        anchorId: block.anchorId,
+        hasStableAnchor: block.hasStableAnchor,
+        nodeIndex: block.nodeIndex,
+        nodeRange: block.nodeRange,
+        type: block.type,
+        editMode: block.editMode,
+        level: block.level,
+        textHash: block.textHash,
+        nodeHash: block.nodeHash,
+        charCount: block.charCount,
+    }));
+}
 function requireNoteId(id) {
     const normalized = id?.trim() ?? '';
     if (!normalized) {
@@ -60,11 +74,11 @@ export async function runNoteContentRead({ command, options, args }) {
     await withNoteDatabase(command, async (runtime) => {
         await syncBeforeNoteCommand(runtime);
         const identity = await resolveAuthIdentity(runtime.config);
-        const result = await readNoteContentForPatch(runtime.db, id, getPowerSyncDbPath(identity.userId), identity.userId);
-        const { content, ...rest } = result;
+        const result = await readNoteContentForPatch(runtime.db, id, getPowerSyncDbPath(identity.userId), identity.userId, { includeContent: readOptions.includeContent === true });
+        const { content, blocks, ...rest } = result;
         const payload = readOptions.includeContent
-            ? { ...rest, content, stale: commandStale(runtime) }
-            : { ...rest, stale: commandStale(runtime) };
+            ? { ...rest, blocks, content, stale: commandStale(runtime) }
+            : { ...rest, blocks: toPublicNoteContentBlocks(blocks), stale: commandStale(runtime) };
         printSuccess(payload);
     });
 }
@@ -88,6 +102,9 @@ export async function runNotePatch({ command, options, args }) {
                 summary: `Preview ${plan.operation} for note "${plan.title}" (${plan.noteId}); content ${plan.changed ? 'would change' : 'is unchanged'}.`,
                 warnings: [
                     'Run `dino note content-read <id> --format json` before the real edit and pass the returned readToken as --read-token.',
+                    ...('allowProtectedReplace' in operation && operation.allowProtectedReplace === true
+                        ? ['Protected replacement requires `content-read --include-content`; review the affected protected blocks before using its full-content token.']
+                        : []),
                     ...(offline ? ['Execution would run in offline mode and only use the local cache.'] : []),
                 ],
                 inputs: {
@@ -102,12 +119,14 @@ export async function runNotePatch({ command, options, args }) {
                     after_chars: plan.afterContent.length,
                     changed: plan.changed,
                 },
-            });
+            }, runtime);
             return;
         }
-        const readToken = patchOptions.readToken?.trim() ?? '';
+        const readToken = typeof patchOptions.readToken === 'string'
+            ? (await parseStringInput(patchOptions.readToken)).trim()
+            : '';
         if (!readToken) {
-            throw new DinoxError('Real note content edits require --read-token from `dino note content-read <id>`.');
+            throw new DinoxError('Real note content edits require --read-token <token|@file> from `dino note content-read <id>`.');
         }
         const result = await applyNoteContentPatch(db, {
             id,
@@ -124,10 +143,12 @@ export async function runNotePatch({ command, options, args }) {
             upload,
             stale: commandStale(runtime),
         });
-        const { changed: contentChanged, ...publicResult } = result;
+        const { changed: contentChanged, beforeBlocks, afterBlocks, ...publicResult } = result;
         const payload = {
             ok: true,
             ...publicResult,
+            beforeBlocks: toPublicNoteContentBlocks(beforeBlocks),
+            afterBlocks: toPublicNoteContentBlocks(afterBlocks),
             content_changed: contentChanged,
             ...receipt,
         };

package/dist/commands/notes/descriptors.js

@@ -42,7 +42,7 @@ export const noteCommandGroup = {
                 { flags: '--sql <expr>', description: 'SQL-like expression over id/content_md/summary/tags/zettel_boxes/created_at/type/is_starred', type: 'string' },
                 { flags: '--limit <n>', description: 'Maximum returned notes', type: 'number' },
                 { flags: '--offset <n>', description: 'Result offset for pagination', type: 'number', defaultValue: 0 },
-                { flags: '--fields <list>', description: 'Comma-separated fields: id,title,summary,tags,created_at,boxes,is_starred', type: 'string[]' },
+                { flags: '--fields <list>', description: 'Comma-separated fields: id,title,summary,tags,created_at,starred_at,boxes,is_starred', type: 'string[]' },
                 { flags: '--include-deleted', description: 'Include soft-deleted notes', type: 'boolean' },
             ],
             schema: {
@@ -54,7 +54,7 @@ export const noteCommandGroup = {
                     type: 'structured',
                     summary: 'AI-friendly note search payload',
                     entity: 'note_search_result',
-                    fields: ['id', 'title', 'summary', 'tags', 'created_at', 'boxes', 'is_starred'],
+                    fields: ['id', 'title', 'summary', 'tags', 'created_at', 'starred_at', 'boxes', 'is_starred'],
                     metaFields: ['query', 'returned_count', 'total_count', 'stale', 'pagination', 'fields', 'applied_filters'],
                 },
                 examples: [
@@ -66,9 +66,9 @@ export const noteCommandGroup = {
         },
         {
             name: 'get',
-            description: 'Get one note by id, optionally in lightweight context mode',
+            description: 'Get lightweight note context by id without exposing full note content',
             arguments: [{ syntax: '<id>', description: 'Note id' }],
-            options: [{ flags: '--context-only', description: 'Return lightweight note context (title/tags/summary/links)', type: 'boolean' }],
+            options: [{ flags: '--context-only', description: 'Compatibility flag; note get is context-only by default', type: 'boolean' }],
             schema: {
                 path: 'note.get',
                 risk: 'read',
@@ -76,11 +76,11 @@ export const noteCommandGroup = {
                 globalOptions: NOTE_GLOBAL_OPTIONS,
                 output: {
                     type: 'structured',
-                    summary: 'Single note or note context payload',
+                    summary: 'Lightweight note context payload; use note detail or content-read --include-content for full content',
                     entity: 'note_context',
-                    fields: ['id', 'title', 'summary', 'tags', 'created_at', 'updated_at', 'is_del', 'boxes', 'links'],
+                    fields: ['stale', 'note.id', 'note.title', 'note.summary', 'note.tags', 'note.created_at', 'note.updated_at', 'note.is_del', 'note.starred_at', 'note.is_starred', 'note.boxes', 'note.links'],
                 },
-                examples: ['dino note get <id> --context-only --format json', 'dino note get <id> --format json'],
+                examples: ['dino note get <id> --format json'],
             },
             action: runNoteGet,
         },
@@ -115,8 +115,8 @@ export const noteCommandGroup = {
                 globalOptions: NOTE_GLOBAL_OPTIONS,
                 output: {
                     type: 'structured',
-                    summary: 'One full note object or an ordered array of note objects',
-                    fields: ['id', 'title', 'content_md', 'content_text', 'content_json', 'tags', 'boxes', 'created_at', 'updated_at', 'is_del'],
+                    summary: 'Ordered full-note collection with freshness metadata',
+                    fields: ['stale', 'count', 'notes.id', 'notes.title', 'notes.content_md', 'notes.content_text', 'notes.content_json', 'notes.properties', 'notes.is_pub', 'notes.starred_at', 'notes.is_starred', 'notes.tags', 'notes.boxes', 'notes.created_at', 'notes.updated_at', 'notes.is_del'],
                 },
                 examples: ['dino note detail <id> --format json', 'dino note detail --ids @/tmp/note-ids.txt --format json'],
             },
@@ -155,7 +155,7 @@ export const noteCommandGroup = {
             description: 'Read note content context and issue a short-lived token required before content patching',
             arguments: [{ syntax: '<id>', description: 'Note id' }],
             options: [
-                { flags: '--include-content', description: 'Include full markdown content in the response', type: 'boolean' },
+                { flags: '--include-content', description: 'Include full markdown plus detailed block text and attributes', type: 'boolean' },
             ],
             schema: {
                 path: 'note.content-read',
@@ -164,10 +164,13 @@ export const noteCommandGroup = {
                 globalOptions: NOTE_GLOBAL_OPTIONS,
                 output: {
                     type: 'structured',
-                    summary: 'Note content read context with readToken, base hash, heading outline, block index, and derived metadata',
-                    fields: ['noteId', 'title', 'readToken', 'readTokenExpiresAt', 'base', 'outline', 'blocks', 'derived', 'content', 'stale'],
+                    summary: 'Privacy-preserving note edit context; full content and detailed blocks require --include-content',
+                    fields: ['noteId', 'title', 'readToken', 'readTokenExpiresAt', 'readTokenScope', 'base', 'outline', 'blocks.type', 'blocks.editMode', 'blocks.nodeRange', 'blocks.textHash', 'blocks.nodeHash', 'blocks.charCount', 'derived', 'content', 'stale'],
                 },
-                examples: ['dino note content-read <id> --include-content --format json'],
+                examples: [
+                    'dino note content-read <id> --format json',
+                    'dino note content-read <id> --include-content --format json',
+                ],
             },
             action: runNoteContentRead,
         },
@@ -295,8 +298,8 @@ export const noteCommandGroup = {
                 { flags: '--replace-block', description: 'Replace one exact markdown block matched by --match', type: 'boolean' },
                 { flags: '--match <string|@file>', description: 'Exact markdown to replace when using --replace-block', type: 'string' },
                 { flags: '--content <string|@file>', description: 'Markdown content to insert', type: 'string' },
-                { flags: '--read-token <token>', description: 'Required for real writes; returned by note content-read', type: 'string' },
-                { flags: '--allow-protected-replace', description: 'Allow replace operations to affect media, table, container, or unknown blocks after reviewing content-read output', type: 'boolean' },
+                { flags: '--read-token <token|@file>', description: 'Single-use patch capability returned by note content-read; prefer @file to avoid exposing it in argv', type: 'string' },
+                { flags: '--allow-protected-replace', description: 'Allow replacement of media, table, container, or unknown blocks only with a reviewed full-content read token', type: 'boolean' },
                 WRITE_DURABILITY_OPTION,
                 { flags: '--dry-run', description: 'Preview the patch without writing', type: 'boolean' },
             ],
@@ -312,7 +315,7 @@ export const noteCommandGroup = {
                 },
                 examples: [
                     'dino note content-read <id> --format json',
-                    'dino note patch <id> --append-section "复盘" --content @/tmp/section.md --read-token <token> --format json',
+                    'dino note patch <id> --append-section "复盘" --content @/tmp/section.md --read-token @/tmp/dinox-read-token --format json',
                 ],
             },
             action: runNotePatch,

package/dist/commands/notes/export.js

@@ -59,6 +59,9 @@ function serializeMarkdownExport(note) {
         tags: note.tags,
         boxes: note.boxes,
         box_ids: note.box_ids,
+        properties: note.properties,
+        is_pub: note.is_pub,
+        starred_at: note.starred_at,
         is_starred: note.is_starred,
         is_del: note.is_del ?? 0,
     }, {

package/dist/commands/notes/repo/read.d.ts

@@ -0,0 +1,8 @@
+import type { AbstractPowerSyncDatabase } from '@powersync/common';
+import { type NoteContext, type NoteDetail, type NoteExportItem, type NotePreview, type NoteRow } from './shared.js';
+export declare function getNote(db: AbstractPowerSyncDatabase, id: string): Promise<NoteRow | null>;
+export declare function getNoteContext(db: AbstractPowerSyncDatabase, id: string): Promise<NoteContext | null>;
+export declare function getNotePreview(db: AbstractPowerSyncDatabase, id: string, requestedLines: number): Promise<NotePreview | null>;
+export declare function getNoteDetails(db: AbstractPowerSyncDatabase, ids: string[]): Promise<NoteDetail[]>;
+export declare function getNoteDetail(db: AbstractPowerSyncDatabase, id: string): Promise<NoteDetail | null>;
+export declare function getNoteExportItems(db: AbstractPowerSyncDatabase, ids: string[]): Promise<NoteExportItem[]>;

package/dist/commands/notes/repo/read.js

@@ -0,0 +1,321 @@
+// Note reads: single-note lookup, context, preview, detail, and export rows.
+import { DinoxError } from '../../../utils/errors.js';
+import { loadZettelBoxNameMap, normalizeStoredFlag, normalizeStoredStarred, parseStoredTags, parseZettelBoxIds, resolveSummary, } from './shared.js';
+export async function getNote(db, id) {
+    return db.getOptional(`
+    SELECT
+      id,
+      title,
+      content_md,
+      content_json,
+      content_text,
+      created_at,
+      updated_at,
+      is_del,
+      starred_at,
+      CASE WHEN starred_at IS NOT NULL THEN 1 ELSE 0 END AS is_starred,
+      version
+    FROM c_note
+    WHERE id = ?
+    `, [id]);
+}
+async function getLinkCount(db, direction, noteId) {
+    const [column, boundColumn] = direction === 'in'
+        ? ['src_note_id', 'dst_note_id']
+        : ['dst_note_id', 'src_note_id'];
+    const row = await db.getOptional(`
+    SELECT COUNT(1) AS count
+    FROM c_note_link l
+    JOIN c_note n ON n.id = l.${column}
+    WHERE l.${boundColumn} = ?
+      AND (l.is_del IS NULL OR l.is_del = 0)
+      AND (n.is_del IS NULL OR n.is_del = 0)
+    `, [noteId]);
+    return Number(row?.count ?? 0);
+}
+function buildPreviewText(contentMd, requestedLines) {
+    const normalized = (contentMd ?? '').replace(/\r\n/g, '\n');
+    if (!normalized) {
+        return {
+            preview: '',
+            totalLines: 0,
+            returnedLines: 0,
+            truncated: false,
+        };
+    }
+    const lines = normalized.split('\n');
+    const selected = lines.slice(0, requestedLines);
+    return {
+        preview: selected.join('\n'),
+        totalLines: lines.length,
+        returnedLines: selected.length,
+        truncated: selected.length < lines.length,
+    };
+}
+export async function getNoteContext(db, id) {
+    const row = await db.getOptional(`
+    SELECT
+      n.id,
+      n.title,
+      n.summary,
+      n.content_text,
+      n.tags,
+      n.created_at,
+      n.updated_at,
+      n.is_del,
+      n.starred_at,
+      CASE WHEN n.starred_at IS NOT NULL THEN 1 ELSE 0 END AS is_starred,
+      n.zettel_boxes AS zettel_boxes_raw
+    FROM c_note n
+    WHERE n.id = ?
+    `, [id]);
+    if (!row) {
+        return null;
+    }
+    const boxIds = parseZettelBoxIds(row.zettel_boxes_raw);
+    const boxNameMap = await loadZettelBoxNameMap(db, boxIds);
+    const [backlinks, outlinks] = await Promise.all([
+        getLinkCount(db, 'in', id),
+        getLinkCount(db, 'out', id),
+    ]);
+    return {
+        id: row.id,
+        title: row.title?.trim() ?? '',
+        summary: resolveSummary(row.summary, row.content_text),
+        tags: parseStoredTags(row.tags),
+        created_at: row.created_at,
+        updated_at: row.updated_at,
+        is_del: row.is_del,
+        starred_at: row.starred_at ?? null,
+        is_starred: normalizeStoredStarred(row.is_starred),
+        zettel_boxes: boxIds
+            .map((boxId) => boxNameMap.get(boxId))
+            .filter((name) => typeof name === 'string' && name.length > 0),
+        links: {
+            backlinks,
+            outlinks,
+        },
+    };
+}
+export async function getNotePreview(db, id, requestedLines) {
+    const row = await db.getOptional(`
+    SELECT
+      n.id,
+      n.title,
+      n.content_md,
+      n.updated_at
+    FROM c_note n
+    WHERE n.id = ?
+    `, [id]);
+    if (!row) {
+        return null;
+    }
+    const preview = buildPreviewText(row.content_md, requestedLines);
+    return {
+        id: row.id,
+        title: row.title?.trim() ?? '',
+        requested_lines: requestedLines,
+        total_lines: preview.totalLines,
+        returned_lines: preview.returnedLines,
+        truncated: preview.truncated,
+        preview: preview.preview,
+        updated_at: row.updated_at ?? null,
+    };
+}
+function mapNoteDetailRow(note, boxNameMap) {
+    const boxIds = parseZettelBoxIds(note.zettel_boxes_raw);
+    const zettelBoxes = boxIds
+        .map((boxId) => boxNameMap.get(boxId))
+        .filter((name) => typeof name === 'string' && name.length > 0);
+    return {
+        id: note.id,
+        created_at: note.created_at,
+        updated_at: note.updated_at,
+        title: note.title,
+        type: note.type,
+        source: note.source,
+        tags: parseStoredTags(note.tags),
+        is_del: note.is_del,
+        is_pub: normalizeStoredFlag(note.is_pub),
+        properties: parseStoredNoteProperties(note.properties),
+        starred_at: note.starred_at ?? null,
+        is_starred: normalizeStoredStarred(note.is_starred),
+        content_md: note.content_md,
+        content_text: note.content_text,
+        content_json: parseStoredJsonValue(note.content_json),
+        zettel_boxes: zettelBoxes,
+    };
+}
+function parseStoredJsonValue(raw) {
+    const value = raw?.trim() ?? '';
+    if (!value) {
+        return null;
+    }
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return raw;
+    }
+}
+function parseStoredNoteProperties(raw) {
+    const value = raw?.trim() ?? '';
+    if (!value) {
+        return {};
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(value);
+    }
+    catch (cause) {
+        throw new DinoxError('c_note.properties must be valid JSON', {
+            code: 'NOTE_INVALID_PROPERTIES',
+            details: { cause: cause instanceof Error ? cause.message : String(cause) },
+            recoverable: false,
+        });
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new DinoxError('c_note.properties must be a JSON object', {
+            code: 'NOTE_INVALID_PROPERTIES',
+            recoverable: false,
+        });
+    }
+    return Object.fromEntries(Object.entries(parsed));
+}
+function mapNoteExportRow(note, boxNameMap) {
+    const boxIds = parseZettelBoxIds(note.zettel_boxes_raw);
+    const boxes = boxIds
+        .map((boxId) => boxNameMap.get(boxId))
+        .filter((name) => typeof name === 'string' && name.length > 0);
+    return {
+        id: note.id,
+        created_at: note.created_at,
+        updated_at: note.updated_at,
+        title: note.title,
+        type: note.type,
+        source: note.source,
+        summary: note.summary,
+        tags: parseStoredTags(note.tags),
+        is_del: note.is_del,
+        is_pub: normalizeStoredFlag(note.is_pub),
+        properties: parseStoredNoteProperties(note.properties),
+        starred_at: note.starred_at ?? null,
+        is_starred: normalizeStoredStarred(note.is_starred),
+        content_md: note.content_md ?? '',
+        content_text: note.content_text,
+        content_json: parseStoredJsonValue(note.content_json),
+        box_ids: boxIds,
+        boxes,
+    };
+}
+export async function getNoteDetails(db, ids) {
+    const targetIds = Array.from(new Set(ids
+        .map((id) => id.trim())
+        .filter((id) => id.length > 0)));
+    if (targetIds.length === 0) {
+        return [];
+    }
+    const noteRowsById = new Map();
+    const chunkSize = 500;
+    for (let index = 0; index < targetIds.length; index += chunkSize) {
+        const batch = targetIds.slice(index, index + chunkSize);
+        const placeholders = batch.map(() => '?').join(', ');
+        const rows = await db.getAll(`
+      SELECT
+        id,
+        created_at,
+        updated_at,
+        title,
+        type,
+        source,
+        tags,
+        is_del,
+        is_pub,
+        properties,
+        starred_at,
+        CASE WHEN starred_at IS NOT NULL THEN 1 ELSE 0 END AS is_starred,
+        content_md,
+        content_text,
+        content_json,
+        zettel_boxes AS zettel_boxes_raw
+      FROM c_note
+      WHERE id IN (${placeholders})
+      `, batch);
+        for (const row of rows) {
+            const id = row.id?.trim() ?? '';
+            if (!id || noteRowsById.has(id)) {
+                continue;
+            }
+            noteRowsById.set(id, row);
+        }
+    }
+    const allBoxIds = Array.from(new Set(Array.from(noteRowsById.values()).flatMap((row) => parseZettelBoxIds(row.zettel_boxes_raw))));
+    const boxNameMap = await loadZettelBoxNameMap(db, allBoxIds);
+    const details = [];
+    for (const id of targetIds) {
+        const row = noteRowsById.get(id);
+        if (!row) {
+            continue;
+        }
+        details.push(mapNoteDetailRow(row, boxNameMap));
+    }
+    return details;
+}
+export async function getNoteDetail(db, id) {
+    const details = await getNoteDetails(db, [id]);
+    return details[0] ?? null;
+}
+export async function getNoteExportItems(db, ids) {
+    const targetIds = Array.from(new Set(ids
+        .map((id) => id.trim())
+        .filter((id) => id.length > 0)));
+    if (targetIds.length === 0) {
+        return [];
+    }
+    const noteRowsById = new Map();
+    const chunkSize = 500;
+    for (let index = 0; index < targetIds.length; index += chunkSize) {
+        const batch = targetIds.slice(index, index + chunkSize);
+        const placeholders = batch.map(() => '?').join(', ');
+        const rows = await db.getAll(`
+      SELECT
+        id,
+        created_at,
+        updated_at,
+        title,
+        type,
+        source,
+        tags,
+        summary,
+        is_del,
+        is_pub,
+        properties,
+        starred_at,
+        CASE WHEN starred_at IS NOT NULL THEN 1 ELSE 0 END AS is_starred,
+        content_md,
+        content_text,
+        content_json,
+        zettel_boxes AS zettel_boxes_raw
+      FROM c_note
+      WHERE id IN (${placeholders})
+      `, batch);
+        for (const row of rows) {
+            const id = row.id?.trim() ?? '';
+            if (!id || noteRowsById.has(id)) {
+                continue;
+            }
+            noteRowsById.set(id, row);
+        }
+    }
+    const allBoxIds = Array.from(new Set(Array.from(noteRowsById.values()).flatMap((row) => parseZettelBoxIds(row.zettel_boxes_raw))));
+    const boxNameMap = await loadZettelBoxNameMap(db, allBoxIds);
+    const items = [];
+    for (const id of targetIds) {
+        const row = noteRowsById.get(id);
+        if (!row) {
+            continue;
+        }
+        items.push(mapNoteExportRow(row, boxNameMap));
+    }
+    return items;
+}

package/dist/commands/notes/repo/resolve.d.ts

@@ -0,0 +1,8 @@
+import type { AbstractPowerSyncDatabase } from '@powersync/common';
+export declare function validateTagsForCreate(db: AbstractPowerSyncDatabase, requestedTags: string[], userId: string): Promise<string[]>;
+export declare function validateTagsForUpdate(db: AbstractPowerSyncDatabase, requestedTags: string[], userId: string): Promise<string[]>;
+export declare function validateTagsForBulk(db: AbstractPowerSyncDatabase, requestedTags: string[], userId: string): Promise<string[]>;
+export declare function resolveZettelBoxIdsForCreate(db: AbstractPowerSyncDatabase, requestedNames: string[]): Promise<string[]>;
+export declare function resolveZettelBoxIdsForSearch(db: AbstractPowerSyncDatabase, requestedNames: string[]): Promise<string[]>;
+export declare function resolveZettelBoxIdsForUpdate(db: AbstractPowerSyncDatabase, requestedNames: string[]): Promise<string[]>;
+export declare function resolveZettelBoxIdsForBulk(db: AbstractPowerSyncDatabase, requestedNames: string[]): Promise<string[]>;