@myvillage/cli 2.2.0 → 2.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myvillage/cli",
-  "version": "2.2.0",
+  "version": "2.4.0",
   "description": "MyVillageOS CLI for community developers",
   "type": "module",
   "bin": {

package/src/commands/dataset.js

@@ -103,7 +103,7 @@ export async function datasetAppendCommand(options) {
       rows = readRowsFromFile(options.file);
     } else if (options.text !== undefined || options.features !== undefined) {
       const row = { split: options.split || 'train' };
-      row.features = options.features !== undefined ? parseFeatures(options.features) : options.text;
+      row.features = options.features !== undefined ? parseFeatures(options.features, manifest.modality) : options.text;
       if (options.label !== undefined) row.label = options.label;
       if (options.target !== undefined) row.target = Number(options.target);
       rows = [row];
@@ -111,15 +111,27 @@ export async function datasetAppendCommand(options) {
       throw new Error('Provide --image <path> (image datasets), --file <jsonl>, or --text/--features (with --label or --target).');
     }
 
+    if (options.replace && !options.file) {
+      throw new Error('--replace only works with --file (it swaps in the whole working set).');
+    }
+    const featureNames = options.featureNames !== undefined ? parseNameList(options.featureNames) : undefined;
+
     const spinner = options.json ? null : villageSpinner('Appending rows...').start();
-    const result = appendRows(slug, rows, { source: 'cli' });
-    if (spinner) spinner.stop();
+    let result;
+    try {
+      result = appendRows(slug, rows, { source: options.source || 'cli' }, {
+        replace: Boolean(options.replace),
+        featureNames,
+      });
+    } finally {
+      if (spinner) spinner.stop();
+    }
 
     if (options.json) {
       console.log(JSON.stringify(result, null, 2));
       return;
     }
-    success(`Appended ${result.appended} row(s) to ${slug}`);
+    success(`${result.replaced ? 'Replaced the working set with' : 'Appended'} ${result.appended} row(s) ${result.replaced ? 'in' : 'to'} ${slug}`);
     info(`  total: ${result.stats.rowCount} (train ${result.stats.bySplit.train} / val ${result.stats.bySplit.val})`);
   } catch (e) {
     error(e.message);
@@ -133,8 +145,13 @@ export async function datasetShowCommand(slug, options) {
   try {
     const manifest = readManifest(slug);
     if (!manifest) throw new Error(`Dataset "${slug}" not found.`);
-    const limit = options.limit ? parseInt(options.limit, 10) : 5;
-    const sample = readRows(slug, { limit });
+    // --limit 0 returns every row (used by Studio's export).
+    const limit = options.limit !== undefined ? parseInt(options.limit, 10) : 5;
+    const version = options.frozen !== undefined ? parseInt(options.frozen, 10) : undefined;
+    if (version !== undefined && !manifest.versions.some((v) => v.version === version)) {
+      throw new Error(`Dataset "${slug}" has no frozen v${options.frozen}.`);
+    }
+    const sample = readRows(slug, { limit, version });
     if (options.json) {
       console.log(JSON.stringify({ manifest, sample }, null, 2));
       return;
@@ -206,7 +223,9 @@ export async function datasetRowUpdateCommand(options) {
     if (!slug) throw new Error('--dataset <slug> is required.');
     if (!options.id) throw new Error('--id <rowId> is required.');
     const updates = {};
-    if (options.features !== undefined) updates.features = parseFeatures(options.features);
+    if (options.features !== undefined) {
+      updates.features = parseFeatures(options.features, readManifest(slug)?.modality);
+    }
     else if (options.text !== undefined) updates.features = options.text;
     if (options.label !== undefined) updates.label = options.label;
     if (options.target !== undefined) updates.target = Number(options.target);
@@ -244,8 +263,22 @@ function readRowsFromFile(path) {
   return rows;
 }
 
-function parseFeatures(raw) {
-  // tabular features may be passed as a comma/JSON numeric vector
+/** A JSON array of names, or a comma-separated list. */
+function parseNameList(raw) {
+  const trimmed = String(raw).trim();
+  if (trimmed.startsWith('[')) {
+    const parsed = JSON.parse(trimmed);
+    if (!Array.isArray(parsed)) throw new Error('--feature-names must be a list.');
+    return parsed.map(String);
+  }
+  return trimmed.split(',').map((s) => s.trim());
+}
+
+function parseFeatures(raw, modality) {
+  // Tabular features are a numeric vector, passed as JSON ("[12, 45]") or a
+  // comma list ("12, 45" or a single "12"). Anything that isn't a number stays
+  // NaN so row validation rejects it rather than storing it as text.
+  if (modality !== 'tabular') return raw;
   const trimmed = raw.trim();
   if (trimmed.startsWith('[')) {
     try {
@@ -254,10 +287,7 @@ function parseFeatures(raw) {
       /* fall through */
     }
   }
-  if (/^-?\d.*,/.test(trimmed)) {
-    return trimmed.split(',').map((n) => Number(n.trim()));
-  }
-  return raw;
+  return trimmed.split(',').map((n) => (n.trim() === '' ? NaN : Number(n.trim())));
 }
 
 function truncate(s, n) {

package/src/commands/deploy.js

@@ -463,6 +463,13 @@ async function deployUnityPlatform(projectDir, mvConfig, platform, { gameIdOverr
       buildDir,
       sdkVersion: mvConfig.sdkVersion,
       platform,
+      onStatus: (text) => {
+        preflightSpinner.text = `[${platform}] ${text}`;
+        // Studio streams our stdout into its publish log and isn't a TTY, so
+        // the spinner's text changes never reach the developer there. Print a
+        // plain line too, otherwise the one-time UnityPy install looks like a hang.
+        if (!process.stderr.isTTY) console.log(brand.teal(`  [${platform}] ${text}`));
+      },
     });
     if (preflightResult.skipped) {
       if (preflightResult.fatal) {
@@ -471,7 +478,18 @@ async function deployUnityPlatform(projectDir, mvConfig, platform, { gameIdOverr
       }
       preflightSpinner.warn(`[${platform}] Preflight skipped: ${preflightResult.reason}`);
     } else if (!preflightResult.ok) {
-      preflightSpinner.fail(`[${platform}] Preflight found ${preflightResult.violations.length} violation(s).`);
+      // "preflight_error" / "preflight_crash" mean the scanner itself failed
+      // (couldn't parse the bundle, script crashed). That's on us, not on the
+      // developer's scripts — so don't tell them to rewrite their game.
+      const toolingFailures = preflightResult.violations.filter(
+        (v) => v.kind === 'preflight_error' || v.kind === 'preflight_crash',
+      );
+      const codeViolations = preflightResult.violations.filter((v) => !toolingFailures.includes(v));
+      if (codeViolations.length > 0) {
+        preflightSpinner.fail(`[${platform}] Preflight found ${codeViolations.length} violation(s).`);
+      } else {
+        preflightSpinner.fail(`[${platform}] Preflight could not scan the bundle.`);
+      }
       console.log();
       for (const v of preflightResult.violations) {
         console.log(chalk.red(`  \u2717 ${v.kind}`));
@@ -481,7 +499,12 @@ async function deployUnityPlatform(projectDir, mvConfig, platform, { gameIdOverr
         if (v.reason) console.log(`     ${v.reason}`);
         console.log();
       }
-      console.log(brand.teal('  Fix these scripts to extend MissionBase / use SDK templates, rebuild, and retry.'));
+      if (codeViolations.length > 0) {
+        console.log(brand.teal('  Fix these scripts to extend MissionBase / use SDK templates, rebuild, and retry.'));
+      } else {
+        console.log(brand.teal('  This is a problem with the bundle scanner, not with your game.'));
+        console.log(brand.teal('  Rebuild the bundle in Unity and publish again. If it keeps happening, send the message above to the MyVillage team.'));
+      }
       console.log();
       return { ok: false };
     } else {

package/src/index.js

@@ -1010,13 +1010,17 @@ export function run() {
     .option('--label <label>', 'Class label (classification)')
     .option('--target <number>', 'Numeric target (regression)')
     .option('--split <split>', 'train | val', 'train')
+    .option('--replace', 'With --file: replace the working set instead of adding to it')
+    .option('--source <source>', 'Provenance source stamped on each row (e.g. import:csv)')
+    .option('--feature-names <list>', 'Tabular column names (JSON array or comma-separated)')
     .option('--json', 'Output raw JSON')
     .action(datasetAppendCommand);
 
   datasetCmd
     .command('show <slug>')
     .description('Show a dataset manifest and a sample of rows')
-    .option('--limit <n>', 'Number of sample rows to show', '5')
+    .option('--limit <n>', 'Number of sample rows to show (0 = all)', '5')
+    .option('--frozen <n>', 'Read frozen version n instead of the working set')
     .option('--json', 'Output raw JSON')
     .action(datasetShowCommand);
 

package/src/utils/dataset-workspace.js

@@ -202,23 +202,50 @@ export function createDataset({ name, modality, taskType = 'classification', lab
  * Append rows to a dataset's working set, stamping provenance, validating
  * against the dataset's modality/task, and updating manifest stats.
  *
+ * Every row is validated before anything is written, so a bad row leaves the
+ * dataset untouched. With `replace`, the working set is overwritten instead of
+ * extended (frozen versions are never touched) and the label list is rebuilt
+ * from the new rows. `featureNames` names the columns of a tabular vector
+ * (e.g. from a spreadsheet header); once set, every tabular row must have
+ * exactly that many numbers.
+ *
  * @param {string} slug
  * @param {Array<{features:any, label?:string, target?:number, split?:string}>} rows
  * @param {object} provenance  partial provenance ({ source, agentId, villagerId, villageId })
- * @returns {{datasetId:string, appended:number, stats:object}}
+ * @param {{replace?:boolean, featureNames?:string[]}} opts
+ * @returns {{datasetId:string, appended:number, replaced:boolean, stats:object}}
  */
-export function appendRows(slug, rows, provenance = {}) {
+export function appendRows(slug, rows, provenance = {}, { replace = false, featureNames } = {}) {
   const manifest = readManifest(slug);
   if (!manifest) throw new Error(`Dataset "${slug}" not found.`);
   if (!Array.isArray(rows) || rows.length === 0) {
     throw new Error('No rows to append.');
   }
-  const source = provenance.source || 'cli';
-  const lines = [];
-  let appended = 0;
+  if (featureNames !== undefined) {
+    applyFeatureNames(manifest, featureNames, replace);
+  } else if (replace) {
+    delete manifest.featureNames;
+  }
 
-  for (const raw of rows) {
-    const row = normalizeRow(raw, manifest);
+  const existing = replace ? [] : readRows(slug);
+  // Without named columns, hold tabular rows to the width already on disk
+  // (the trainer needs every vector the same length).
+  let width = manifest.featureNames?.length;
+  if (width == null && manifest.modality === 'tabular') {
+    const first = existing.find((r) => Array.isArray(r.features));
+    if (first) width = first.features.length;
+  }
+
+  const source = provenance.source || 'cli';
+  const newRows = [];
+  rows.forEach((raw, i) => {
+    let row;
+    try {
+      row = normalizeRow(raw, manifest, width);
+    } catch (e) {
+      throw new Error(rows.length > 1 ? `Row ${i + 1}: ${e.message}` : e.message);
+    }
+    if (width == null && Array.isArray(row.features)) width = row.features.length;
     row.id = randomUUID();
     row.provenance = {
       source,
@@ -227,24 +254,47 @@ export function appendRows(slug, rows, provenance = {}) {
       ...(provenance.villageId ? { villageId: provenance.villageId } : {}),
       ts: nowISO(),
     };
-    lines.push(JSON.stringify(row));
+    newRows.push(row);
+  });
 
-    // stats
-    manifest.stats.rowCount += 1;
-    manifest.stats.bySplit[row.split] += 1;
-    if (row.label != null) {
-      manifest.stats.byLabel[row.label] = (manifest.stats.byLabel[row.label] || 0) + 1;
-      if (!manifest.labels.includes(row.label)) manifest.labels.push(row.label);
-    }
-    appended += 1;
+  if (replace) manifest.labels = [];
+  for (const row of newRows) {
+    if (row.label != null && !manifest.labels.includes(row.label)) manifest.labels.push(row.label);
+  }
+  if (replace) {
+    writeWorkingSet(slug, manifest, newRows);
+  } else {
+    appendFileSync(getCurrentDataFile(slug), newRows.map((r) => JSON.stringify(r)).join('\n') + '\n');
+    manifest.stats = recomputeStats([...existing, ...newRows]);
+    writeManifest(slug, manifest);
   }
+  return { datasetId: slug, appended: newRows.length, replaced: replace, stats: manifest.stats };
+}
 
-  appendFileSync(getCurrentDataFile(slug), lines.join('\n') + '\n');
-  writeManifest(slug, manifest);
-  return { datasetId: slug, appended, stats: manifest.stats };
+/** Swap the whole working set for `rows` (e.g. a spreadsheet import). */
+export function replaceRows(slug, rows, provenance = {}, { featureNames } = {}) {
+  return appendRows(slug, rows, provenance, { replace: true, featureNames });
+}
+
+/** Set a tabular dataset's column names, refusing a mismatch on append. */
+function applyFeatureNames(manifest, featureNames, replace) {
+  if (manifest.modality !== 'tabular') {
+    throw new Error('Feature names only apply to tabular datasets.');
+  }
+  const names = featureNames.map((n) => String(n).trim());
+  if (names.length === 0 || names.some((n) => !n)) {
+    throw new Error('Feature names must be non-empty.');
+  }
+  const current = manifest.featureNames;
+  if (!replace && current?.length && current.join('\u0000') !== names.join('\u0000')) {
+    throw new Error(
+      `These columns don't match the dataset. It expects: ${current.join(', ')}.`,
+    );
+  }
+  manifest.featureNames = names;
 }
 
-function normalizeRow(raw, manifest) {
+function normalizeRow(raw, manifest, width) {
   if (raw == null || typeof raw !== 'object') {
     throw new Error('Each row must be an object.');
   }
@@ -266,6 +316,18 @@ function normalizeRow(raw, manifest) {
       );
     }
   }
+  if (manifest.modality === 'tabular') {
+    const f = raw.features;
+    if (!Array.isArray(f) || f.length === 0 || f.some((n) => typeof n !== 'number' || !Number.isFinite(n))) {
+      throw new Error('Tabular rows need features that are all numbers (e.g. [12, 45, 8]).');
+    }
+    if (width != null && f.length !== width) {
+      throw new Error(`Expected ${width} number(s) in each row, got ${f.length}.`);
+    }
+  }
+  if (manifest.modality === 'text' && (typeof raw.features !== 'string' || !raw.features.trim())) {
+    throw new Error('Text rows need some text.');
+  }
   const row = { features: raw.features, split };
   if (manifest.taskType === 'classification') {
     if (raw.label == null || String(raw.label).length === 0) {
@@ -273,7 +335,7 @@ function normalizeRow(raw, manifest) {
     }
     row.label = String(raw.label);
   } else {
-    if (raw.target == null || Number.isNaN(Number(raw.target))) {
+    if (raw.target == null || raw.target === '' || !Number.isFinite(Number(raw.target))) {
       throw new Error('Regression rows require a numeric "target".');
     }
     row.target = Number(raw.target);
@@ -376,6 +438,7 @@ export function updateRow(slug, rowId, updates = {}) {
   if ((manifest.modality === 'image' || manifest.modality === 'audio') && updates.features !== undefined) {
     throw new Error(`Can't edit the asset of an ${manifest.modality} row — delete it and re-add.`);
   }
+  const sibling = rows.find((r, i) => i !== idx && Array.isArray(r.features));
   const merged = normalizeRow(
     {
       features: updates.features !== undefined ? updates.features : existing.features,
@@ -384,6 +447,7 @@ export function updateRow(slug, rowId, updates = {}) {
       target: updates.target !== undefined ? updates.target : existing.target,
     },
     manifest,
+    manifest.featureNames?.length ?? sibling?.features.length,
   );
   merged.id = existing.id;
   merged.provenance = { ...(existing.provenance || {}), editedAt: nowISO() };

package/src/utils/preflight.js

@@ -1,6 +1,6 @@
 import { spawn } from 'child_process';
-import { existsSync, mkdtempSync, readdirSync, statSync, writeFileSync } from 'fs';
-import { tmpdir } from 'os';
+import { existsSync, mkdirSync, mkdtempSync, readdirSync, statSync, writeFileSync } from 'fs';
+import { homedir, tmpdir } from 'os';
 import { dirname, join, resolve } from 'path';
 import { fileURLToPath } from 'url';
 import { getGameKitAllowlist } from './api.js';
@@ -14,6 +14,91 @@ const PREFLIGHT_SCRIPT = resolve(__dirname, '../../tools/preflight/preflight.py'
 
 const PYTHON_CANDIDATES = ['python3', 'python'];
 
+// The bundle scanner needs UnityPy. Rather than asking every game developer to
+// pip-install it by hand (the #1 reason deploys failed with "preflight_error"),
+// we install it once into a private venv under ~/.myvillage and reuse it.
+const UNITYPY_SPEC = 'UnityPy==1.25.0';
+const PREFLIGHT_VENV_DIR = join(homedir(), '.myvillage', 'tools', 'preflight-venv');
+
+function venvPython(dir) {
+  return process.platform === 'win32' ? join(dir, 'Scripts', 'python.exe') : join(dir, 'bin', 'python');
+}
+
+/** Run a command, capture output, never throw. */
+function runCapture(cmd, args) {
+  return new Promise((resolveRun) => {
+    let stdout = '';
+    let stderr = '';
+    let proc;
+    try {
+      proc = spawn(cmd, args, { stdio: ['ignore', 'pipe', 'pipe'] });
+    } catch (err) {
+      resolveRun({ code: -1, stdout, stderr: err.message });
+      return;
+    }
+    proc.stdout.on('data', (b) => { stdout += b.toString(); });
+    proc.stderr.on('data', (b) => { stderr += b.toString(); });
+    proc.on('error', (err) => resolveRun({ code: -1, stdout, stderr: err.message }));
+    proc.on('exit', (code) => resolveRun({ code, stdout, stderr }));
+  });
+}
+
+async function hasUnityPy(python) {
+  const r = await runCapture(python, ['-c', 'import UnityPy']);
+  return r.code === 0;
+}
+
+function lastLine(text) {
+  const lines = (text || '').trim().split(/\r?\n/).filter(Boolean);
+  return lines.length ? lines[lines.length - 1] : '';
+}
+
+/**
+ * Find a Python that can import UnityPy, installing it if needed.
+ *
+ * Order: our managed venv → a system Python that already has UnityPy →
+ * create the managed venv with the system Python and pip-install UnityPy.
+ * `onStatus(text)` is called with progress copy for the caller's spinner.
+ *
+ * Returns { python } on success, or { python: null, reason } when there's no
+ * usable interpreter — the caller decides whether that skips or blocks.
+ */
+export async function ensurePreflightPython({ onStatus } = {}) {
+  const managed = venvPython(PREFLIGHT_VENV_DIR);
+  if (existsSync(managed) && await hasUnityPy(managed)) return { python: managed };
+
+  const system = await findPython();
+  if (!system) {
+    return {
+      python: null,
+      reason: 'Python 3 was not found on your PATH. Install Python 3.9+ from python.org (on Windows, tick "Add to PATH"), then publish again.',
+    };
+  }
+  if (await hasUnityPy(system)) return { python: system };
+
+  const manualHint = `${system} -m pip install "${UNITYPY_SPEC}"`;
+
+  onStatus?.('First publish from this computer: setting up the bundle scanner (one-time, about a minute)...');
+  mkdirSync(PREFLIGHT_VENV_DIR, { recursive: true });
+  const venv = await runCapture(system, ['-m', 'venv', PREFLIGHT_VENV_DIR]);
+  if (venv.code !== 0 || !existsSync(managed)) {
+    return {
+      python: null,
+      reason: `Could not create a Python environment at ${PREFLIGHT_VENV_DIR} (${lastLine(venv.stderr) || `exit ${venv.code}`}). Repair your Python install or run: ${manualHint}`,
+    };
+  }
+
+  onStatus?.('Installing the bundle scanner (UnityPy)...');
+  const pip = await runCapture(managed, ['-m', 'pip', 'install', '--disable-pip-version-check', '--quiet', UNITYPY_SPEC]);
+  if (pip.code !== 0 || !(await hasUnityPy(managed))) {
+    return {
+      python: null,
+      reason: `Could not install ${UNITYPY_SPEC} (${lastLine(pip.stderr) || `exit ${pip.code}`}). Check your network connection and retry, or run: ${manualHint}`,
+    };
+  }
+  return { python: managed };
+}
+
 /**
  * Find the first usable Python interpreter on PATH.
  * Returns the command name (e.g. "python3") or null if none works.
@@ -94,11 +179,11 @@ async function runPreflight(python, bundlePath, allowlistPath) {
  * Run preflight against all AssetBundles in a build directory.
  *
  * Returns:
- *   { skipped: true, reason }        — bundles couldn't be checked (no SDK, no Python, etc.)
+ *   { skipped: true, reason }        — bundles couldn't be checked (no SDK, no usable Python, etc.)
  *   { ok: true, bundlesChecked }     — all bundles passed
  *   { ok: false, violations, bundle } — at least one violation found
  */
-export async function preflightBundles({ buildDir, sdkVersion, platform }) {
+export async function preflightBundles({ buildDir, sdkVersion, platform, onStatus }) {
   if (!sdkVersion) {
     return { skipped: true, reason: 'No sdkVersion in myvillage.json — preflight only runs for SDK-based games.' };
   }
@@ -109,12 +194,13 @@ export async function preflightBundles({ buildDir, sdkVersion, platform }) {
     return { skipped: true, reason: `preflight.py not found at ${PREFLIGHT_SCRIPT} — CLI install may be incomplete.` };
   }
 
-  const python = await findPython();
+  // No usable Python (or UnityPy couldn't be installed) is a *tooling* gap on
+  // the developer's machine, never a problem with their game. Skip with a clear
+  // warning instead of blocking — the same outcome for "no Python at all" and
+  // "Python but no UnityPy", which used to diverge (one skipped, one failed).
+  const { python, reason: pythonReason } = await ensurePreflightPython({ onStatus });
   if (!python) {
-    return {
-      skipped: true,
-      reason: 'Python 3 not found on PATH. Install Python 3.9+ and then run: pip install UnityPy==1.25.0',
-    };
+    return { skipped: true, reason: `${pythonReason} (Bundle scan skipped; the platform re-checks on upload.)` };
   }
 
   let allowlistResponse;

package/src/utils/templates.js

@@ -12,7 +12,7 @@ const GAME_ART_DIR = join(dirname(fileURLToPath(import.meta.url)), '..', 'assets
 
 // GameKit SDK version that scaffolded Unity projects pin to.
 // Bump alongside CLI minor releases as the SDK contract evolves.
-const GAMEKIT_SDK_VERSION = '1.1.0-alpha.4';
+const GAMEKIT_SDK_VERSION = '1.1.0-alpha.5';
 const GAMEKIT_SDK_URL =
   `https://github.com/MyVillage-Project-Technologies/myvillage-gamekit.git#v${GAMEKIT_SDK_VERSION}`;
 
@@ -1302,7 +1302,7 @@ export async function createUnityGameProject(targetDir, options) {
   // Unity project files. When the SDK is embedded it must NOT also be listed as
   // a manifest dependency (Unity would try to re-resolve it); when it isn't, the
   // git-URL entry is the fallback resolution path.
-  writeFileSync(join(targetDir, 'Packages/manifest.json'), generateUnityPackagesManifest(sdkEmbedded));
+  writeFileSync(join(targetDir, 'Packages/manifest.json'), generateUnityPackagesManifest(sdkEmbedded, unityVersion));
   writeFileSync(join(targetDir, 'ProjectSettings/ProjectVersion.txt'), generateUnityProjectVersion(unityVersion));
 
   // Starter mission. New devs subclass MissionBase here.
@@ -1367,7 +1367,59 @@ public static class MyVillageOrientation
 
 // ── Unity (GameKit SDK) ─────────────────────────────────────────────
 
-function generateUnityPackagesManifest(sdkEmbedded = true) {
+// Unity's built-in engine modules. A project created through Unity Hub lists
+// every one of these in Packages/manifest.json; a manifest that omits them
+// DISABLES them. An earlier version of this scaffold wrote only the registry
+// packages, so fresh projects had no Particle System, Terrain, Animation,
+// Tilemap, Physics2D, Video, ... and developers had to hand-restore them.
+const UNITY_BUILTIN_MODULES = [
+  'accessibility',
+  'ai',
+  'androidjni',
+  'animation',
+  'assetbundle',
+  'audio',
+  'cloth',
+  'director',
+  'imageconversion',
+  'imgui',
+  'jsonserialize',
+  'particlesystem',
+  'physics',
+  'physics2d',
+  'screencapture',
+  'terrain',
+  'terrainphysics',
+  'tilemap',
+  'ui',
+  'uielements',
+  'umbra',
+  'unityanalytics',
+  'unitywebrequest',
+  'unitywebrequestassetbundle',
+  'unitywebrequestaudio',
+  'unitywebrequesttexture',
+  'unitywebrequestwww',
+  'vehicles',
+  'video',
+  'vr',
+  'wind',
+  'xr',
+];
+
+// Visual Scripting version pinned in the scaffold manifest. Keep in sync with
+// the `com.unity.visualscripting` dependency in the GameKit's package.json —
+// GameKit's MyVillage.GameKit.VisualScripting assembly references it, and an
+// embedded package's own dependency isn't enough on its own for Unity to keep
+// it resolved, so the manifest lists it explicitly.
+const UNITY_VISUAL_SCRIPTING_VERSION = '1.9.4';
+
+function unityMajor(unityVersion) {
+  const m = /^(\d+)\./.exec(unityVersion || '');
+  return m ? Number(m[1]) : 6000;
+}
+
+function generateUnityPackagesManifest(sdkEmbedded = true, unityVersion = UNITY_EDITOR_VERSION_FALLBACK) {
   const dependencies = {};
   // Only declare the SDK as a git dependency when it could NOT be embedded
   // locally. When embedded under Packages/com.myvillage.gamekit/, Unity
@@ -1378,11 +1430,25 @@ function generateUnityPackagesManifest(sdkEmbedded = true) {
   Object.assign(dependencies, {
     'com.unity.feature.development': '1.0.2',
     'com.unity.render-pipelines.universal': '17.2.0',
-    'com.unity.textmeshpro': '3.0.6',
     'com.unity.inputsystem': '1.14.2',
+    // GameKit ships Visual Scripting units (CompleteMission, ReadConfig, ...).
+    // Without this package the SDK's VisualScripting assembly can't compile.
+    'com.unity.visualscripting': UNITY_VISUAL_SCRIPTING_VERSION,
     'com.unity.ide.rider': '3.0.38',
     'com.unity.ide.visualstudio': '2.0.22',
   });
+  // Unity 6 folded TextMesh Pro into com.unity.ugui 2.x; declaring the old
+  // standalone com.unity.textmeshpro there triggers a deprecation conflict.
+  // Older editors still need the standalone package.
+  if (unityMajor(unityVersion) >= 6000) {
+    dependencies['com.unity.ugui'] = '2.0.0';
+  } else {
+    dependencies['com.unity.ugui'] = '1.0.0';
+    dependencies['com.unity.textmeshpro'] = '3.0.6';
+  }
+  for (const mod of UNITY_BUILTIN_MODULES) {
+    dependencies[`com.unity.modules.${mod}`] = '1.0.0';
+  }
   return JSON.stringify({ dependencies }, null, 2) + '\n';
 }
 

package/tools/preflight/README.md

@@ -16,7 +16,7 @@ Requires **Python 3.9+** and **UnityPy 1.25.0** (specifically — newer versions
 pip install -r requirements.txt
 ```
 
-The CLI checks for `python3` and `UnityPy` automatically and prints install hints if either is missing.
+The CLI finds `python3`/`python` on PATH and, if UnityPy isn't importable, installs it once into a private venv at `~/.myvillage/tools/preflight-venv/` (see `ensurePreflightPython` in `src/utils/preflight.js`). If Python is missing or the install fails, preflight is skipped with a warning and the upload proceeds; the ed-platform re-checks on upload.
 
 ## Run directly (for debugging)