@dinoxx/dinox-cli 1.1.1 → 2.0.0

package/dist/commands/tags/operations.js

@@ -1,6 +1,7 @@
 import { withPowerSyncWriteTransaction } from '../../powersync/runtime.js';
 import { DinoxError } from '../../utils/errors.js';
 import { nowIsoUtc } from '../../utils/time.js';
+import { assertConfirmedWrite, assertWriteConfirmationProvided, } from '../writeConfirmation.js';
 import { mergeTagReferencesInNote, renameTagReferencesInNote } from './content.js';
 import { MAX_TAG_SEGMENT_LENGTH, REQUIRED_NOTE_TAG_COLUMNS, REQUIRED_TAG_NODE_COLUMNS, canonicalizeTagPath, getLeafName, isActiveTagNode, isActualTagNode, isTagPathWithinPrefix, normalizeTagLookupKey, parseStoredTags, parentPathOf, renameTagPathWithPrefix, trimString, } from './model.js';
 import { activeTagNodes, actualActiveTagNodes, assertCanWriteTag, assertRequiredColumns, assertWritableTagNodes, descendantsOf, ensureNoTagPathConflict, getTableColumns, loadTagNodes, parentIdForPath, requireActiveTagPath, toTagListItem, } from './store.js';
@@ -297,7 +298,7 @@ export async function moveTag(db, input, options = {}) {
         updatedNotes: noteUpdates.map(({ id, before, after }) => ({ id, before, after })),
     };
 }
-export async function mergeTag(db, input, options = {}) {
+async function buildTagMergePlan(db, input) {
     const from = assertPath(input.from, 'Source tag path');
     const to = assertPath(input.to, 'Target tag path');
     const userId = trimString(input.userId);
@@ -318,28 +319,52 @@ export async function mergeTag(db, input, options = {}) {
         .map((row) => updateNoteTagsForPrefix(row, source.fullPath, target.fullPath, 'merge', lookup))
         .filter((row) => row.id && row.changed);
     const softDeletedTagIds = sourceNodes.map((node) => node.id);
-    if (!options.dryRun) {
-        await withPowerSyncWriteTransaction(db, async (tx) => {
-            const timestamp = nowIsoUtc();
-            await applyNoteUpdates(tx, noteUpdates, timestamp);
-            for (const tagId of softDeletedTagIds) {
-                await tx.execute(`
-          UPDATE c_tag_node
-          SET is_del = 1, updated_at = ?
-          WHERE id = ?
-          `, [timestamp, tagId]);
-            }
-        });
-    }
+    const affectedCount = softDeletedTagIds.length + noteUpdates.length;
     return {
-        fromId: source.id,
-        toId: target.id,
-        fromPath: source.fullPath,
-        toPath: target.fullPath,
-        softDeletedTagIds,
-        updatedNotes: noteUpdates.map(({ id, before, after }) => ({ id, before, after })),
+        result: {
+            fromId: source.id,
+            toId: target.id,
+            fromPath: source.fullPath,
+            toPath: target.fullPath,
+            softDeletedTagIds,
+            updatedNotes: noteUpdates.map(({ id, before, after }) => ({ id, before, after })),
+            affectedCount,
+        },
+        noteUpdates,
+        userId,
     };
 }
+function assertTagMergeCount(plan, options) {
+    assertConfirmedWrite({
+        operation: 'Tag merge',
+        schemaPath: 'tag.merge',
+        actualCount: plan.result.affectedCount,
+        options,
+    });
+}
+export async function mergeTag(db, input, options = {}) {
+    if (options.dryRun) {
+        const plan = await buildTagMergePlan(db, input);
+        assertTagMergeCount(plan, options);
+        return plan.result;
+    }
+    assertWriteConfirmationProvided('Tag merge', options);
+    return withPowerSyncWriteTransaction(db, async (tx) => {
+        const plan = await buildTagMergePlan(tx, input);
+        assertTagMergeCount(plan, options);
+        const timestamp = nowIsoUtc();
+        await applyNoteUpdates(tx, plan.noteUpdates, timestamp);
+        for (const tagId of plan.result.softDeletedTagIds) {
+            await tx.execute(`
+        UPDATE c_tag_node
+        SET is_del = 1, updated_at = ?
+        WHERE id = ?
+          AND TRIM(COALESCE(user_id, '')) = ?
+        `, [timestamp, tagId, plan.userId]);
+        }
+        return plan.result;
+    });
+}
 export async function inspectTagCleanup(db, input = {}) {
     const columns = await getTableColumns(db, 'c_tag_node');
     assertRequiredColumns('c_tag_node', columns, REQUIRED_TAG_NODE_COLUMNS);

package/dist/commands/templates/model.d.ts

@@ -0,0 +1,50 @@
+import { type TiptapNode } from '../notes/contentEngine.js';
+export declare const NOTE_TEMPLATE_PROPERTY_DEF_VERSION = 1;
+export declare const MAX_NOTE_TEMPLATE_PROPERTY_KEYS = 50;
+export declare const MAX_NOTE_TEMPLATE_CONTENT_LENGTH = 200000;
+export type NoteTemplatePropertyDef = {
+    version: typeof NOTE_TEMPLATE_PROPERTY_DEF_VERSION;
+    keys: string[];
+};
+export type NoteTemplateRow = {
+    id: string;
+    user_id: string | null;
+    name: string | null;
+    content: string | null;
+    priority: number | null;
+    is_show: number | null;
+    extra_data: string | null;
+    property_def: string | null;
+    insert_at: string | null;
+    update_at: string | null;
+    is_del: number | null;
+};
+export type NoteTemplateSummary = {
+    id: string;
+    name: string;
+    propertyKeys: string[];
+    content: string;
+    hasContent: boolean;
+    isShow: boolean;
+    priority: number;
+    updateAt: string | null;
+};
+export type NoteTemplateTokenValues = {
+    date: string;
+    datetime: string;
+    time: string;
+    location: string;
+};
+export declare function isNotePropertyKeyValid(value: unknown): value is string;
+export declare function validateNoteTemplatePropertyKeys(keys: readonly unknown[]): string[];
+export declare function parseNoteTemplatePropertyDef(raw: string | null | undefined): NoteTemplatePropertyDef | null;
+export declare function serializeNoteTemplatePropertyDef(keys: readonly string[]): string | null;
+export declare function isNoteTemplateDocumentEmpty(document: TiptapNode | null | undefined): boolean;
+export declare function parseNoteTemplateContent(raw: string | null | undefined): TiptapNode | null;
+export declare function serializeNoteTemplateContent(document: unknown): string;
+export declare function buildNoteTemplateTokenValues(now?: Date, location?: string): NoteTemplateTokenValues;
+export declare function hydrateNoteTemplateDocument(document: TiptapNode, options?: {
+    now?: Date;
+    location?: string;
+}): TiptapNode;
+export declare function mapNoteTemplateRow(row: NoteTemplateRow): NoteTemplateSummary;

package/dist/commands/templates/model.js

@@ -0,0 +1,239 @@
+import { projectNoteContent } from '../notes/contentEngine.js';
+import { DinoxError } from '../../utils/errors.js';
+export const NOTE_TEMPLATE_PROPERTY_DEF_VERSION = 1;
+export const MAX_NOTE_TEMPLATE_PROPERTY_KEYS = 50;
+export const MAX_NOTE_TEMPLATE_CONTENT_LENGTH = 200_000;
+const MAX_TIPTAP_NODE_DEPTH = 100;
+const MAX_TIPTAP_NODE_COUNT = 10_000;
+const NON_TEXT_TEMPLATE_NODE_TYPES = new Set([
+    'image',
+    'table',
+    'mermaid',
+    'mindgraph',
+    'codeBlock',
+    'horizontalRule',
+    'taskList',
+]);
+function formatError(message, code, details) {
+    return new DinoxError(message, {
+        code,
+        details,
+        recoverable: false,
+    });
+}
+function isPlainRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+export function isNotePropertyKeyValid(value) {
+    if (typeof value !== 'string')
+        return false;
+    const trimmed = value.trim();
+    if (!trimmed || trimmed !== value || trimmed.length > 64)
+        return false;
+    if (trimmed === '__proto__')
+        return false;
+    return !trimmed.includes('.') && !/[\n\r\t]/.test(trimmed);
+}
+export function validateNoteTemplatePropertyKeys(keys) {
+    if (keys.length > MAX_NOTE_TEMPLATE_PROPERTY_KEYS) {
+        throw formatError(`Note templates support at most ${MAX_NOTE_TEMPLATE_PROPERTY_KEYS} property keys`, 'NOTE_TEMPLATE_INVALID_PROPERTY_DEF', { maxKeys: MAX_NOTE_TEMPLATE_PROPERTY_KEYS, receivedKeys: keys.length });
+    }
+    const seen = new Set();
+    const validated = [];
+    for (const key of keys) {
+        if (!isNotePropertyKeyValid(key)) {
+            throw formatError('Note template property_def contains an invalid property key', 'NOTE_TEMPLATE_INVALID_PROPERTY_DEF', {
+                key,
+            });
+        }
+        if (seen.has(key)) {
+            throw formatError('Note template property_def contains duplicate property keys', 'NOTE_TEMPLATE_INVALID_PROPERTY_DEF', {
+                key,
+            });
+        }
+        seen.add(key);
+        validated.push(key);
+    }
+    return validated;
+}
+export function parseNoteTemplatePropertyDef(raw) {
+    const value = raw?.trim() ?? '';
+    if (!value)
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(value);
+    }
+    catch (cause) {
+        throw formatError('Note template property_def must be valid JSON', 'NOTE_TEMPLATE_INVALID_PROPERTY_DEF', {
+            cause: cause instanceof Error ? cause.message : String(cause),
+        });
+    }
+    if (!isPlainRecord(parsed)) {
+        throw formatError('Note template property_def must be a versioned object', 'NOTE_TEMPLATE_INVALID_PROPERTY_DEF');
+    }
+    if (parsed.version !== NOTE_TEMPLATE_PROPERTY_DEF_VERSION) {
+        throw formatError(`Unsupported note template property_def version: ${String(parsed.version)}`, 'NOTE_TEMPLATE_UNSUPPORTED_PROPERTY_DEF_VERSION', { supportedVersion: NOTE_TEMPLATE_PROPERTY_DEF_VERSION, receivedVersion: parsed.version });
+    }
+    if (!Array.isArray(parsed.keys)) {
+        throw formatError('Note template property_def keys must be an array', 'NOTE_TEMPLATE_INVALID_PROPERTY_DEF');
+    }
+    return {
+        version: NOTE_TEMPLATE_PROPERTY_DEF_VERSION,
+        keys: validateNoteTemplatePropertyKeys(parsed.keys),
+    };
+}
+export function serializeNoteTemplatePropertyDef(keys) {
+    const validated = validateNoteTemplatePropertyKeys(keys);
+    if (validated.length === 0)
+        return null;
+    return JSON.stringify({
+        version: NOTE_TEMPLATE_PROPERTY_DEF_VERSION,
+        keys: validated,
+    });
+}
+function assertTiptapNode(value, state, depth) {
+    if (depth > MAX_TIPTAP_NODE_DEPTH) {
+        throw formatError(`Note template content exceeds the maximum node depth of ${MAX_TIPTAP_NODE_DEPTH}`, 'NOTE_TEMPLATE_INVALID_CONTENT');
+    }
+    if (!isPlainRecord(value) || typeof value.type !== 'string' || !value.type.trim()) {
+        throw formatError('Note template content contains an invalid Tiptap node', 'NOTE_TEMPLATE_INVALID_CONTENT');
+    }
+    state.count += 1;
+    if (state.count > MAX_TIPTAP_NODE_COUNT) {
+        throw formatError(`Note template content exceeds the maximum node count of ${MAX_TIPTAP_NODE_COUNT}`, 'NOTE_TEMPLATE_INVALID_CONTENT');
+    }
+    if (value.text !== undefined && typeof value.text !== 'string') {
+        throw formatError('Tiptap node text must be a string', 'NOTE_TEMPLATE_INVALID_CONTENT');
+    }
+    if (value.attrs !== undefined && !isPlainRecord(value.attrs)) {
+        throw formatError('Tiptap node attrs must be an object', 'NOTE_TEMPLATE_INVALID_CONTENT');
+    }
+    if (value.marks !== undefined) {
+        if (!Array.isArray(value.marks)) {
+            throw formatError('Tiptap node marks must be an array', 'NOTE_TEMPLATE_INVALID_CONTENT');
+        }
+        for (const mark of value.marks) {
+            if (!isPlainRecord(mark) || typeof mark.type !== 'string' || !mark.type.trim()) {
+                throw formatError('Tiptap node contains an invalid mark', 'NOTE_TEMPLATE_INVALID_CONTENT');
+            }
+            if (mark.attrs !== undefined && !isPlainRecord(mark.attrs)) {
+                throw formatError('Tiptap mark attrs must be an object', 'NOTE_TEMPLATE_INVALID_CONTENT');
+            }
+        }
+    }
+    if (value.content !== undefined) {
+        if (!Array.isArray(value.content)) {
+            throw formatError('Tiptap node content must be an array', 'NOTE_TEMPLATE_INVALID_CONTENT');
+        }
+        for (const child of value.content) {
+            assertTiptapNode(child, state, depth + 1);
+        }
+    }
+}
+function assertCanonicalTemplateDocument(value) {
+    assertTiptapNode(value, { count: 0 }, 1);
+    if (value.type !== 'doc' || !Array.isArray(value.content)) {
+        throw formatError('Note template content must be a Tiptap doc with a content array', 'NOTE_TEMPLATE_INVALID_CONTENT');
+    }
+}
+function extractTemplatePlainText(node) {
+    if (node.type === 'text')
+        return typeof node.text === 'string' ? node.text : '';
+    if (node.type === 'hardBreak')
+        return '\n';
+    return (node.content ?? []).map(extractTemplatePlainText).join('');
+}
+function hasNonTextTemplateContent(node) {
+    if (NON_TEXT_TEMPLATE_NODE_TYPES.has(node.type))
+        return true;
+    return (node.content ?? []).some(hasNonTextTemplateContent);
+}
+export function isNoteTemplateDocumentEmpty(document) {
+    if (!document)
+        return true;
+    if (extractTemplatePlainText(document).trim())
+        return false;
+    return !hasNonTextTemplateContent(document);
+}
+export function parseNoteTemplateContent(raw) {
+    const value = raw?.trim() ?? '';
+    if (!value)
+        return null;
+    if (value.length > MAX_NOTE_TEMPLATE_CONTENT_LENGTH) {
+        throw formatError(`Note template content must be at most ${MAX_NOTE_TEMPLATE_CONTENT_LENGTH} characters`, 'NOTE_TEMPLATE_INVALID_CONTENT');
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(value);
+    }
+    catch (cause) {
+        throw formatError('Note template content must be valid Tiptap JSON', 'NOTE_TEMPLATE_INVALID_CONTENT', {
+            cause: cause instanceof Error ? cause.message : String(cause),
+        });
+    }
+    assertCanonicalTemplateDocument(parsed);
+    return projectNoteContent(parsed).document;
+}
+export function serializeNoteTemplateContent(document) {
+    assertCanonicalTemplateDocument(document);
+    if (isNoteTemplateDocumentEmpty(document))
+        return '';
+    const content = projectNoteContent(document).contentJson;
+    if (content.length > MAX_NOTE_TEMPLATE_CONTENT_LENGTH) {
+        throw formatError(`Note template content must be at most ${MAX_NOTE_TEMPLATE_CONTENT_LENGTH} characters`, 'NOTE_TEMPLATE_INVALID_CONTENT');
+    }
+    return content;
+}
+function pad(value) {
+    return String(value).padStart(2, '0');
+}
+export function buildNoteTemplateTokenValues(now = new Date(), location = '') {
+    if (Number.isNaN(now.getTime())) {
+        throw formatError('Note template token time must be a valid date', 'NOTE_TEMPLATE_INVALID_TOKEN_CONTEXT');
+    }
+    const date = `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}`;
+    const time = `${pad(now.getHours())}:${pad(now.getMinutes())}`;
+    return {
+        date,
+        time,
+        datetime: `${date} ${time}`,
+        location,
+    };
+}
+function hydrateTemplateNode(node, values) {
+    if (node.type === 'text' && typeof node.text === 'string') {
+        const text = node.text
+            .replaceAll('{{date}}', values.date)
+            .replaceAll('{{datetime}}', values.datetime)
+            .replaceAll('{{time}}', values.time)
+            .replaceAll('{{location}}', values.location);
+        return text ? { ...node, text } : null;
+    }
+    if (!Array.isArray(node.content))
+        return { ...node };
+    const content = node.content
+        .map((child) => hydrateTemplateNode(child, values))
+        .filter((child) => child !== null);
+    return { ...node, content };
+}
+export function hydrateNoteTemplateDocument(document, options = {}) {
+    assertCanonicalTemplateDocument(document);
+    const values = buildNoteTemplateTokenValues(options.now, options.location ?? '');
+    return hydrateTemplateNode(document, values) ?? { type: 'doc', content: [] };
+}
+export function mapNoteTemplateRow(row) {
+    const propertyDef = parseNoteTemplatePropertyDef(row.property_def);
+    const document = parseNoteTemplateContent(row.content);
+    const content = document ? serializeNoteTemplateContent(document) : '';
+    return {
+        id: row.id,
+        name: (row.name ?? '').trim(),
+        propertyKeys: propertyDef?.keys ?? [],
+        content,
+        hasContent: Boolean(content),
+        isShow: Number(row.is_show ?? 0) === 1,
+        priority: Number.isFinite(row.priority) ? Math.trunc(Number(row.priority)) : 0,
+        updateAt: row.update_at ?? null,
+    };
+}

package/dist/commands/todo/index.js

@@ -182,7 +182,7 @@ async function runTodoAppend({ args, globals, options }) {
                 noteId: typeof appendOptions.noteId === 'string' ? appendOptions.noteId : undefined,
                 taskTexts,
             });
-            printDryRunPreview(preview);
+            printDryRunPreview(preview, runtime);
             return;
         }
         const result = await appendTodoTasks(db, {
@@ -216,7 +216,7 @@ async function runTodoCreate({ args, globals, options }) {
                 title: typeof createOptions.title === 'string' ? createOptions.title : undefined,
                 taskTexts,
             });
-            printDryRunPreview(preview);
+            printDryRunPreview(preview, runtime);
             return;
         }
         const identity = await resolveAuthIdentity(config);
@@ -254,7 +254,7 @@ async function runTodoUpdate({ args, globals, options }) {
                 noteId: typeof updateOptions.noteId === 'string' ? updateOptions.noteId : undefined,
                 checked,
             });
-            printDryRunPreview(preview);
+            printDryRunPreview(preview, runtime);
             return;
         }
         const result = await updateTodoTaskStatus(db, {

package/dist/commands/update.d.ts

@@ -8,6 +8,7 @@ type UpdateCommandDeps = {
         structuredOutput: boolean;
     }) => Promise<void>;
     getVersion: () => string;
+    getLatestVersion: () => Promise<string | null>;
     log: LogFn;
 };
 export declare function detectPackageManager(input?: {

package/dist/commands/update.js

@@ -2,9 +2,11 @@ import { spawn } from 'node:child_process';
 import { realpathSync } from 'node:fs';
 import { registerStandaloneCommand } from './descriptor/register.js';
 import { FORMAT_OPTIONS } from './schema/globalOptions.js';
-import { SKILLS_REPO_URL } from '../constants/links.js';
+import { getSkillsReleaseMetadata } from '../constants/links.js';
+import { RETIRED_SKILLS, RETIRED_SKILLS_CLEANUP, formatRetiredSkillsSummary, } from '../skills/retired.js';
 import { getRequestedStructuredOutputFormat, printHumanReadableLine, printSuccess, } from '../utils/output.js';
 import { DinoxError } from '../utils/errors.js';
+import { fetchLatestPublishedVersion } from '../utils/updateNotice.js';
 import { getPackageVersion } from '../utils/version.js';
 const PACKAGE_NAME = '@dinoxx/dinox-cli';
 const MAX_CAPTURED_UPDATE_OUTPUT_BYTES = 64 * 1024;
@@ -123,13 +125,20 @@ function resolveDeps(overrides) {
         detectPackageManager,
         runUpdate,
         getVersion: getPackageVersion,
+        getLatestVersion: fetchLatestPublishedVersion,
         log: logHumanReadable,
         ...overrides,
     };
 }
-function printSkillsReminder(log) {
-    log(`skills repo: ${SKILLS_REPO_URL}`);
-    log('ai reminder: review and update local Dinox skills after CLI updates (especially dino-dinox and dino-update-cli).');
+function printSkillsReminder(log, version) {
+    const skills = getSkillsReleaseMetadata(version);
+    log(`skills repo: ${skills.repository}`);
+    log(`skills release: ${skills.release}`);
+    log(`skills installer: ${skills.installer.name}@${skills.installer.version}`);
+    log(`skills install: ${skills.installCommand}`);
+    log(`ai reminder: update local Dinox skills to ${skills.tag} after this CLI update.`);
+    log(`retired skills: ${formatRetiredSkillsSummary()}`);
+    log(`retired skills cleanup: ${RETIRED_SKILLS_CLEANUP.guidance}`);
 }
 function parsePackageManagerOverride(value) {
     if (value === undefined || value === null || value === '') {
@@ -161,32 +170,60 @@ export function createUpdateCommandDescriptor(overrides = {}) {
             globalOptions: FORMAT_OPTIONS,
             output: {
                 type: 'structured',
-                summary: 'Updater result and bundled skills reminder',
-                fields: ['previousVersion', 'packageManager', 'package', 'target', 'skillsRepo'],
+                summary: 'Updater result and matching standalone skills release metadata',
+                fields: [
+                    'previousVersion',
+                    'version',
+                    'packageManager',
+                    'package',
+                    'target',
+                    'skillsRepo',
+                    'skillsVersion',
+                    'skillsTag',
+                    'skillsRelease',
+                    'skillsInstaller',
+                    'skillsInstallCommand',
+                    'retiredSkills',
+                    'retiredSkillsCleanup',
+                ],
             },
             examples: ['dino update', 'dino update --package-manager pnpm --format json'],
         },
         action: async (context) => {
             const pm = parsePackageManagerOverride(context.options.packageManager) ?? deps.detectPackageManager();
             const previousVersion = deps.getVersion();
+            const targetVersion = await deps.getLatestVersion();
             const structuredOutput = getRequestedStructuredOutputFormat() !== null;
             if (!structuredOutput) {
                 deps.log(`current version: ${previousVersion}`);
                 deps.log(`updating ${PACKAGE_NAME} via ${pm}...`);
             }
             await deps.runUpdate(pm, { structuredOutput });
+            const observedVersion = deps.getVersion();
+            const version = observedVersion !== previousVersion
+                ? observedVersion
+                : targetVersion ?? observedVersion;
+            const skills = getSkillsReleaseMetadata(version);
             if (structuredOutput) {
                 printSuccess({
                     previousVersion,
+                    version,
                     packageManager: pm,
                     package: PACKAGE_NAME,
                     target: 'latest',
-                    skillsRepo: SKILLS_REPO_URL,
+                    skillsRepo: skills.repository,
+                    skillsVersion: skills.version,
+                    skillsTag: skills.tag,
+                    skillsRelease: skills.release,
+                    skillsInstaller: skills.installer,
+                    skillsInstallCommand: skills.installCommand,
+                    retiredSkills: RETIRED_SKILLS,
+                    retiredSkillsCleanup: RETIRED_SKILLS_CLEANUP,
                 });
                 return;
             }
-            deps.log('done');
-            printSkillsReminder(deps.log);
+            deps.log(`done: ${version}`);
+            printSkillsReminder(deps.log, version);
         },
     };
 }

package/dist/commands/writeConfirmation.d.ts

@@ -0,0 +1,13 @@
+export type ConfirmedWriteOptions = {
+    dryRun?: boolean;
+    confirm?: boolean;
+    expectedCount?: number | null;
+};
+export declare function parseExpectedCount(value: unknown): number | null;
+export declare function assertConfirmedWrite(args: {
+    operation: string;
+    schemaPath: string;
+    actualCount: number;
+    options?: ConfirmedWriteOptions;
+}): void;
+export declare function assertWriteConfirmationProvided(operation: string, options?: ConfirmedWriteOptions): void;

package/dist/commands/writeConfirmation.js

@@ -0,0 +1,54 @@
+import { DinoxError } from '../utils/errors.js';
+export function parseExpectedCount(value) {
+    if (value === undefined || value === null || value === '') {
+        return null;
+    }
+    if (typeof value !== 'string') {
+        throw new DinoxError('--expected-count must be a non-negative integer');
+    }
+    const trimmed = value.trim();
+    if (!/^\d+$/.test(trimmed)) {
+        throw new DinoxError('--expected-count must be a non-negative integer');
+    }
+    const parsed = Number(trimmed);
+    if (!Number.isSafeInteger(parsed) || parsed < 0) {
+        throw new DinoxError('--expected-count must be a non-negative integer');
+    }
+    return parsed;
+}
+export function assertConfirmedWrite(args) {
+    if (args.options?.dryRun) {
+        return;
+    }
+    const options = args.options;
+    assertWriteConfirmationProvided(args.operation, options);
+    const expectedCount = options?.expectedCount;
+    if (expectedCount === undefined || expectedCount === null) {
+        throw new DinoxError(`${args.operation} requires --expected-count <n> for writes`);
+    }
+    if (expectedCount !== args.actualCount) {
+        throw new DinoxError(`--expected-count ${expectedCount} does not match current affected record count ${args.actualCount}`, {
+            code: 'PRECONDITION_FAILED',
+            details: {
+                expectedCount,
+                actualCount: args.actualCount,
+            },
+            suggestion: `Re-run the merge with --dry-run, review changes.affected_count, then retry with the matching count. See \`dino schema ${args.schemaPath} --format json\`.`,
+            suggestedAction: {
+                command: `dino schema ${args.schemaPath} --format json`,
+                reason: 'Review the merge guard contract, then run a fresh dry-run before retrying.',
+            },
+        });
+    }
+}
+export function assertWriteConfirmationProvided(operation, options) {
+    if (options?.dryRun) {
+        return;
+    }
+    if (!options?.confirm) {
+        throw new DinoxError(`${operation} requires --confirm for writes`);
+    }
+    if (options.expectedCount === undefined || options.expectedCount === null) {
+        throw new DinoxError(`${operation} requires --expected-count <n> for writes`);
+    }
+}

package/dist/config/resolve.js

@@ -2,8 +2,7 @@ import crypto from 'node:crypto';
 import { POWERSYNC_DEFAULT_ENDPOINT, POWERSYNC_DEFAULT_TOKEN_ENDPOINT, POWERSYNC_DEFAULT_UPLOAD_BASE_URL, } from './serviceEndpoints.js';
 import { normalizeAuthToken, readEnvAuthToken } from '../utils/authToken.js';
 import { parseSyncTimeoutMs } from '../utils/syncTimeout.js';
-const DEFAULT_UPLOAD_V4_PATH = '/powersync/v4/uploadData';
-const DEFAULT_UPLOAD_V2_PATH = '/powersync/v2/uploadData';
+const DEFAULT_UPLOAD_PATH = '/powersync/v6/uploadData';
 const DEFAULT_SYNC_TIMEOUT_MS = 300_000;
 function nonEmptyString(value) {
     if (typeof value !== 'string') {
@@ -24,8 +23,7 @@ export function fingerprintDaemonRuntimeConfig(config) {
             endpoint: config.powersync.endpoint,
             tokenEndpoint: config.powersync.tokenEndpoint,
             uploadBaseUrl: config.powersync.uploadBaseUrl,
-            uploadV4Path: config.powersync.uploadV4Path,
-            uploadV2Path: config.powersync.uploadV2Path,
+            uploadPath: config.powersync.uploadPath,
         },
         sync: {
             timeoutMs: config.sync.timeoutMs,
@@ -40,13 +38,11 @@ export function resolveConfig(raw) {
     const fileEmail = nonEmptyString(raw.auth?.email ?? undefined) ?? raw.auth?.email ?? undefined;
     const fileUserInfoSyncedAt = nonEmptyString(raw.auth?.userInfoSyncedAt);
     const fileTokenEndpoint = nonEmptyString(raw.powersync?.tokenEndpoint);
-    const fileUploadV4Path = nonEmptyString(raw.powersync?.uploadV4Path);
-    const fileUploadV2Path = nonEmptyString(raw.powersync?.uploadV2Path);
+    const fileUploadPath = nonEmptyString(raw.powersync?.uploadPath);
     const fileTimeoutMs = parseSyncTimeoutMs(raw.sync?.timeoutMs, { invalid: 'undefined' });
     const envAuth = readEnvAuthToken();
     const envTokenEndpoint = nonEmptyString(process.env.DINOX_POWERSYNC_TOKEN_ENDPOINT) ?? nonEmptyString(process.env.POWERSYNC_TOKEN_ENDPOINT);
-    const envUploadV4Path = nonEmptyString(process.env.DINOX_POWERSYNC_UPLOAD_V4_PATH);
-    const envUploadV2Path = nonEmptyString(process.env.DINOX_POWERSYNC_UPLOAD_V2_PATH);
+    const envUploadPath = nonEmptyString(process.env.DINOX_POWERSYNC_UPLOAD_PATH);
     const envTimeoutMs = parseSyncTimeoutMs(process.env.DINOX_SYNC_TIMEOUT_MS, { invalid: 'undefined' });
     const effectiveAuth = envAuth ?? fileAuth;
     const canReusePersistedIdentity = !envAuth || envAuth === fileAuth;
@@ -63,8 +59,7 @@ export function resolveConfig(raw) {
             endpoint: POWERSYNC_DEFAULT_ENDPOINT,
             tokenEndpoint: envTokenEndpoint ?? fileTokenEndpoint ?? POWERSYNC_DEFAULT_TOKEN_ENDPOINT,
             uploadBaseUrl: POWERSYNC_DEFAULT_UPLOAD_BASE_URL,
-            uploadV4Path: envUploadV4Path ?? fileUploadV4Path ?? DEFAULT_UPLOAD_V4_PATH,
-            uploadV2Path: envUploadV2Path ?? fileUploadV2Path ?? DEFAULT_UPLOAD_V2_PATH,
+            uploadPath: envUploadPath ?? fileUploadPath ?? DEFAULT_UPLOAD_PATH,
         },
         sync: {
             timeoutMs: envTimeoutMs ?? fileTimeoutMs ?? DEFAULT_SYNC_TIMEOUT_MS,

package/dist/config/types.d.ts

@@ -21,10 +21,8 @@ export type DinoxConfig = {
         tokenEndpoint?: string;
         /** Base URL for upload endpoints. */
         uploadBaseUrl?: string;
-        /** Defaults to /powersync/v4/uploadData */
-        uploadV4Path?: string;
-        /** Defaults to /powersync/v2/uploadData */
-        uploadV2Path?: string;
+        /** Batch upload endpoint path. Defaults to /powersync/v6/uploadData */
+        uploadPath?: string;
     };
     sync?: {
         /** Default sync/connect timeout in milliseconds. */
@@ -45,8 +43,7 @@ export type ResolvedDinoxConfig = {
         endpoint: string;
         tokenEndpoint: string;
         uploadBaseUrl: string;
-        uploadV4Path: string;
-        uploadV2Path: string;
+        uploadPath: string;
     };
     sync: {
         timeoutMs: number;