@dinoxx/dinox-cli 1.0.19 → 1.0.21

package/dist/commands/tags/repo.js

@@ -1,117 +1,53 @@
 import { generateId } from '../../utils/id.js';
 import { DinoxError } from '../../utils/errors.js';
-function canonicalizeTagPath(value) {
-    return value
-        .split(/[\\/]+/g)
-        .map((segment) => segment.trim())
-        .filter(Boolean)
-        .join('/');
-}
-async function getTagNodeColumns(db) {
-    const rows = await db.getAll('PRAGMA table_info(c_tag_node)', []);
-    return new Set(rows.map((row) => row.name).filter(Boolean));
-}
-async function loadTagNodes(db, columnNames) {
-    const fullPathExpr = columnNames.has('full_path')
-        ? (columnNames.has('path_key')
-            ? `TRIM(COALESCE(full_path, path_key, ''))`
-            : `TRIM(COALESCE(full_path, ''))`)
-        : `TRIM(COALESCE(path_key, ''))`;
-    const pathKeyExpr = columnNames.has('path_key')
-        ? (columnNames.has('full_path')
-            ? `TRIM(COALESCE(path_key, full_path, ''))`
-            : `TRIM(COALESCE(path_key, ''))`)
-        : `TRIM(COALESCE(full_path, ''))`;
-    const userIdExpr = columnNames.has('user_id')
-        ? `TRIM(COALESCE(user_id, ''))`
-        : `''`;
-    const emojiExpr = columnNames.has('emoji')
-        ? `TRIM(COALESCE(emoji, ''))`
-        : `''`;
-    const parentIdExpr = columnNames.has('parent_id') ? 'parent_id' : 'NULL';
-    const depthExpr = columnNames.has('depth') ? 'depth' : 'NULL';
-    const isActualExpr = columnNames.has('is_actual') ? 'is_actual' : 'NULL';
-    const isDelExpr = columnNames.has('is_del') ? 'is_del' : 'NULL';
-    const updatedOrderExpr = columnNames.has('updated_at') ? 'updated_at DESC,' : '';
-    const createdOrderExpr = columnNames.has('created_at') ? 'created_at DESC,' : '';
-    const rows = await db.getAll(`
-    SELECT
-      TRIM(COALESCE(id, '')) AS id,
-      ${fullPathExpr} AS full_path,
-      ${pathKeyExpr} AS path_key,
-      ${parentIdExpr} AS parent_id,
-      ${depthExpr} AS depth,
-      ${isActualExpr} AS is_actual,
-      ${isDelExpr} AS is_del,
-      ${userIdExpr} AS user_id,
-      ${emojiExpr} AS emoji
-    FROM c_tag_node
-    WHERE ${fullPathExpr} <> ''
-    ORDER BY
-      CASE WHEN is_del IS NULL OR is_del = 0 THEN 0 ELSE 1 END ASC,
-      CASE WHEN is_actual IS NULL THEN 0 ELSE is_actual END DESC,
-      ${updatedOrderExpr}
-      ${createdOrderExpr}
-      id DESC
-    `, []);
-    const nodes = new Map();
-    for (const row of rows) {
-        const id = row.id?.trim() ?? '';
-        if (!id) {
-            continue;
-        }
-        const fullPath = canonicalizeTagPath(row.full_path ?? row.path_key ?? '');
-        if (!fullPath) {
-            continue;
-        }
-        if (nodes.has(fullPath)) {
-            continue;
+import { withPowerSyncWriteTransaction } from '../../powersync/runtime.js';
+import { MAX_TAG_EMOJI_LENGTH, MAX_TAG_PATH_LENGTH, MAX_TAG_SEGMENT_LENGTH, assertMaxLength, canonicalizeTagPath, getLeafName, normalizeTagLookupKey, trimString, } from './model.js';
+import { assertCanWriteTag, getTableColumns, loadTagNodes, } from './store.js';
+export { canonicalizeTagPath } from './model.js';
+function tagNodeMapByPath(nodes) {
+    const map = new Map();
+    for (const node of nodes) {
+        const key = normalizeTagLookupKey(node.fullPath);
+        if (!map.has(key)) {
+            map.set(key, node);
         }
-        nodes.set(fullPath, {
-            id,
-            fullPath,
-            pathKey: canonicalizeTagPath(row.path_key ?? fullPath) || fullPath,
-            parentId: row.parent_id ?? null,
-            depth: typeof row.depth === 'number' ? row.depth : null,
-            isActual: typeof row.is_actual === 'number' ? row.is_actual : null,
-            isDel: typeof row.is_del === 'number' ? row.is_del : null,
-            userId: row.user_id?.trim() ?? '',
-            emoji: row.emoji?.trim() ?? '',
-        });
     }
-    return nodes;
+    return map;
+}
+function assertAddTagInput(input) {
+    const userId = trimString(input.userId);
+    const emoji = trimString(input.emoji);
+    const tag = canonicalizeTagPath(input.name);
+    if (!tag) {
+        throw new DinoxError('Tag name is required');
+    }
+    assertMaxLength('Tag path', tag, MAX_TAG_PATH_LENGTH);
+    assertMaxLength('Tag name', getLeafName(tag), MAX_TAG_SEGMENT_LENGTH);
+    assertMaxLength('Tag emoji', emoji, MAX_TAG_EMOJI_LENGTH);
+    return { tag, userId, emoji };
 }
-export async function listTags(db) {
+export async function listTags(db, input = {}) {
+    const userId = trimString(input.userId);
+    const userFilter = userId
+        ? `AND (TRIM(COALESCE(user_id, '')) = ? OR TRIM(COALESCE(user_id, '')) = '')`
+        : '';
     const rows = await db.getAll(`
     SELECT DISTINCT TRIM(COALESCE(full_path, path_key, '')) AS tag
     FROM c_tag_node
     WHERE (is_del IS NULL OR is_del = 0)
       AND (is_actual IS NULL OR is_actual != 0)
       AND TRIM(COALESCE(full_path, path_key, '')) <> ''
+      ${userFilter}
     ORDER BY tag COLLATE NOCASE ASC
-    `, []);
+    `, userId ? [userId] : []);
     return rows.map((row) => row.tag?.trim() ?? '').filter(Boolean);
 }
 export async function addTag(db, input) {
-    const userId = input.userId.trim();
-    const emoji = typeof input.emoji === 'string' ? input.emoji.trim() : '';
-    const tag = canonicalizeTagPath(input.name);
-    if (!tag) {
-        throw new DinoxError('Tag name is required');
-    }
-    const columnNames = await getTagNodeColumns(db);
-    if (!columnNames.has('id')) {
-        throw new DinoxError('c_tag_node table is missing required column: id');
-    }
-    if (!columnNames.has('full_path') && !columnNames.has('path_key')) {
-        throw new DinoxError('c_tag_node table is missing required column: full_path or path_key');
-    }
-    const requiredUserColumns = ['user_id'].filter((column) => columnNames.has(column));
-    if (requiredUserColumns.length > 0 && !userId) {
-        throw new DinoxError(`c_tag_node insert requires ${requiredUserColumns.join(', ')}. Missing persisted userId. Run \`dino auth login\` first.`);
-    }
-    const nodesByPath = await loadTagNodes(db, columnNames);
-    const existingLeaf = nodesByPath.get(tag);
+    const { tag, userId, emoji } = assertAddTagInput(input);
+    const columnNames = await getTableColumns(db, 'c_tag_node');
+    assertCanWriteTag(columnNames, userId, 'insert');
+    const nodesByPath = tagNodeMapByPath(await loadTagNodes(db, columnNames, { userId, dedupeByPath: true }));
+    const existingLeaf = nodesByPath.get(normalizeTagLookupKey(tag));
     if (existingLeaf && existingLeaf.isDel !== 1 && existingLeaf.isActual === 1) {
         throw new DinoxError(`Tag already exists: ${tag}`, {
             details: {
@@ -128,113 +64,115 @@ export async function addTag(db, input) {
     let restoredNodes = 0;
     let parentId = null;
     let leafId = '';
-    for (let i = 0; i < segments.length; i += 1) {
-        const path = segments.slice(0, i + 1).join('/');
-        const isLeaf = i === segments.length - 1;
-        const existing = nodesByPath.get(path);
-        if (existing) {
-            const assignments = [];
-            const params = [];
-            const setValue = (column, value) => {
-                if (!columnNames.has(column)) {
-                    return;
-                }
-                assignments.push(`${column} = ?`);
-                params.push(value);
-            };
-            if (existing.isDel === 1) {
-                setValue('is_del', 0);
-            }
-            if (isLeaf && existing.isActual !== 1) {
-                setValue('is_actual', 1);
-            }
-            if (columnNames.has('updated_at')) {
-                setValue('updated_at', timestamp);
-            }
-            if (columnNames.has('user_id') && !existing.userId) {
-                setValue('user_id', userId);
-            }
-            if (columnNames.has('parent_id') && existing.parentId == null && parentId !== null) {
-                setValue('parent_id', parentId);
-            }
-            if (columnNames.has('depth') && existing.depth == null) {
-                setValue('depth', i);
-            }
-            if (columnNames.has('full_path') && existing.fullPath !== path) {
-                setValue('full_path', path);
-            }
-            if (columnNames.has('path_key') && existing.pathKey !== path) {
-                setValue('path_key', path);
-            }
-            if (isLeaf && emoji && columnNames.has('emoji') && existing.emoji !== emoji) {
-                setValue('emoji', emoji);
-            }
-            if (assignments.length > 0) {
-                params.push(existing.id);
-                await db.execute(`
-          UPDATE c_tag_node
-          SET ${assignments.join(', ')}
-          WHERE id = ?
-          `, params);
+    await withPowerSyncWriteTransaction(db, async (tx) => {
+        for (let i = 0; i < segments.length; i += 1) {
+            const path = segments.slice(0, i + 1).join('/');
+            const isLeaf = i === segments.length - 1;
+            const existing = nodesByPath.get(normalizeTagLookupKey(path));
+            if (existing) {
+                const assignments = [];
+                const params = [];
+                const setValue = (column, value) => {
+                    if (!columnNames.has(column)) {
+                        return;
+                    }
+                    assignments.push(`${column} = ?`);
+                    params.push(value);
+                };
                 if (existing.isDel === 1) {
-                    restoredNodes += 1;
-                    existing.isDel = 0;
+                    setValue('is_del', 0);
                 }
                 if (isLeaf && existing.isActual !== 1) {
-                    existing.isActual = 1;
+                    setValue('is_actual', 1);
+                }
+                if (columnNames.has('updated_at')) {
+                    setValue('updated_at', timestamp);
+                }
+                if (columnNames.has('user_id') && !existing.userId) {
+                    setValue('user_id', userId);
                 }
+                if (columnNames.has('parent_id') && existing.parentId == null && parentId !== null) {
+                    setValue('parent_id', parentId);
+                }
+                if (columnNames.has('depth') && existing.depth == null) {
+                    setValue('depth', i);
+                }
+                if (columnNames.has('full_path') && existing.fullPath !== path) {
+                    setValue('full_path', path);
+                }
+                if (columnNames.has('path_key') && existing.pathKey !== path) {
+                    setValue('path_key', path);
+                }
+                if (isLeaf && emoji && columnNames.has('emoji') && existing.emoji !== emoji) {
+                    setValue('emoji', emoji);
+                }
+                if (assignments.length > 0) {
+                    params.push(existing.id);
+                    await tx.execute(`
+            UPDATE c_tag_node
+            SET ${assignments.join(', ')}
+            WHERE id = ?
+            `, params);
+                    if (existing.isDel === 1) {
+                        restoredNodes += 1;
+                        existing.isDel = 0;
+                    }
+                    if (isLeaf && existing.isActual !== 1) {
+                        existing.isActual = 1;
+                    }
+                }
+                parentId = existing.id;
+                if (isLeaf) {
+                    leafId = existing.id;
+                }
+                continue;
             }
-            parentId = existing.id;
+            const id = generateId();
+            const insertEntries = [];
+            const pushInsert = (column, value) => {
+                if (!columnNames.has(column)) {
+                    return;
+                }
+                insertEntries.push([column, value]);
+            };
+            pushInsert('id', id);
+            pushInsert('user_id', userId);
+            pushInsert('emoji', isLeaf && emoji ? emoji : null);
+            pushInsert('full_path', path);
+            pushInsert('path_key', path);
+            pushInsert('parent_id', parentId);
+            pushInsert('depth', i);
+            pushInsert('is_actual', isLeaf ? 1 : 0);
+            pushInsert('is_del', 0);
+            pushInsert('created_at', timestamp);
+            pushInsert('updated_at', timestamp);
+            pushInsert('meta', '{}');
+            const insertColumns = insertEntries.map(([column]) => column);
+            const placeholders = insertColumns.map(() => '?').join(', ');
+            const insertParams = insertEntries.map(([, value]) => value);
+            await tx.execute(`
+        INSERT INTO c_tag_node (${insertColumns.join(', ')})
+        VALUES (${placeholders})
+        `, insertParams);
+            const node = {
+                id,
+                fullPath: path,
+                pathKey: path,
+                parentId,
+                depth: i,
+                isActual: isLeaf ? 1 : 0,
+                isDel: 0,
+                userId,
+                emoji: isLeaf && emoji ? emoji : '',
+            };
+            nodesByPath.set(normalizeTagLookupKey(path), node);
+            createdNodes += 1;
+            parentId = id;
             if (isLeaf) {
-                leafId = existing.id;
+                leafId = id;
             }
-            continue;
-        }
-        const id = generateId();
-        const insertEntries = [];
-        const pushInsert = (column, value) => {
-            if (!columnNames.has(column)) {
-                return;
-            }
-            insertEntries.push([column, value]);
-        };
-        pushInsert('id', id);
-        pushInsert('user_id', userId);
-        pushInsert('emoji', isLeaf && emoji ? emoji : null);
-        pushInsert('full_path', path);
-        pushInsert('path_key', path);
-        pushInsert('parent_id', parentId);
-        pushInsert('depth', i);
-        pushInsert('is_actual', isLeaf ? 1 : 0);
-        pushInsert('is_del', 0);
-        pushInsert('created_at', timestamp);
-        pushInsert('updated_at', timestamp);
-        pushInsert('meta', '{}');
-        const insertColumns = insertEntries.map(([column]) => column);
-        const placeholders = insertColumns.map(() => '?').join(', ');
-        const insertParams = insertEntries.map(([, value]) => value);
-        await db.execute(`
-      INSERT INTO c_tag_node (${insertColumns.join(', ')})
-      VALUES (${placeholders})
-      `, insertParams);
-        const node = {
-            id,
-            fullPath: path,
-            pathKey: path,
-            parentId,
-            depth: i,
-            isActual: isLeaf ? 1 : 0,
-            isDel: 0,
-            userId,
-            emoji: isLeaf && emoji ? emoji : '',
-        };
-        nodesByPath.set(path, node);
-        createdNodes += 1;
-        parentId = id;
-        if (isLeaf) {
-            leafId = id;
         }
-    }
+    });
     if (!leafId) {
         throw new DinoxError(`Failed to create tag: ${tag}`);
     }
@@ -246,25 +184,11 @@ export async function addTag(db, input) {
     };
 }
 export async function inspectAddTag(db, input) {
-    const userId = input.userId.trim();
-    const emoji = typeof input.emoji === 'string' ? input.emoji.trim() : '';
-    const tag = canonicalizeTagPath(input.name);
-    if (!tag) {
-        throw new DinoxError('Tag name is required');
-    }
-    const columnNames = await getTagNodeColumns(db);
-    if (!columnNames.has('id')) {
-        throw new DinoxError('c_tag_node table is missing required column: id');
-    }
-    if (!columnNames.has('full_path') && !columnNames.has('path_key')) {
-        throw new DinoxError('c_tag_node table is missing required column: full_path or path_key');
-    }
-    const requiredUserColumns = ['user_id'].filter((column) => columnNames.has(column));
-    if (requiredUserColumns.length > 0 && !userId) {
-        throw new DinoxError(`c_tag_node insert requires ${requiredUserColumns.join(', ')}. Missing persisted userId. Run \`dino auth login\` first.`);
-    }
-    const nodesByPath = await loadTagNodes(db, columnNames);
-    const existingLeaf = nodesByPath.get(tag);
+    const { tag, userId, emoji } = assertAddTagInput(input);
+    const columnNames = await getTableColumns(db, 'c_tag_node');
+    assertCanWriteTag(columnNames, userId, 'insert');
+    const nodesByPath = tagNodeMapByPath(await loadTagNodes(db, columnNames, { userId, dedupeByPath: true }));
+    const existingLeaf = nodesByPath.get(normalizeTagLookupKey(tag));
     if (existingLeaf && existingLeaf.isDel !== 1 && existingLeaf.isActual === 1) {
         throw new DinoxError(`Tag already exists: ${tag}`, {
             details: {
@@ -281,7 +205,7 @@ export async function inspectAddTag(db, input) {
     for (let i = 0; i < segments.length; i += 1) {
         const path = segments.slice(0, i + 1).join('/');
         const isLeaf = i === segments.length - 1;
-        const existing = nodesByPath.get(path);
+        const existing = nodesByPath.get(normalizeTagLookupKey(path));
         if (!existing) {
             createdPaths.push(path);
             continue;

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

@@ -0,0 +1,28 @@
+import type { AbstractPowerSyncDatabase } from '@powersync/common';
+import type { MutableTagNode, TagListItem } from './model.js';
+type TableName = 'c_tag_node' | 'c_note';
+export declare function getTableColumns(db: AbstractPowerSyncDatabase, table: TableName): Promise<Set<string>>;
+export declare function assertRequiredColumns(table: string, columnNames: Set<string>, required: string[]): void;
+export declare function assertCanWriteTag(columnNames: Set<string>, userId: string, action: 'insert' | 'update'): void;
+export declare function loadTagNodes(db: AbstractPowerSyncDatabase, columnNames: Set<string>, options?: {
+    userId?: string;
+    dedupeByPath?: boolean;
+}): Promise<MutableTagNode[]>;
+export declare function activeTagNodes(nodes: MutableTagNode[]): MutableTagNode[];
+export declare function actualActiveTagNodes(nodes: MutableTagNode[]): MutableTagNode[];
+export declare function tagNodeByPath(nodes: MutableTagNode[], options?: {
+    actualOnly?: boolean;
+}): Map<string, MutableTagNode>;
+export declare function requireActiveTagPath(nodes: MutableTagNode[], rawPath: string, label: string): MutableTagNode;
+export declare function descendantsOf(nodes: MutableTagNode[], root: MutableTagNode, includeRoot?: boolean): MutableTagNode[];
+export declare function toTagListItem(node: MutableTagNode): TagListItem;
+export declare function assertWritableTagNodes(nodes: MutableTagNode[], ids: Set<string>, userId: string): void;
+export declare function ensureNoTagPathConflict(nodes: MutableTagNode[], changes: Array<{
+    id: string;
+    toPath: string;
+}>): void;
+export declare function parentIdForPath(path: string, nodes: MutableTagNode[], changes: Array<{
+    id: string;
+    toPath: string;
+}>): string | null;
+export {};

package/dist/commands/tags/store.js

@@ -0,0 +1,166 @@
+import { DinoxError } from '../../utils/errors.js';
+import { REQUIRED_TAG_NODE_COLUMNS, canonicalizeTagPath, getLeafName, isActiveTagNode, isActualTagNode, normalizeTagLookupKey, parentPathOf, trimString, } from './model.js';
+export async function getTableColumns(db, table) {
+    const sql = table === 'c_tag_node' ? 'PRAGMA table_info(c_tag_node)' : 'PRAGMA table_info(c_note)';
+    const rows = await db.getAll(sql, []);
+    return new Set(rows.map((row) => trimString(row.name)).filter(Boolean));
+}
+export function assertRequiredColumns(table, columnNames, required) {
+    const missing = required.filter((column) => !columnNames.has(column));
+    if (missing.length > 0) {
+        throw new DinoxError(`${table} table is missing required columns: ${missing.join(', ')}`);
+    }
+}
+export function assertCanWriteTag(columnNames, userId, action) {
+    assertRequiredColumns('c_tag_node', columnNames, REQUIRED_TAG_NODE_COLUMNS);
+    if (!userId.trim()) {
+        throw new DinoxError(`c_tag_node ${action} requires user_id. Missing resolved userId. Run \`dino auth login\` first, or set DINOX_TOKEN and run an online command so the CLI can resolve the token identity.`);
+    }
+}
+export async function loadTagNodes(db, columnNames, options = {}) {
+    const userId = trimString(options.userId);
+    const userFilter = userId
+        ? `AND (TRIM(COALESCE(user_id, '')) = ? OR TRIM(COALESCE(user_id, '')) = '')`
+        : '';
+    const rows = await db.getAll(`
+    SELECT
+      TRIM(COALESCE(id, '')) AS id,
+      TRIM(COALESCE(full_path, path_key, '')) AS full_path,
+      TRIM(COALESCE(path_key, full_path, '')) AS path_key,
+      TRIM(COALESCE(parent_id, '')) AS parent_id,
+      depth,
+      is_actual,
+      is_del,
+      TRIM(COALESCE(user_id, '')) AS user_id,
+      TRIM(COALESCE(emoji, '')) AS emoji
+    FROM c_tag_node
+    WHERE TRIM(COALESCE(id, '')) <> ''
+      AND TRIM(COALESCE(full_path, path_key, '')) <> ''
+      ${userFilter}
+    ORDER BY
+      CASE WHEN is_del IS NULL OR is_del = 0 THEN 0 ELSE 1 END ASC,
+      CASE WHEN is_actual IS NULL THEN 0 ELSE is_actual END DESC,
+      updated_at DESC,
+      created_at DESC,
+      id DESC
+    `, userId ? [userId] : []);
+    const nodes = [];
+    const seenPaths = new Set();
+    for (const row of rows) {
+        const id = trimString(row.id);
+        const fullPath = canonicalizeTagPath(row.full_path ?? row.path_key ?? '');
+        if (!id || !fullPath) {
+            continue;
+        }
+        const key = normalizeTagLookupKey(fullPath);
+        if (options.dedupeByPath && seenPaths.has(key)) {
+            continue;
+        }
+        seenPaths.add(key);
+        nodes.push({
+            id,
+            fullPath,
+            pathKey: canonicalizeTagPath(row.path_key ?? fullPath) || fullPath,
+            parentId: trimString(row.parent_id) || null,
+            depth: typeof row.depth === 'number' ? row.depth : null,
+            isActual: typeof row.is_actual === 'number' ? row.is_actual : null,
+            isDel: typeof row.is_del === 'number' ? row.is_del : null,
+            userId: trimString(row.user_id),
+            emoji: trimString(row.emoji),
+        });
+    }
+    return nodes;
+}
+export function activeTagNodes(nodes) {
+    return nodes.filter(isActiveTagNode);
+}
+export function actualActiveTagNodes(nodes) {
+    return nodes.filter((node) => isActiveTagNode(node) && isActualTagNode(node));
+}
+export function tagNodeByPath(nodes, options = {}) {
+    const map = new Map();
+    const candidates = options.actualOnly ? actualActiveTagNodes(nodes) : activeTagNodes(nodes);
+    for (const node of candidates) {
+        const key = normalizeTagLookupKey(node.fullPath);
+        if (!map.has(key)) {
+            map.set(key, node);
+        }
+    }
+    return map;
+}
+export function requireActiveTagPath(nodes, rawPath, label) {
+    const path = canonicalizeTagPath(rawPath);
+    if (!path) {
+        throw new DinoxError(`${label} is required`);
+    }
+    const node = tagNodeByPath(nodes).get(normalizeTagLookupKey(path));
+    if (!node) {
+        throw new DinoxError(`Unknown tag path: ${path}`);
+    }
+    return node;
+}
+export function descendantsOf(nodes, root, includeRoot = true) {
+    const rootKey = `${normalizeTagLookupKey(root.fullPath)}/`;
+    return activeTagNodes(nodes)
+        .filter((node) => {
+        if (includeRoot && node.id === root.id) {
+            return true;
+        }
+        return normalizeTagLookupKey(node.fullPath).startsWith(rootKey);
+    })
+        .sort((left, right) => left.fullPath.localeCompare(right.fullPath));
+}
+export function toTagListItem(node) {
+    return {
+        id: node.id,
+        tag: node.fullPath,
+        name: getLeafName(node.fullPath),
+        parentId: node.parentId,
+        depth: node.depth,
+        emoji: node.emoji,
+    };
+}
+export function assertWritableTagNodes(nodes, ids, userId) {
+    const foreign = nodes
+        .filter((node) => ids.has(node.id))
+        .filter((node) => node.userId && node.userId !== userId);
+    if (foreign.length > 0) {
+        throw new DinoxError(`Tags belong to a different user: ${foreign.map((node) => node.fullPath).join(', ')}`);
+    }
+}
+export function ensureNoTagPathConflict(nodes, changes) {
+    const changedIds = new Set(changes.map((change) => change.id));
+    const activePaths = new Map();
+    for (const node of activeTagNodes(nodes)) {
+        if (changedIds.has(node.id)) {
+            continue;
+        }
+        activePaths.set(normalizeTagLookupKey(node.fullPath), node);
+    }
+    const seen = new Set();
+    for (const change of changes) {
+        const key = normalizeTagLookupKey(change.toPath);
+        const existing = activePaths.get(key);
+        if (existing) {
+            throw new DinoxError(`Target tag path already exists: ${change.toPath}`, {
+                details: { type: 'tag_path_conflict', path: change.toPath, existingId: existing.id },
+            });
+        }
+        if (seen.has(key)) {
+            throw new DinoxError(`Duplicate target tag path in operation: ${change.toPath}`);
+        }
+        seen.add(key);
+    }
+}
+export function parentIdForPath(path, nodes, changes) {
+    const parentPath = parentPathOf(path);
+    if (!parentPath) {
+        return null;
+    }
+    const key = normalizeTagLookupKey(parentPath);
+    const changedParent = changes.find((change) => normalizeTagLookupKey(change.toPath) === key);
+    if (changedParent) {
+        return changedParent.id;
+    }
+    return tagNodeByPath(nodes).get(key)?.id ?? null;
+}