@neocompose/cli 0.50.1 → 0.50.2

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## [0.50.2] - 2026-09-12
+
+- Export Unity C# as separate files named after their generated types. Keep stable identities in the manifest to preserve Unity GUIDs through renames. Preserve unchanged files and their Unity metadata, remove obsolete owned outputs, and share the integrity manifest with editor synchronization.
+
 ## [0.50.1] - 2026-09-12
 
 - Reuse schema and symbol indexes while compiling a push, including migration bodies, and compile each changed member body once. Bulk scripted changes no longer rebuild the complete project for every body.

package/dist/neo.mjs

@@ -35365,7 +35365,7 @@ var init_login = __esm({
       "project:localization:export",
       "project:localization:import",
       "project:release-channel:read",
-      // `neo export unity` writes project.json + NeoGeneratedTypes.cs headlessly
+      // `neo export unity` writes project.json + generated C# files headlessly
       // (the escape hatch when game code references not-yet-generated members and
       // a broken compile blocks the in-editor sync).
       "unity:export",
@@ -132352,7 +132352,7 @@ var init_registry2 = __esm({
   "schema-contract/registry.mjs"() {
     "use strict";
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
-      cliVersion: "0.50.1",
+      cliVersion: "0.50.2",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -138828,13 +138828,177 @@ var init_dialogue_dryrun = __esm({
   }
 });
 
+// src/unity-generated-files.ts
+import { createHash as createHash12 } from "node:crypto";
+import {
+  existsSync as existsSync16,
+  mkdirSync as mkdirSync13,
+  readFileSync as readFileSync21,
+  unlinkSync,
+  writeFileSync as writeFileSync13
+} from "node:fs";
+import { dirname as dirname11, join as join18 } from "node:path";
+function validatePath(path) {
+  if (!/^Generated\/[a-zA-Z0-9_%./-]+\.g\.cs$/.test(path))
+    throw new Error(`Invalid generated file path: ${path}`);
+  if (path.split("/").some((part) => part === "." || part === ".." || part === ""))
+    throw new Error(`Invalid generated file path segment: ${path}`);
+}
+function readManifest(path) {
+  if (!existsSync16(path)) return null;
+  const data = JSON.parse(readFileSync21(path, "utf8"));
+  if (data === null || typeof data !== "object" || !("schemaVersion" in data) || data.schemaVersion !== 1)
+    throw new Error(`Invalid generated-file manifest version: ${path}`);
+  if (!("files" in data) || !Array.isArray(data.files) || data.files.length === 0)
+    throw new Error(`Invalid generated-file manifest entries: ${path}`);
+  if (!("projectId" in data) || typeof data.projectId !== "string")
+    throw new Error(`Invalid generated-file manifest project: ${path}`);
+  const ids = /* @__PURE__ */ new Set();
+  const paths = /* @__PURE__ */ new Set();
+  const files = data.files.map((entry) => {
+    if (entry === null || typeof entry !== "object" || !("path" in entry) || typeof entry.path !== "string")
+      throw new Error(`Invalid generated-file manifest entry: ${path}`);
+    if (!("id" in entry) || typeof entry.id !== "string" || entry.id.length === 0)
+      throw new Error(`Invalid generated-file manifest identity: ${path}`);
+    if (ids.has(entry.id))
+      throw new Error(
+        `Duplicate generated-file manifest identity: ${entry.id}`
+      );
+    ids.add(entry.id);
+    validatePath(entry.path);
+    if (paths.has(entry.path.toLowerCase()))
+      throw new Error(`Duplicate generated-file manifest path: ${entry.path}`);
+    paths.add(entry.path.toLowerCase());
+    return { id: entry.id, path: entry.path };
+  });
+  return { projectId: data.projectId, files };
+}
+function writeUnityGeneratedFiles(directory, projectId, files) {
+  if (!Array.isArray(files) || files.length === 0)
+    throw new Error(
+      "The export returned no generated files. Update the server before exporting Unity code."
+    );
+  const expected = /* @__PURE__ */ new Set();
+  const ids = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    validatePath(file.path);
+    if (typeof file.id !== "string" || file.id.length === 0)
+      throw new Error(`Missing generated file identity: ${file.path}`);
+    if (ids.has(file.id))
+      throw new Error(`Duplicate generated file identity: ${file.id}`);
+    ids.add(file.id);
+    const key = file.path.toLowerCase();
+    if (expected.has(key))
+      throw new Error(`Duplicate generated file path: ${file.path}`);
+    expected.add(key);
+    if (typeof file.content !== "string" || file.content.trim().length === 0)
+      throw new Error(`Empty generated C# file: ${file.path}`);
+  }
+  const manifestPath = join18(directory, "NeoGeneratedFiles.json");
+  const manifest = readManifest(manifestPath);
+  const previousFiles = manifest?.files ?? [];
+  const previousById = new Map(previousFiles.map((file) => [file.id, file]));
+  const previousPaths = new Set(
+    previousFiles.map((file) => file.path.toLowerCase())
+  );
+  const incomingById = new Map(files.map((file) => [file.id, file]));
+  const operations = [];
+  for (const file of previousFiles) {
+    if (incomingById.get(file.id)?.path === file.path && manifest?.projectId === projectId)
+      continue;
+    operations.push(
+      [join18(directory, file.path), null],
+      [join18(directory, file.path + ".meta"), null]
+    );
+  }
+  operations.push(
+    [join18(directory, "NeoGeneratedTypes.cs"), null],
+    [join18(directory, "NeoGeneratedTypes.cs.meta"), null]
+  );
+  for (const file of files) {
+    const old = manifest?.projectId === projectId ? previousById.get(file.id) : void 0;
+    const path = join18(directory, file.path);
+    if (old !== void 0 && old.path !== file.path) {
+      if (!previousPaths.has(file.path.toLowerCase()) && (existsSync16(path) || existsSync16(path + ".meta")))
+        throw new Error(
+          `Generated rename destination is not owned by the manifest: ${file.path}`
+        );
+      const meta = join18(directory, old.path + ".meta");
+      operations.push([
+        path + ".meta",
+        existsSync16(meta) ? readFileSync21(meta, "utf8") : null
+      ]);
+    }
+    operations.push([path, file.content]);
+  }
+  operations.push([
+    manifestPath,
+    JSON.stringify(
+      {
+        schemaVersion: 1,
+        projectId,
+        files: [...files].sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0).map((file) => ({
+          id: file.id,
+          path: file.path,
+          hash: createHash12("sha256").update(file.content).digest("hex")
+        }))
+      },
+      null,
+      2
+    ) + "\n"
+  ]);
+  const previous = /* @__PURE__ */ new Map();
+  for (const [path] of operations) {
+    const key = path.toLowerCase();
+    if (!previous.has(key))
+      previous.set(key, {
+        path,
+        content: existsSync16(path) ? readFileSync21(path, "utf8") : null
+      });
+  }
+  const write = (path, content) => {
+    if (content === null) {
+      if (existsSync16(path)) unlinkSync(path);
+    } else {
+      mkdirSync13(dirname11(path), { recursive: true });
+      writeFileSync13(path, content);
+    }
+  };
+  const changed = [];
+  try {
+    for (const [path, content] of operations) {
+      const current = existsSync16(path) ? readFileSync21(path, "utf8") : null;
+      if (current === content) continue;
+      changed.push(path);
+      write(path, content);
+    }
+  } catch (error) {
+    const restored = /* @__PURE__ */ new Set();
+    for (const path of changed.reverse()) {
+      const key = path.toLowerCase();
+      if (restored.has(key)) continue;
+      restored.add(key);
+      const original = previous.get(key);
+      if (original.path !== path && existsSync16(path)) unlinkSync(path);
+      const current = existsSync16(original.path) ? readFileSync21(original.path, "utf8") : null;
+      if (current !== original.content) write(original.path, original.content);
+    }
+    throw error;
+  }
+}
+var init_unity_generated_files = __esm({
+  "src/unity-generated-files.ts"() {
+    "use strict";
+  }
+});
+
 // src/commands/export.ts
 var export_exports = {};
 __export(export_exports, {
   runExportUnity: () => runExportUnity
 });
-import { mkdirSync as mkdirSync13, writeFileSync as writeFileSync13 } from "node:fs";
-import { join as join18 } from "node:path";
+import { mkdirSync as mkdirSync14, writeFileSync as writeFileSync14 } from "node:fs";
+import { join as join19 } from "node:path";
 async function runExportUnity(workspace, outDir) {
   if (outDir === null) {
     throw new Error(
@@ -138846,23 +139010,24 @@ async function runExportUnity(workspace, outDir) {
     `/api/projects/${workspace.config.projectId}/export`,
     { versionId: workspace.config.versionId }
   );
-  const resourcesDir = join18(outDir, "Resources", "Neo");
-  const localizationDir = join18(resourcesDir, "Localization");
-  const scriptsDir = join18(outDir, "Scripts", "Neo");
-  mkdirSync13(localizationDir, { recursive: true });
-  mkdirSync13(scriptsDir, { recursive: true });
-  writeFileSync13(join18(resourcesDir, "project.json"), response.projectJson);
-  writeFileSync13(
-    join18(scriptsDir, "NeoGeneratedTypes.cs"),
-    response.generatedTypes
-  );
+  const resourcesDir = join19(outDir, "Resources", "Neo");
+  const localizationDir = join19(resourcesDir, "Localization");
+  const scriptsDir = join19(outDir, "Scripts", "Neo");
+  mkdirSync14(localizationDir, { recursive: true });
+  mkdirSync14(scriptsDir, { recursive: true });
+  writeUnityGeneratedFiles(
+    scriptsDir,
+    response.projectId,
+    response.generatedFiles
+  );
+  writeFileSync14(join19(resourcesDir, "project.json"), response.projectJson);
   for (const file of response.localizationFiles ?? []) {
-    writeFileSync13(join18(localizationDir, file.fileName), file.content);
+    writeFileSync14(join19(localizationDir, file.fileName), file.content);
   }
-  console.log(`wrote ${join18(resourcesDir, "project.json")}`);
-  console.log(`wrote ${join18(scriptsDir, "NeoGeneratedTypes.cs")}`);
+  console.log(`wrote ${join19(resourcesDir, "project.json")}`);
+  console.log(`synchronized generated files in ${scriptsDir}`);
   for (const file of response.localizationFiles ?? []) {
-    console.log(`wrote ${join18(localizationDir, file.fileName)}`);
+    console.log(`wrote ${join19(localizationDir, file.fileName)}`);
   }
   const diagnostics = response.diagnostics ?? [];
   for (const diagnostic of diagnostics) {
@@ -138875,6 +139040,7 @@ async function runExportUnity(workspace, outDir) {
 var init_export = __esm({
   "src/commands/export.ts"() {
     "use strict";
+    init_unity_generated_files();
     init_http();
   }
 });
@@ -138885,7 +139051,7 @@ __export(dev_exports, {
   runDev: () => runDev
 });
 import { watch } from "node:fs";
-import { join as join19 } from "node:path";
+import { join as join20 } from "node:path";
 import { emitKeypressEvents } from "node:readline";
 import { ConvexClient } from "convex/browser";
 function isSchemaSignal(value) {
@@ -138995,7 +139161,7 @@ async function runDev(workspace, options) {
   };
   for (const dir of ["Classes", "Enums"]) {
     try {
-      watch(join19(workspace.root, dir), { persistent: true }, onFileChange);
+      watch(join20(workspace.root, dir), { persistent: true }, onFileChange);
     } catch {
     }
   }
@@ -139049,8 +139215,8 @@ __export(resolve_exports, {
   resolveMarkers: () => resolveMarkers,
   runResolve: () => runResolve
 });
-import { readFileSync as readFileSync21, rmSync as rmSync8, writeFileSync as writeFileSync14 } from "node:fs";
-import { join as join20, relative as relative11 } from "node:path";
+import { readFileSync as readFileSync22, rmSync as rmSync8, writeFileSync as writeFileSync15 } from "node:fs";
+import { join as join21, relative as relative11 } from "node:path";
 function runResolve(workspace, side) {
   const marked = readMarkedProjectSourcesV4(workspace.root);
   assertRecordConflictsResolveTogetherV4(
@@ -139060,7 +139226,7 @@ function runResolve(workspace, side) {
   const resolvedRecords = adoptServerConflictBases(workspace);
   let resolvedFiles = 0;
   for (const file of marked) {
-    writeFileSync14(file.absolutePath, resolveMarkers(file.source, side), "utf8");
+    writeFileSync15(file.absolutePath, resolveMarkers(file.source, side), "utf8");
     resolvedFiles += 1;
   }
   let resolvedBinaries = 0;
@@ -139068,12 +139234,12 @@ function runResolve(workspace, side) {
     const binary = state.projectBinary;
     const conflict2 = binary?.conflict;
     if (binary === void 0 || conflict2 === void 0) continue;
-    const destination = join20(workspace.root, binary.path);
+    const destination = join21(workspace.root, binary.path);
     if (side === "theirs") {
       if (conflict2.remoteSha256 !== null && conflict2.artifactPath !== void 0) {
         writeVerifiedBinaryDownloadV4(
           destination,
-          readFileSync21(join20(workspace.root, conflict2.artifactPath)),
+          readFileSync22(join21(workspace.root, conflict2.artifactPath)),
           conflict2.remoteSha256
         );
         binary.sha256 = conflict2.remoteSha256;
@@ -139083,7 +139249,7 @@ function runResolve(workspace, side) {
       }
     }
     if (conflict2.artifactPath !== void 0) {
-      rmSync8(join20(workspace.root, conflict2.artifactPath), { force: true });
+      rmSync8(join21(workspace.root, conflict2.artifactPath), { force: true });
     }
     delete binary.conflict;
     resolvedBinaries += 1;
@@ -139102,7 +139268,7 @@ function runResolve(workspace, side) {
 function readMarkedProjectSourcesV4(root) {
   const files = [];
   for (const absolutePath of listProjectSourceFilesV4(root)) {
-    const source = readFileSync21(absolutePath, "utf8");
+    const source = readFileSync22(absolutePath, "utf8");
     if (detectConflictMarkers(source) === null) continue;
     files.push({
       path: normalizeWorkspaceSourcePath(relative11(root, absolutePath)),
@@ -139402,7 +139568,7 @@ There is no --keep-current: preserving current semantic state defines flatten.
 async function main() {
   const args = parseArgs(process.argv.slice(2));
   if (args.command === "--version") {
-    console.log("0.50.1");
+    console.log("0.50.2");
     return;
   }
   if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neocompose/cli",
-  "version": "0.50.1",
+  "version": "0.50.2",
   "description": "Neo Compose native project-source CLI with bidirectional sync.",
   "license": "MIT",
   "type": "module",

package/skills/neocompose-cli/SKILL.md

@@ -9,7 +9,7 @@ description: >-
   `@neocompose/cli` or `node cli/bin/neo.mjs` in the neo-compose repository.
 ---
 
-<!-- reviewed-through-cli: 0.50.1 -->
+<!-- reviewed-through-cli: 0.50.2 -->
 
 # Neo Compose CLI
 

package/skills/neocompose-cli/references/cli-development.md

@@ -88,7 +88,7 @@ wrappers.
 The marker near the top of `SKILL.md` must exactly match the package version:
 
 ```html
-<!-- reviewed-through-cli: 0.50.1 -->
+<!-- reviewed-through-cli: 0.50.2 -->
 ```
 
 The quoted version above is checked too, so this instruction cannot go stale

package/skills/neocompose-cli/references/commands-and-sync.md

@@ -246,3 +246,11 @@ honor both variables.
 
 Pass explicit project/version IDs and flags in automation. Prefer `--json` for
 machine-readable output and do not depend on interactive pickers or confirms.
+
+## Unity code export
+
+`neo export unity --out <UnityAssetsDir>` writes separate C# files under
+`Scripts/Neo/Generated/`, named after the generated C# types, plus project and localization JSON. It compares
+contents before writing C#, preserves unchanged `.meta` files, removes obsolete
+outputs listed in `NeoGeneratedFiles.json`, and removes the former
+`NeoGeneratedTypes.cs`. Stable identities in the manifest preserve `.meta` GUIDs when types are renamed. Keep the manifest with the generated files.