@dboio/cli 0.13.2 → 0.15.0

package/src/commands/login.js

@@ -1,5 +1,5 @@
 import { Command } from 'commander';
-import { loadConfig, saveUserInfo, saveUserProfile, ensureGitignore } from '../lib/config.js';
+import { loadConfig, initConfig, saveUserInfo, saveUserProfile, ensureGitignore } from '../lib/config.js';
 import { DboClient } from '../lib/client.js';
 import { log } from '../lib/logger.js';
 
@@ -13,13 +13,24 @@ import { log } from '../lib/logger.js';
  */
 export async function performLogin(domain, knownUsername) {
   const config = await loadConfig();
+  const inquirer = (await import('inquirer')).default;
+
+  // Prompt for domain if not provided and not configured
+  if (!domain && !config.domain) {
+    const { domain: inputDomain } = await inquirer.prompt([
+      { type: 'input', name: 'domain', message: 'Domain (e.g. myapp.dbo.io):' },
+    ]);
+    if (!inputDomain) throw new Error('Domain is required.');
+    domain = inputDomain.trim();
+    await initConfig(domain);
+  }
+
   const client = new DboClient({ domain });
 
   let username = knownUsername || config.username;
   let password;
 
   // Interactive prompt for missing credentials
-  const inquirer = (await import('inquirer')).default;
   const answers = await inquirer.prompt([
     { type: 'input', name: 'username', message: 'Username (email):', default: username || undefined, when: !username },
     { type: 'password', name: 'password', message: 'Password:', mask: '*' },
@@ -83,7 +94,23 @@ export const loginCommand = new Command('login')
   .action(async (options) => {
     try {
       const config = await loadConfig();
-      const client = new DboClient({ domain: options.domain });
+      const inquirer = (await import('inquirer')).default;
+      let domain = options.domain;
+
+      // Prompt for domain if not provided and not configured
+      if (!domain && !config.domain) {
+        const { domain: inputDomain } = await inquirer.prompt([
+          { type: 'input', name: 'domain', message: 'Domain (e.g. myapp.dbo.io):' },
+        ]);
+        if (!inputDomain) {
+          log.error('Domain is required.');
+          process.exit(1);
+        }
+        domain = inputDomain.trim();
+        await initConfig(domain);
+      }
+
+      const client = new DboClient({ domain });
 
       let username = options.username || options.email || options.phone;
       let password = options.password || options.passkey;
@@ -93,7 +120,6 @@ export const loginCommand = new Command('login')
 
       // Interactive prompt if still missing
       if (!username || !password) {
-        const inquirer = (await import('inquirer')).default;
         const answers = await inquirer.prompt([
           { type: 'input', name: 'username', message: 'Username (email):', default: config.username, when: !username },
           { type: 'password', name: 'password', message: 'Password:', mask: '*', when: !password },

package/src/commands/mv.js

@@ -13,8 +13,9 @@ import {
   BINS_DIR
 } from '../lib/structure.js';
 import { findMetadataFiles } from '../lib/diff.js';
-import { findMetadataForCompanion } from '../lib/filenames.js';
+import { isMetadataFile, parseMetaFilename, findMetadataForCompanion } from '../lib/filenames.js';
 import { runPendingMigrations } from '../lib/migrations.js';
+import { removeDeployEntry, upsertDeployEntry } from '../lib/deploy-config.js';
 
 export const mvCommand = new Command('mv')
   .description('Move files or bins to a new location and update metadata')
@@ -200,7 +201,7 @@ function checkCircularReference(sourceBinId, targetBinId, structure) {
  * Resolve a file path to its metadata.json path.
  */
 function resolveMetaPath(filePath) {
-  if (filePath.endsWith('.metadata.json')) {
+  if (isMetadataFile(basename(filePath)) || filePath.endsWith('.metadata.json')) {
     return filePath;
   }
   const dir = dirname(filePath);
@@ -544,13 +545,13 @@ async function mvFile(sourceFile, targetBinId, structure, options) {
   // Calculate paths
   const targetDir = resolveBinPath(targetBinId, structure);
   const sourceDir = dirname(metaPath);
-  const contentFileName = sourceFile.endsWith('.metadata.json')
+  const contentFileName = (isMetadataFile(basename(sourceFile)) || sourceFile.endsWith('.metadata.json'))
     ? null
     : basename(sourceFile);
   const metaFileName = basename(metaPath);
 
   // Determine display name
-  const displayName = basename(metaPath, '.metadata.json');
+  const displayName = parseMetaFilename(basename(metaPath))?.naturalBase ?? basename(metaPath, '.metadata.json');
   const targetBin = structure[targetBinId];
   const targetBinName = targetBin ? targetBin.name : String(targetBinId);
   const targetBinFullPath = targetBin ? `${BINS_DIR}/${targetBin.fullPath}` : targetDir;
@@ -672,6 +673,18 @@ async function mvFile(sourceFile, targetBinId, structure, options) {
     }
   }
 
+  if (!options.dryRun) {
+    // Update deploy config: remove old entry (by UID), re-insert with new path + correct key
+    await removeDeployEntry(uid);
+    if (newContentPath) {
+      const col = (meta._contentColumns || [])[0] || 'Content';
+      await upsertDeployEntry(newContentPath, uid, entity, col);
+    } else if (meta._mediaFile && String(meta._mediaFile).startsWith('@')) {
+      const movedMediaPath = join(targetDir, String(meta._mediaFile).substring(1));
+      await upsertDeployEntry(movedMediaPath, uid, entity, 'File');
+    }
+  }
+
   if (options.dryRun) {
     log.info(`[DRY RUN] Would move "${displayName}" to "${targetBinName}" (${targetBinFullPath})`);
   } else {

package/src/commands/push.js

@@ -12,16 +12,26 @@ import { checkStoredTicket, applyStoredTicketToSubmission, clearRecordTicket, cl
 import { checkModifyKey, isModifyKeyError, handleModifyKeyError } from '../lib/modify-key.js';
 import { resolveTransactionKey } from '../lib/transaction-key.js';
 import { setFileTimestamps } from '../lib/timestamps.js';
-import { stripUidFromFilename, renameToUidConvention, hasUidInFilename, findMetadataForCompanion } from '../lib/filenames.js';
+import { stripUidFromFilename, renameToUidConvention, hasUidInFilename, isMetadataFile, parseMetaFilename, findMetadataForCompanion } from '../lib/filenames.js';
 import { findMetadataFiles, findFileInProject, findByUID } from '../lib/diff.js';
 import { loadIgnore } from '../lib/ignore.js';
 import { detectChangedColumns, findBaselineEntry, detectOutputChanges, getAllUserColumns, isReference, resolveReferencePath, detectBinChanges, synthesizeBinMetadata } from '../lib/delta.js';
 import { BINS_DIR, ENTITY_DIR_NAMES, loadStructureFile, findBinByPath } from '../lib/structure.js';
-import { ensureTrashIcon } from '../lib/folder-icon.js';
+import { ensureTrashIcon, setFileTag } from '../lib/tagging.js';
 import { checkToeStepping } from '../lib/toe-stepping.js';
 import { runPendingMigrations } from '../lib/migrations.js';
 import { findUnaddedFiles, detectBinFile, submitAdd } from './add.js';
 
+function _getMetaCompanionPaths(meta, metaPath) {
+  const dir = dirname(metaPath);
+  const paths = [];
+  for (const col of (meta._contentColumns || [])) {
+    const ref = meta[col];
+    if (ref && String(ref).startsWith('@')) paths.push(join(dir, String(ref).substring(1)));
+  }
+  return paths;
+}
+
 /**
  * Resolve an @reference file path to an absolute filesystem path.
  * "@filename.ext"         → relative to the metadata file's directory (existing behaviour)
@@ -306,13 +316,20 @@ async function moveWillDeleteToTrash(entry) {
 async function pushSingleFile(filePath, client, options, modifyKey = null, transactionKey = 'RowUID') {
   // Find the metadata file
   let metaPath;
-  if (filePath.endsWith('.metadata.json')) {
+  if (isMetadataFile(basename(filePath)) || filePath.endsWith('.metadata.json')) {
     // User passed the metadata file directly — use it as-is
     metaPath = filePath;
   } else {
-    const dir = dirname(filePath);
-    const base = basename(filePath, extname(filePath));
-    metaPath = join(dir, `${base}.metadata.json`);
+    // Try findMetadataForCompanion first (handles both new and legacy formats)
+    const found = await findMetadataForCompanion(filePath);
+    if (found) {
+      metaPath = found;
+    } else {
+      // Fallback: old convention
+      const dir = dirname(filePath);
+      const base = basename(filePath, extname(filePath));
+      metaPath = join(dir, `${base}.metadata.json`);
+    }
   }
 
   let meta;
@@ -717,7 +734,7 @@ async function pushDirectory(dirPath, client, options, modifyKey = null, transac
   const totalRecords = toPush.length + outputCompoundFiles.length + binPushItems.length;
   if (!options.ticket && totalRecords > 0) {
     const recordSummary = [
-      ...toPush.map(r => basename(r.metaPath, '.metadata.json')),
+      ...toPush.map(r => { const p = parseMetaFilename(basename(r.metaPath)); return p ? p.naturalBase : basename(r.metaPath, '.metadata.json'); }),
       ...outputCompoundFiles.map(r => basename(r.metaPath, '.json')),
       ...binPushItems.map(r => `bin:${r.meta.Name}`),
     ].join(', ');
@@ -861,6 +878,13 @@ async function pushDirectory(dirPath, client, options, modifyKey = null, transac
     await updateBaselineAfterPush(baseline, successfulPushes);
   }
 
+  // Re-tag successfully pushed files as Synced (best-effort)
+  for (const { meta, metaPath } of successfulPushes) {
+    for (const filePath of _getMetaCompanionPaths(meta, metaPath)) {
+      setFileTag(filePath, 'synced').catch(() => {});
+    }
+  }
+
   log.info(`Push complete: ${succeeded} succeeded, ${failed} failed, ${skipped} skipped`);
 }
 
@@ -1221,7 +1245,8 @@ async function pushFromMetadata(meta, metaPath, client, options, changedColumns
   }
 
   const fieldLabel = changedColumns ? `${dataExprs.length} changed field(s)${isMediaUpload ? ' + media file' : ''}` : `${dataExprs.length} field(s)`;
-  log.info(`Pushing ${basename(metaPath, '.metadata.json')} (${entity}:${rowKeyValue}) — ${fieldLabel}`);
+  const pushDisplayName = parseMetaFilename(basename(metaPath))?.naturalBase ?? basename(metaPath, '.metadata.json');
+  log.info(`Pushing ${pushDisplayName} (${entity}:${rowKeyValue}) — ${fieldLabel}`);
 
   // Apply stored ticket if no --ticket flag
   const storedTicket = await applyStoredTicketToSubmission(dataExprs, entity, uid || id, uid || id, options);
@@ -1449,7 +1474,7 @@ async function checkPathMismatch(meta, metaPath, entity, options) {
   if (ENTITY_DIR_NAMES.has(entity)) return;
 
   const metaDir = dirname(metaPath);
-  const metaBase = basename(metaPath, '.metadata.json');
+  const metaBase = parseMetaFilename(basename(metaPath))?.naturalBase ?? basename(metaPath, '.metadata.json');
 
   // Find the content file referenced by @filename
   const contentCols = meta._contentColumns || [];

package/src/commands/rm.js

@@ -5,9 +5,10 @@ import { log } from '../lib/logger.js';
 import { formatError } from '../lib/formatter.js';
 import { addDeleteEntry, removeAppJsonReference } from '../lib/config.js';
 import { findMetadataFiles } from '../lib/diff.js';
-import { findMetadataForCompanion } from '../lib/filenames.js';
+import { isMetadataFile, parseMetaFilename, findMetadataForCompanion } from '../lib/filenames.js';
 import { loadStructureFile, findBinByPath, findChildBins, BINS_DIR } from '../lib/structure.js';
 import { runPendingMigrations } from '../lib/migrations.js';
+import { removeDeployEntry } from '../lib/deploy-config.js';
 
 export const rmCommand = new Command('rm')
   .description('Remove a file or directory locally and stage server deletions for the next dbo push')
@@ -42,7 +43,7 @@ export const rmCommand = new Command('rm')
  * Resolve a file path to its metadata.json path.
  */
 function resolveMetaPath(filePath) {
-  if (filePath.endsWith('.metadata.json')) {
+  if (isMetadataFile(basename(filePath)) || filePath.endsWith('.metadata.json')) {
     return filePath;
   }
   const dir = dirname(filePath);
@@ -101,7 +102,7 @@ async function rmFileRecord(metaPath, options, { skipPrompt = false } = {}) {
     localFiles.push(join(metaDir, String(meta._mediaFile).substring(1)));
   }
 
-  const displayName = basename(metaPath, '.metadata.json');
+  const displayName = parseMetaFilename(basename(metaPath))?.naturalBase ?? basename(metaPath, '.metadata.json');
 
   // Prompt if needed
   if (!skipPrompt && !options.force) {
@@ -121,6 +122,7 @@ async function rmFileRecord(metaPath, options, { skipPrompt = false } = {}) {
   // Stage deletion (include metaPath for Trash workflow in push.js)
   const expression = `RowID:del${rowId};entity:${entity}=true`;
   await addDeleteEntry({ UID: uid, RowID: rowId, entity, name: displayName, expression, metaPath });
+  await removeDeployEntry(uid);
   log.success(`  Staged: ${displayName} → ${expression}`);
 
   // Remove from app.json
@@ -205,7 +207,7 @@ async function rmFile(filePath, options) {
     localFiles.push(join(metaDir, String(meta._mediaFile).substring(1)));
   }
 
-  const displayName = basename(metaPath, '.metadata.json');
+  const displayName = parseMetaFilename(basename(metaPath))?.naturalBase ?? basename(metaPath, '.metadata.json');
   log.info(`Removing "${displayName}" (${entity}:${uid || rowId})`);
   for (const f of localFiles) {
     log.dim(`  ${f}`);

package/src/commands/tag.js

@@ -0,0 +1,65 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { tagProjectFiles } from '../lib/tagging.js';
+import { loadTagConfig, saveTagConfig } from '../lib/config.js';
+import { loadIgnore } from '../lib/ignore.js';
+import { join } from 'path';
+
+export const tagCommand = new Command('tag')
+  .description('Apply sync-status tags (Finder color tags / gio emblems) to project files')
+  .argument('[path]', 'File or directory to tag (defaults to entire project)')
+  .option('--clear', 'Remove all dbo:* tags from companion files')
+  .option('--status', 'Show counts of synced / modified / untracked / trashed files')
+  .option('--enable', 'Enable automatic tagging after clone/pull/push')
+  .option('--disable', 'Disable automatic tagging after clone/pull/push')
+  .option('--verbose', 'Log each file with its status')
+  .action(async (pathArg, options) => {
+    if (options.enable) {
+      await saveTagConfig(true);
+      console.log(chalk.green('✔ Automatic file tagging enabled'));
+      return;
+    }
+    if (options.disable) {
+      await saveTagConfig(false);
+      console.log(chalk.yellow('Automatic file tagging disabled'));
+      return;
+    }
+
+    // Verify project is initialized
+    const ig = await loadIgnore().catch(() => null);
+    if (!ig) {
+      console.error(chalk.red('Not a dbo project'));
+      process.exit(1);
+    }
+
+    const dir = pathArg ? join(process.cwd(), pathArg) : process.cwd();
+
+    if (options.clear) {
+      await tagProjectFiles({ clearAll: true, dir, verbose: options.verbose });
+      console.log(chalk.green('✔ All dbo:* tags cleared'));
+      return;
+    }
+
+    const counts = await tagProjectFiles({ verbose: options.verbose, dir });
+
+    if (counts === null) {
+      const { tagFiles } = await loadTagConfig();
+      if (!tagFiles) {
+        console.log(chalk.yellow('File tagging is disabled. Run `dbo tag --enable` to enable.'));
+      } else {
+        console.log(chalk.dim('File tagging is not supported on this platform.'));
+      }
+      return;
+    }
+
+    if (options.status || options.verbose) {
+      console.log(
+        `${chalk.green(counts.synced)} synced, ` +
+        `${chalk.blue(counts.modified)} modified, ` +
+        `${chalk.yellow(counts.untracked)} untracked, ` +
+        `${chalk.red(counts.trashed)} trashed`
+      );
+    } else {
+      console.log(chalk.green(`✔ Tags applied (${counts.synced} synced, ${counts.modified} modified, ${counts.untracked} untracked)`));
+    }
+  });

package/src/lib/config.js

@@ -936,3 +936,31 @@ export async function loadScriptsLocal() {
     throw new SyntaxError(`Invalid JSON in .dbo/scripts.local.json: ${err.message}`);
   }
 }
+
+// ─── Tag Config ───────────────────────────────────────────────────────────────
+
+/**
+ * Load the tagFiles setting from config.json.
+ * @returns {Promise<{tagFiles: boolean}>} defaults to true
+ */
+export async function loadTagConfig() {
+  try {
+    const raw = await readFile(join(process.cwd(), DBO_DIR, CONFIG_FILE), 'utf8');
+    const config = JSON.parse(raw);
+    return { tagFiles: config.tagFiles !== false };
+  } catch {
+    return { tagFiles: true };
+  }
+}
+
+/**
+ * Enable or disable automatic file tagging by writing to config.json.
+ * @param {boolean} enabled
+ */
+export async function saveTagConfig(enabled) {
+  const configPath = join(process.cwd(), DBO_DIR, CONFIG_FILE);
+  let config = {};
+  try { config = JSON.parse(await readFile(configPath, 'utf8')); } catch {}
+  config.tagFiles = enabled;
+  await writeFile(configPath, JSON.stringify(config, null, 2));
+}

package/src/lib/deploy-config.js

@@ -0,0 +1,137 @@
+import { readFile, writeFile, mkdir } from 'fs/promises';
+import { join, relative, extname, basename } from 'path';
+import { log } from './logger.js';
+
+const DEPLOY_CONFIG_FILE = '.dbo/deploy_config.json';
+
+function deployConfigPath() {
+  return join(process.cwd(), DEPLOY_CONFIG_FILE);
+}
+
+function sortedKeys(obj) {
+  return Object.fromEntries(Object.entries(obj).sort(([a], [b]) => a.localeCompare(b)));
+}
+
+/**
+ * Load .dbo/deploy_config.json. Returns { deployments: {} } if missing.
+ * Throws on malformed JSON (do not silently recreate — would lose existing entries).
+ */
+export async function loadDeployConfig() {
+  try {
+    const raw = await readFile(deployConfigPath(), 'utf8');
+    return JSON.parse(raw);
+  } catch (err) {
+    if (err.code === 'ENOENT') return { deployments: {} };
+    throw new Error(`Failed to parse ${DEPLOY_CONFIG_FILE}: ${err.message}`);
+  }
+}
+
+/**
+ * Write .dbo/deploy_config.json with alphabetically sorted deployment keys.
+ */
+export async function saveDeployConfig(config) {
+  await mkdir(join(process.cwd(), '.dbo'), { recursive: true });
+  const sorted = { ...config, deployments: sortedKeys(config.deployments || {}) };
+  await writeFile(deployConfigPath(), JSON.stringify(sorted, null, 2) + '\n');
+}
+
+/**
+ * Derive the <ext>:<basename> deploy key from a relative file path.
+ * Finds the shortest key not already occupied in existingDeployments.
+ *
+ * @param {string} relPath             - e.g. "lib/bins/app/assets/css/colors.css"
+ * @param {Object} existingDeployments - current deployments object (to avoid collisions)
+ * @returns {string}                   - e.g. "css:colors"
+ */
+export function buildDeployKey(relPath, existingDeployments = {}) {
+  const normalized = relPath.replace(/\\/g, '/');
+  const parts = normalized.split('/');
+  const filename = parts[parts.length - 1];
+  const ext = extname(filename).slice(1).toLowerCase();   // '' if no dot
+  const base = ext ? basename(filename, `.${ext}`) : filename;
+  const prefix = ext || 'file';
+
+  // Try simplest key first, then progressively add parent segments for disambiguation
+  const dirParts = parts.slice(0, -1);
+  const candidates = [`${prefix}:${base}`];
+  for (let depth = 1; depth <= dirParts.length; depth++) {
+    const suffix = dirParts.slice(-depth).join('/');
+    candidates.push(`${prefix}:${suffix}/${base}`);
+  }
+  candidates.push(`${prefix}:${normalized}`);   // absolute fallback
+
+  for (const key of candidates) {
+    if (!existingDeployments[key]) return key;
+  }
+  return `${prefix}:${normalized}`;  // always unique
+}
+
+/**
+ * Insert or update a deploy config entry for a companion file.
+ *
+ * Behaviour:
+ *  - If an entry with the same UID already exists → update file, entity, column in place
+ *    (keeps the existing key, avoids duplicate keys on re-clone)
+ *  - If a new key collision exists with a DIFFERENT UID → log a warning, skip
+ *  - Otherwise → create new entry with the shortest unique key
+ *
+ * @param {string} companionPath - Absolute path to the companion file
+ * @param {string} uid           - Record UID (from metadata)
+ * @param {string} entity        - Entity type (e.g. 'content', 'extension', 'media')
+ * @param {string} [column]      - Column name (e.g. 'Content', 'CSS')
+ */
+export async function upsertDeployEntry(companionPath, uid, entity, column) {
+  if (!uid || !companionPath) return;
+  const config = await loadDeployConfig();
+  const { deployments } = config;
+
+  const relPath = relative(process.cwd(), companionPath).replace(/\\/g, '/');
+
+  // Find if this UID is already tracked under any key
+  const existingKey = Object.keys(deployments).find(k => deployments[k].uid === uid);
+
+  if (existingKey) {
+    // Update path + metadata in place — keeps existing key, avoids duplicates on re-clone
+    deployments[existingKey] = {
+      ...deployments[existingKey],
+      file: relPath,
+      entity,
+      ...(column ? { column } : {}),
+    };
+    config.deployments = sortedKeys(deployments);
+    await saveDeployConfig(config);
+    return;
+  }
+
+  // New entry — build unique key avoiding all occupied keys
+  const key = buildDeployKey(relPath, deployments);
+
+  if (deployments[key]) {
+    // buildDeployKey returned an occupied key (should not happen — means all path segments collide)
+    log.warn(`Deploy config: skipping auto-registration of "${relPath}" — key "${key}" already exists for a different record. Add manually to ${DEPLOY_CONFIG_FILE}.`);
+    return;
+  }
+
+  const entry = { uid, file: relPath, entity };
+  if (column) entry.column = column;
+  deployments[key] = entry;
+  config.deployments = sortedKeys(deployments);
+  await saveDeployConfig(config);
+}
+
+/**
+ * Remove the deploy config entry matching a given UID.
+ * No-op if no entry with that UID exists.
+ *
+ * @param {string} uid - Record UID to remove
+ */
+export async function removeDeployEntry(uid) {
+  if (!uid) return;
+  const config = await loadDeployConfig();
+  const { deployments } = config;
+  const key = Object.keys(deployments).find(k => deployments[k].uid === uid);
+  if (!key) return;
+  delete deployments[key];
+  config.deployments = sortedKeys(deployments);
+  await saveDeployConfig(config);
+}

package/src/lib/diff.js

@@ -5,6 +5,7 @@ import { loadIgnore } from './ignore.js';
 import { parseServerDate, setFileTimestamps } from './timestamps.js';
 import { loadConfig, loadUserInfo, loadAppJsonBaseline } from './config.js';
 import { findBaselineEntry } from './delta.js';
+import { isMetadataFile, parseMetaFilename } from './filenames.js';
 import { log } from './logger.js';
 
 // ─── Baseline Cache ─────────────────────────────────────────────────────────
@@ -155,10 +156,10 @@ export async function findMetadataFiles(dir, ig) {
       const relPath = relative(process.cwd(), fullPath).replace(/\\/g, '/');
       if (ig.ignores(relPath + '/') || ig.ignores(relPath)) continue;
       results.push(...await findMetadataFiles(fullPath, ig));
-    } else if (entry.name.endsWith('.metadata.json') && !entry.name.startsWith('__WILL_DELETE__')) {
+    } else if (isMetadataFile(entry.name) && !entry.name.startsWith('__WILL_DELETE__')) {
       const relPath = relative(process.cwd(), fullPath).replace(/\\/g, '/');
       if (!ig.ignores(relPath)) results.push(fullPath);
-    } else if (entry.name.endsWith('.json') && !entry.name.endsWith('.metadata.json') && !entry.name.includes('.CustomSQL.') && entry.name.includes('~')) {
+    } else if (entry.name.endsWith('.json') && !isMetadataFile(entry.name) && !entry.name.includes('.CustomSQL.') && entry.name.includes('~')) {
       // Output hierarchy root files: Name~UID.json (or legacy _output~Name~UID.json)
       // Exclude old-format child output files — they contain a dot-prefixed
       // child-type segment (.column~, .join~, .filter~) before .json.
@@ -495,7 +496,7 @@ export async function compareRecord(metaPath, config, serverRecordsMap) {
   }
 
   const metaDir = dirname(metaPath);
-  const metaBase = basename(metaPath, '.metadata.json');
+  const metaBase = parseMetaFilename(basename(metaPath))?.naturalBase ?? basename(metaPath, '.metadata.json');
   const contentCols = localMeta._contentColumns || [];
   const fieldDiffs = [];
 
@@ -799,7 +800,7 @@ export async function inlineDiffAndMerge(serverRow, metaPath, config, options =
   }
 
   const metaDir = dirname(metaPath);
-  const metaBase = basename(metaPath, '.metadata.json');
+  const metaBase = parseMetaFilename(basename(metaPath))?.naturalBase ?? basename(metaPath, '.metadata.json');
   const contentCols = localMeta._contentColumns || [];
   const fieldDiffs = [];