@symbo.ls/cli 2.33.35 → 2.33.36

package/bin/collab.js

@@ -11,6 +11,14 @@ import { stringifyFunctionsForTransport } from '../helpers/transportUtils.js'
 import { getCurrentProjectData } from '../helpers/apiUtils.js'
 import { computeCoarseChanges, computeOrdersForTuples, preprocessChanges } from '../helpers/changesUtils.js'
 import { createFs } from './fs.js'
+import { stripOrderFields } from '../helpers/orderUtils.js'
+import { normalizeKeys } from '../helpers/compareUtils.js'
+import {
+  augmentProjectWithLocalPackageDependencies,
+  ensureSchemaDependencies,
+  findNearestPackageJson,
+  syncPackageJsonDependencies
+} from '../helpers/dependenciesUtils.js'
 
 // Lazy import socket.io-client and chokidar to avoid adding cost for non-collab users
 async function importDeps() {
@@ -21,6 +29,29 @@ async function importDeps() {
   return { io, chokidar }
 }
 
+function toExportNameFromFileStem(stem) {
+  // Mirror fs.js behavior loosely: kebab/snake/path -> camelCase export name.
+  // e.g. "add-network" -> "addNetwork"
+  if (!stem || typeof stem !== 'string') return stem
+  const parts = stem.split(/[^a-zA-Z0-9]+/).filter(Boolean)
+  if (!parts.length) return stem
+  const first = parts[0]
+  return (
+    first +
+    parts
+      .slice(1)
+      .map((p) => (p ? p[0].toUpperCase() + p.slice(1) : ''))
+      .join('')
+  )
+}
+
+function toPagesRouteKeyFromFileStem(stem) {
+  // createFs writes `/foo` -> pages/foo.js and `/` -> pages/main.js
+  if (!stem || typeof stem !== 'string') return stem
+  if (stem === 'main') return '/'
+  return `/${stem}`
+}
+
 function debounce(fn, wait) {
   let t = null
   const debounced = (...args) => {
@@ -52,6 +83,8 @@ export async function startCollab(options) {
     resolveDistDir(symbolsConfig) ||
     path.join(process.cwd(), 'smbls')
 
+  const packageJsonPath = findNearestPackageJson(process.cwd())
+
   if (!appKey) {
     console.log(chalk.red('Missing project key. Add it to symbols.json or .symbols/config.json'))
     process.exit(1)
@@ -141,9 +174,19 @@ export async function startCollab(options) {
   }
 
   async function writeProjectAndFs(fullObj) {
+    // Avoid persisting ordering metadata into local repository files
+    const persistedObj = stripOrderFields(fullObj)
+    // Keep schema.dependencies consistent and sync dependencies into local package.json
+    try {
+      ensureSchemaDependencies(persistedObj)
+      if (packageJsonPath && persistedObj?.dependencies) {
+        syncPackageJsonDependencies(packageJsonPath, persistedObj.dependencies, { overwriteExisting: true })
+      }
+    } catch (_) {}
+
     const { projectPath } = getConfigPaths()
     try {
-      await fs.promises.writeFile(projectPath, JSON.stringify(fullObj, null, 2))
+      await fs.promises.writeFile(projectPath, JSON.stringify(persistedObj, null, 2))
     } catch (_) {}
     // Avoid echoing the changes we are about to materialize
     suppressLocalChanges = true
@@ -152,7 +195,7 @@ export async function startCollab(options) {
       sendLocalChanges.cancel()
     }
     try {
-      await createFs(fullObj, distDir, { update: true, metadata: false })
+      await createFs(persistedObj, distDir, { update: true, metadata: false })
     } finally {
       // Extend suppression window to allow file events to settle fully
       suppressUntil = Date.now() + suppressionWindowMs
@@ -167,6 +210,12 @@ export async function startCollab(options) {
     { branch, includePending: true }
   )
   const initialData = prime?.data || {}
+  try {
+    ensureSchemaDependencies(initialData)
+    if (packageJsonPath && initialData?.dependencies) {
+      syncPackageJsonDependencies(packageJsonPath, initialData.dependencies, { overwriteExisting: true })
+    }
+  } catch (_) {}
   const etag = prime?.etag || null
   writeLock({
     etag,
@@ -180,7 +229,7 @@ export async function startCollab(options) {
   try {
     const { projectPath } = getConfigPaths()
     await fs.promises.mkdir(path.dirname(projectPath), { recursive: true })
-    await fs.promises.writeFile(projectPath, JSON.stringify(initialData, null, 2))
+    await fs.promises.writeFile(projectPath, JSON.stringify(stripOrderFields(initialData), null, 2))
   } catch (_) {}
   currentBase = { ...(initialData || {}) }
 
@@ -240,9 +289,8 @@ export async function startCollab(options) {
         : preprocessChanges(currentBase || {}, payload?.changes || []).granularChanges
       if (!Array.isArray(tuples) || !tuples.length) return
       applyTuples(currentBase, tuples)
-      if (Array.isArray(payload?.orders) && payload.orders.length) {
-        applyOrders(currentBase, payload.orders)
-      }
+      // If server omits schema.dependencies updates, ensure it's present locally
+      ensureSchemaDependencies(currentBase)
       await writeProjectAndFs(currentBase)
       writeLock({ pulledAt: new Date().toISOString() })
       if (options.verbose) console.log(chalk.gray('Applied incoming ops to local workspace'))
@@ -268,7 +316,8 @@ export async function startCollab(options) {
       const { loadModule } = await import('./require.js')
       await buildDirectory(distDir, outputDir)
       const loaded = await loadModule(outputFile, { silent: true, noCache: true })
-      return loaded
+      // Ensure a plain, mutable object (avoid getter-only export objects)
+      return normalizeKeys(loaded)
     } catch (e) {
       if (options.verbose) console.error('Build failed while watching:', e.message)
       return null
@@ -312,9 +361,17 @@ export async function startCollab(options) {
         const filename = entries[j]
         if (!filename.endsWith('.js') || filename === 'index.js') continue
 
-        const key = filename.slice(0, -3)
+        const fileStem = filename.slice(0, -3)
+        const key = type === 'pages'
+          ? toPagesRouteKeyFromFileStem(fileStem)
+          : fileStem
+        const altKey = type === 'pages' ? fileStem : null
+
+        // Skip if already present (support legacy/broken non-slash page keys too)
         if (Object.prototype.hasOwnProperty.call(container, key)) continue
+        if (altKey && Object.prototype.hasOwnProperty.call(container, altKey)) continue
         if (Object.prototype.hasOwnProperty.call(baseSection, key)) continue
+        if (altKey && Object.prototype.hasOwnProperty.call(baseSection, altKey)) continue
 
         const compiledPath = path.join(outputDir, type, filename)
         let mod
@@ -332,7 +389,14 @@ export async function startCollab(options) {
 
         let value = null
         if (mod && typeof mod === 'object') {
-          value = mod.default || mod[key] || null
+          const exportName = toExportNameFromFileStem(fileStem)
+          value =
+            mod.default ||
+            mod[exportName] ||
+            mod[fileStem] ||
+            mod[key] ||
+            (altKey ? mod[altKey] : null) ||
+            null
         }
         if (!value || typeof value !== 'object') continue
 
@@ -343,9 +407,11 @@ export async function startCollab(options) {
 
   const sendLocalChanges = debounce(async () => {
     if (suppressLocalChanges) return
-    const local = await loadLocalProject()
+    let local = await loadLocalProject()
     if (!local) return
     await augmentLocalWithNewFsItems(local)
+    // Include package.json deps into local snapshot so dependency edits can be synced
+    local = augmentProjectWithLocalPackageDependencies(local, packageJsonPath) || local
     // Prepare safe, JSON-serialisable snapshots for diffing & transport
     const base = currentBase || {}
     const safeBase = stringifyFunctionsForTransport(base)
@@ -371,9 +437,6 @@ export async function startCollab(options) {
         ? granularChanges
         : changes
       applyTuples(currentBase, tuplesToApply)
-      if (Array.isArray(orders) && orders.length) {
-        applyOrders(currentBase, orders)
-      }
     } catch (e) {
       if (options.verbose) {
         console.error('Failed to apply local ops to in-memory base', e)
@@ -407,6 +470,18 @@ export async function startCollab(options) {
     .on('change', onFsEvent)
     .on('unlink', onFsEvent)
 
+  // Also watch package.json for dependency changes
+  if (packageJsonPath) {
+    const pkgWatcher = chokidar.watch(packageJsonPath, {
+      ignoreInitial: true,
+      persistent: true
+    })
+    pkgWatcher
+      .on('add', onFsEvent)
+      .on('change', onFsEvent)
+      .on('unlink', onFsEvent)
+  }
+
   console.log(chalk.green('Watching local changes and syncing over socket...'))
   console.log(chalk.gray('Press Ctrl+C to exit'))
 }

package/bin/fetch.js

@@ -12,6 +12,8 @@ import { getCurrentProjectData } from '../helpers/apiUtils.js'
 import { showAuthRequiredMessages } from '../helpers/buildMessages.js'
 import { loadSymbolsConfig, resolveDistDir } from '../helpers/symbolsConfig.js'
 import { loadCliConfig, readLock, writeLock, updateLegacySymbolsJson, getConfigPaths } from '../helpers/config.js'
+import { ensureSchemaDependencies, findNearestPackageJson, syncPackageJsonDependencies } from '../helpers/dependenciesUtils.js'
+import { stripOrderFields } from '../helpers/orderUtils.js'
 const { isObjectLike } = (utils.default || utils)
 
 const debugMsg = chalk.dim(
@@ -81,7 +83,9 @@ export const fetchFromCli = async (opts) => {
     try {
       const { projectPath } = getConfigPaths()
       await fs.promises.mkdir(path.dirname(projectPath), { recursive: true })
-      await fs.promises.writeFile(projectPath, JSON.stringify(payload, null, 2))
+      // Ensure schema.dependencies exists for payload.dependencies
+      ensureSchemaDependencies(payload)
+      await fs.promises.writeFile(projectPath, JSON.stringify(stripOrderFields(payload), null, 2))
     } catch (e) {
       console.error(chalk.bold.red('\nError writing file'))
       if (verbose) console.error(e)
@@ -89,6 +93,19 @@ export const fetchFromCli = async (opts) => {
       process.exit(1)
     }
 
+    // Sync project dependencies into local package.json
+    try {
+      const packageJsonPath = findNearestPackageJson(process.cwd())
+      if (packageJsonPath && payload?.dependencies) {
+        const res = syncPackageJsonDependencies(packageJsonPath, payload.dependencies, { overwriteExisting: true })
+        if (verbose && res?.ok && res.changed) {
+          console.log(chalk.gray(`Updated package.json dependencies from fetched project data`))
+        }
+      }
+    } catch (e) {
+      if (verbose) console.error('Failed updating package.json dependencies', e)
+    }
+
     const { version: fetchedVersion, ...config } = payload
 
     for (const t in config) {
@@ -117,9 +134,9 @@ export const fetchFromCli = async (opts) => {
     }
 
     if (update || force) {
-      createFs(payload, distDir, { update: true, metadata: false })
+      createFs(stripOrderFields(payload), distDir, { update: true, metadata: false })
     } else {
-      createFs(payload, distDir, { metadata: false })
+      createFs(stripOrderFields(payload), distDir, { metadata: false })
     }
 }
 

package/bin/fs.js

@@ -226,25 +226,38 @@ export async function createFs (
     const dirs = []
 
     if (body[key] && isObject(body[key])) {
-      const promises = Object.entries(body[key])
-        // Skip meta/reserved identifier entries (e.g. "__order", "default")
-        .filter(([entryKey]) => !shouldSkipEntryKey(entryKey))
-        .map(
-        async ([entryKey, value]) => {
-          // if pages
+      // Normalize + dedupe entries before writing files. This is especially
+      // important for `pages` where both "/node" and "node" can otherwise map
+      // to the same filename and cause concurrent writes / corrupted output.
+      const normalized = new Map()
+      for (const [rawEntryKey, value] of Object.entries(body[key])) {
+        if (shouldSkipEntryKey(rawEntryKey)) continue
+
+        let entryKey = rawEntryKey
+        if (key === 'pages') {
           if (entryKey.startsWith('/')) entryKey = entryKey.slice(1)
           if (entryKey === '') entryKey = 'main'
           if (entryKey.includes('*')) entryKey = 'fallback'
+        }
 
-          await createOrUpdateFile(dirPath, entryKey, value, update)
-          dirs.push(entryKey)
+        // Prefer the canonical slash-prefixed route form when there are collisions
+        const priority = key === 'pages' && rawEntryKey.startsWith('/') ? 1 : 0
+        const existing = normalized.get(entryKey)
+        if (!existing || priority > existing.priority) {
+          normalized.set(entryKey, { value, priority })
         }
-      )
+      }
+
+      const promises = Array.from(normalized.entries()).map(async ([entryKey, info]) => {
+        await createOrUpdateFile(dirPath, entryKey, info.value, update)
+        dirs.push(entryKey)
+      })
 
       await Promise.all(promises)
     }
 
-    await generateIndexjsFile(dirs, dirPath, key)
+    // Ensure deterministic + unique index generation
+    await generateIndexjsFile(Array.from(new Set(dirs)), dirPath, key)
   }
 
   async function createOrUpdateFile(dirPath, childKey, value, update) {

package/bin/push.js

@@ -14,6 +14,8 @@ import { computeCoarseChanges, computeOrdersForTuples, preprocessChanges } from
 import { showAuthRequiredMessages, showProjectNotFoundMessages, showBuildErrorMessages } from '../helpers/buildMessages.js'
 import { loadSymbolsConfig, resolveDistDir } from '../helpers/symbolsConfig.js'
 import { loadCliConfig, readLock, writeLock, updateLegacySymbolsJson } from '../helpers/config.js'
+import { stripOrderFields } from '../helpers/orderUtils.js'
+import { augmentProjectWithLocalPackageDependencies, findNearestPackageJson } from '../helpers/dependenciesUtils.js'
 
 
 async function buildLocalProject (distDir) {
@@ -117,11 +119,16 @@ export async function pushProjectChanges(options) {
       resolveDistDir(symbolsConfig) ||
       path.join(process.cwd(), 'smbls')
 
+    const packageJsonPath = findNearestPackageJson(process.cwd())
+
     // Build and load local project
     console.log(chalk.dim('Building local project...'))
     let localProject
     try {
       localProject = await buildLocalProject(distDir)
+      localProject = augmentProjectWithLocalPackageDependencies(localProject, packageJsonPath) || localProject
+      // Never push `__order` (platform metadata) from local files
+      localProject = stripOrderFields(localProject)
       console.log(chalk.gray('Local project built successfully'))
     } catch (buildError) {
       showBuildErrorMessages(buildError)
@@ -146,8 +153,8 @@ export async function pushProjectChanges(options) {
     console.log(chalk.gray('Server state fetched successfully'))
 
     // Calculate coarse local changes vs server snapshot (or base)
-    const base = normalizeKeys(serverProject || {})
-    const changes = computeCoarseChanges(base, localProject)
+    const base = normalizeKeys(stripOrderFields(serverProject || {}))
+    const changes = computeCoarseChanges(base, stripOrderFields(localProject))
 
     if (!changes.length) {
       console.log(chalk.bold.yellow('\nNo changes to push'))
@@ -178,7 +185,7 @@ export async function pushProjectChanges(options) {
     const operationId = `cli-${Date.now()}`
     // Derive granular changes against server base and compute orders using local for pending children
     const { granularChanges } = preprocessChanges(base, changes)
-    const orders = computeOrdersForTuples(localProject, granularChanges)
+    const orders = computeOrdersForTuples(stripOrderFields(localProject), granularChanges)
     const result = await postProjectChanges(projectId, authToken, {
       branch,
       type,

package/bin/sync.js

@@ -16,6 +16,13 @@ import { createFs } from './fs.js'
 import { showAuthRequiredMessages, showBuildErrorMessages } from '../helpers/buildMessages.js'
 import { loadSymbolsConfig, resolveDistDir } from '../helpers/symbolsConfig.js'
 import { loadCliConfig, readLock, writeLock, getConfigPaths, updateLegacySymbolsJson } from '../helpers/config.js'
+import { stripOrderFields } from '../helpers/orderUtils.js'
+import {
+  augmentProjectWithLocalPackageDependencies,
+  ensureSchemaDependencies,
+  findNearestPackageJson,
+  syncPackageJsonDependencies
+} from '../helpers/dependenciesUtils.js'
 
 async function buildLocalProject(distDir) {
   try {
@@ -167,6 +174,8 @@ export async function syncProjectChanges(options) {
       resolveDistDir(symbolsConfig) ||
       path.join(process.cwd(), 'smbls')
 
+    const packageJsonPath = findNearestPackageJson(process.cwd())
+
     if (options.verbose) {
       console.log(chalk.dim('\nSync configuration:'))
       console.log(chalk.gray(`App Key: ${chalk.cyan(appKey)}`))
@@ -182,6 +191,10 @@ export async function syncProjectChanges(options) {
     let localProject
     try {
       localProject = await buildLocalProject(distDir)
+      // Include local package.json dependencies into the project object for diffing/sync
+      localProject = augmentProjectWithLocalPackageDependencies(localProject, packageJsonPath) || localProject
+      // Never sync/persist `__order` (platform metadata)
+      localProject = stripOrderFields(localProject)
       console.log(chalk.gray('Local project built successfully'))
     } catch (buildError) {
       showBuildErrorMessages(buildError)
@@ -192,7 +205,7 @@ export async function syncProjectChanges(options) {
     const baseSnapshot = (() => {
       try {
         const raw = fs.readFileSync(projectPath, 'utf8')
-        return JSON.parse(raw)
+        return stripOrderFields(JSON.parse(raw))
       } catch (_) {
         return {}
       }
@@ -208,10 +221,15 @@ export async function syncProjectChanges(options) {
     const serverProject = serverResp.data || {}
     console.log(chalk.gray('Server data fetched successfully'))
 
+    // Ensure schema.dependencies exists wherever dependencies exist (base/remote/local)
+    ensureSchemaDependencies(baseSnapshot)
+    ensureSchemaDependencies(serverProject)
+    ensureSchemaDependencies(localProject)
+
     // Generate coarse local and remote changes via simple three-way rebase
     const base = normalizeKeys(baseSnapshot || {})
-    const local = normalizeKeys(localProject || {})
-    const remote = normalizeKeys(serverProject || {})
+    const local = normalizeKeys(stripOrderFields(localProject || {}))
+    const remote = normalizeKeys(stripOrderFields(serverProject || {}))
     const { ours, theirs, conflicts, finalChanges } = threeWayRebase(base, local, remote)
 
     const localChanges = ours
@@ -290,9 +308,17 @@ export async function syncProjectChanges(options) {
     )
     const updatedServerData = updated?.data || {}
 
+    // Ensure fetched snapshot has dependency schema and sync deps into local package.json
+    try {
+      ensureSchemaDependencies(updatedServerData)
+      if (packageJsonPath && updatedServerData?.dependencies) {
+        syncPackageJsonDependencies(packageJsonPath, updatedServerData.dependencies, { overwriteExisting: true })
+      }
+    } catch (_) {}
+
     // Apply changes to local files
     console.log(chalk.dim('Updating local files...'))
-    await createFs(updatedServerData, distDir, { update: true, metadata: false })
+    await createFs(stripOrderFields(updatedServerData), distDir, { update: true, metadata: false })
     console.log(chalk.gray('Local files updated successfully'))
 
     console.log(chalk.bold.green('\nProject synced successfully!'))
@@ -308,7 +334,7 @@ export async function syncProjectChanges(options) {
     })
     try {
       const { projectPath } = getConfigPaths()
-      await fs.promises.writeFile(projectPath, JSON.stringify(updatedServerData, null, 2))
+      await fs.promises.writeFile(projectPath, JSON.stringify(stripOrderFields(updatedServerData), null, 2))
     } catch (_) {}
 
   } catch (error) {

package/helpers/changesUtils.js

@@ -10,6 +10,9 @@ export const DATA_KEYS = [
 ]
 
 const SCHEMA_CODE_TYPES = new Set(['pages', 'components', 'functions', 'methods', 'snippets'])
+// Types that should auto-create a schema entry when a new key is added.
+// NOTE: dependencies schema objects are not "code", but we still want them present for transport.
+const SCHEMA_AUTO_CREATE_TYPES = new Set([...SCHEMA_CODE_TYPES, 'dependencies'])
 
 function stripMetaDeep(val) {
   if (Array.isArray(val)) {
@@ -103,7 +106,7 @@ export function computeCoarseChanges(base, local, keys = DATA_KEYS) {
         // New item
         changes.push(['update', [typeKey, itemKey], bVal])
         const hadSchema = aSchemaSection && Object.prototype.hasOwnProperty.call(aSchemaSection, itemKey)
-        if (SCHEMA_CODE_TYPES.has(typeKey) && !hadSchema) {
+        if (SCHEMA_AUTO_CREATE_TYPES.has(typeKey) && !hadSchema) {
           const schemaItem = buildSchemaItemFromData(typeKey, itemKey, bVal)
           if (schemaItem) {
             changes.push(['update', ['schema', typeKey, itemKey], schemaItem])
@@ -112,8 +115,10 @@ export function computeCoarseChanges(base, local, keys = DATA_KEYS) {
       } else if (!equal(aVal, bVal)) {
         // Updated item
         changes.push(['update', [typeKey, itemKey], bVal])
-        // When an item changes, drop its schema.code to be regenerated
-        changes.push(['delete', ['schema', typeKey, itemKey, 'code']])
+        // When a code-backed item changes, drop its schema.code to be regenerated
+        if (SCHEMA_CODE_TYPES.has(typeKey)) {
+          changes.push(['delete', ['schema', typeKey, itemKey, 'code']])
+        }
       }
     }
   }
@@ -277,6 +282,20 @@ export function buildSchemaCodeFromObject(obj) {
 function buildSchemaItemFromData(type, key, value) {
   const schemaType = type
 
+  if (schemaType === 'dependencies') {
+    const version =
+      typeof value === 'string' && value.length
+        ? value
+        : (value && typeof value === 'object' && typeof value.version === 'string' ? value.version : 'latest')
+    return {
+      key,
+      resolvedVersion: version,
+      type: 'dependency',
+      version,
+      status: 'done'
+    }
+  }
+
   const base = {
     title: key,
     key,

package/helpers/dependenciesUtils.js

@@ -0,0 +1,174 @@
+import fs from 'fs'
+import path from 'path'
+
+function isPlainObject(val) {
+  return !!val && typeof val === 'object' && !Array.isArray(val)
+}
+
+export function findNearestPackageJson(startDir = process.cwd()) {
+  let cur = path.resolve(startDir)
+  for (let i = 0; i < 50; i++) {
+    const candidate = path.join(cur, 'package.json')
+    if (fs.existsSync(candidate)) return candidate
+    const parent = path.dirname(cur)
+    if (parent === cur) break
+    cur = parent
+  }
+  return null
+}
+
+export function readPackageJson(packageJsonPath) {
+  try {
+    const raw = fs.readFileSync(packageJsonPath, 'utf8')
+    const parsed = JSON.parse(raw)
+    return isPlainObject(parsed) ? parsed : null
+  } catch (_) {
+    return null
+  }
+}
+
+export function writePackageJson(packageJsonPath, json) {
+  try {
+    fs.writeFileSync(packageJsonPath, JSON.stringify(json, null, 2) + '\n')
+    return true
+  } catch (_) {
+    return false
+  }
+}
+
+export function getPackageDependencies(packageJsonPath) {
+  const pkg = readPackageJson(packageJsonPath)
+  if (!pkg) return {}
+  const deps = isPlainObject(pkg.dependencies) ? pkg.dependencies : {}
+  return { ...deps }
+}
+
+function sortObjectKeys(obj) {
+  if (!isPlainObject(obj)) return obj
+  const out = {}
+  Object.keys(obj).sort().forEach((k) => {
+    out[k] = obj[k]
+  })
+  return out
+}
+
+/**
+ * Merge dependency map into package.json dependencies.
+ * - If overwriteExisting is true, remote versions win.
+ * - If false, only missing deps are added.
+ */
+export function syncPackageJsonDependencies(packageJsonPath, depsMap, { overwriteExisting = true } = {}) {
+  if (!packageJsonPath) return { ok: false, reason: 'missing_package_json_path' }
+  const pkg = readPackageJson(packageJsonPath)
+  if (!pkg) return { ok: false, reason: 'invalid_package_json' }
+  if (!isPlainObject(depsMap) || !Object.keys(depsMap).length) {
+    return { ok: true, changed: false }
+  }
+
+  const existing = isPlainObject(pkg.dependencies) ? { ...pkg.dependencies } : {}
+  let changed = false
+
+  for (const [name, ver] of Object.entries(depsMap)) {
+    if (typeof name !== 'string' || !name) continue
+    if (typeof ver !== 'string' || !ver) continue
+    if (!Object.prototype.hasOwnProperty.call(existing, name)) {
+      existing[name] = ver
+      changed = true
+      continue
+    }
+    if (overwriteExisting && existing[name] !== ver) {
+      existing[name] = ver
+      changed = true
+    }
+  }
+
+  if (!changed) return { ok: true, changed: false }
+  pkg.dependencies = sortObjectKeys(existing)
+  const ok = writePackageJson(packageJsonPath, pkg)
+  return { ok, changed: ok }
+}
+
+function ensureSchemaContainer(project) {
+  if (!project || typeof project !== 'object') return null
+  if (!isPlainObject(project.schema)) project.schema = {}
+  return project.schema
+}
+
+export function ensureSchemaDependencies(project) {
+  if (!project || typeof project !== 'object') return project
+  const deps = isPlainObject(project.dependencies) ? project.dependencies : null
+  if (!deps) return project
+
+  const schema = ensureSchemaContainer(project)
+  if (!isPlainObject(schema.dependencies)) schema.dependencies = {}
+
+  for (const [name, ver] of Object.entries(deps)) {
+    if (typeof name !== 'string' || !name) continue
+    const version = typeof ver === 'string' && ver.length ? ver : 'latest'
+    const existing = schema.dependencies[name]
+    if (isPlainObject(existing)) {
+      if (typeof existing.key !== 'string') existing.key = name
+      if (typeof existing.type !== 'string') existing.type = 'dependency'
+      if (typeof existing.version !== 'string') existing.version = version
+      if (typeof existing.resolvedVersion !== 'string') existing.resolvedVersion = version
+      if (typeof existing.status !== 'string') existing.status = 'done'
+    } else {
+      schema.dependencies[name] = {
+        key: name,
+        resolvedVersion: version,
+        type: 'dependency',
+        version,
+        status: 'done'
+      }
+    }
+  }
+  return project
+}
+
+/**
+ * Augment a project object with local package.json dependencies so sync/collab
+ * can detect and push dependency additions/updates.
+ */
+export function augmentProjectWithLocalPackageDependencies(project, packageJsonPath) {
+  if (!project || typeof project !== 'object') return project
+  if (!packageJsonPath) return project
+  const pkgDeps = getPackageDependencies(packageJsonPath)
+  if (!Object.keys(pkgDeps).length) return project
+
+  // Some build outputs expose getters-only exports (e.g. Babel interop / CJS wrappers).
+  // Avoid mutating such objects by cloning into a plain, extensible object.
+  let target = project
+  try {
+    const desc = Object.getOwnPropertyDescriptor(target, 'dependencies')
+    const canAssign =
+      !desc ||
+      desc.writable === true ||
+      typeof desc.set === 'function'
+    if (!canAssign || !Object.isExtensible(target)) {
+      target = { ...target }
+    }
+  } catch (_) {
+    target = { ...target }
+  }
+
+  const existing = isPlainObject(target.dependencies) ? target.dependencies : {}
+  const merged = { ...existing, ...pkgDeps }
+
+  try {
+    target.dependencies = merged
+  } catch (_) {
+    try {
+      Object.defineProperty(target, 'dependencies', {
+        value: merged,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      })
+    } catch (_) {}
+  }
+
+  ensureSchemaDependencies(target)
+  return target
+}
+
+

package/helpers/orderUtils.js

@@ -0,0 +1,46 @@
+/**
+ * Strip Symbols ordering metadata (`__order`) from a project object.
+ *
+ * We treat `__order` as platform/transport metadata and avoid persisting it
+ * into local repositories (generated files or base snapshots).
+ *
+ * - Preserves functions and non-plain objects as-is
+ * - Clones arrays and plain objects
+ * - Handles cycles via WeakMap
+ */
+export function stripOrderFields(input) {
+  const seen = new WeakMap()
+
+  function isPlainObject(v) {
+    return Object.prototype.toString.call(v) === '[object Object]'
+  }
+
+  function walk(value) {
+    if (Array.isArray(value)) {
+      if (seen.has(value)) return seen.get(value)
+      const out = new Array(value.length)
+      seen.set(value, out)
+      for (let i = 0; i < value.length; i++) out[i] = walk(value[i])
+      return out
+    }
+
+    if (value && typeof value === 'object') {
+      // Keep non-plain objects (Date, Map, etc.) as-is
+      if (!isPlainObject(value)) return value
+      if (seen.has(value)) return seen.get(value)
+      const out = {}
+      seen.set(value, out)
+      for (const k of Object.keys(value)) {
+        if (k === '__order') continue
+        out[k] = walk(value[k])
+      }
+      return out
+    }
+
+    return value
+  }
+
+  return walk(input)
+}
+
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@symbo.ls/cli",
-  "version": "2.33.35",
+  "version": "2.33.36",
   "description": "Fetch your Symbols configuration",
   "main": "bin/fetch.js",
   "author": "Symbols",
@@ -15,9 +15,9 @@
     "vpatch": "npm version patch && npm publish"
   },
   "dependencies": {
-    "@symbo.ls/fetch": "^2.33.35",
-    "@symbo.ls/init": "^2.33.35",
-    "@symbo.ls/socket": "^2.33.35",
+    "@symbo.ls/fetch": "^2.33.36",
+    "@symbo.ls/init": "^2.33.36",
+    "@symbo.ls/socket": "^2.33.36",
     "chalk": "^5.4.1",
     "chokidar": "^4.0.3",
     "commander": "^13.1.0",
@@ -28,5 +28,5 @@
     "socket.io-client": "^4.8.1",
     "v8-compile-cache": "^2.4.0"
   },
-  "gitHead": "3ad860e75a24c41afaac79d639f7a9162c2f4c81"
+  "gitHead": "c49777e3aee153b8b68f55a2aa9a3a5988483e2f"
 }