@neocompose/cli 0.50.1 → 0.50.3

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## [0.50.3] - 2026-09-14
+
+- Preserve packed siblings when preparing push source identity for new children in an existing value graph. Pending seeds now fill missing rows without replacing reconstructed stored rows.
+- Resolve omitted fields on stored classes without construction records from their shared declaration defaults. CLI validation, NeoScript reads, and editor value cells now agree without adding per-instance overrides or inventing constructor provenance.
+
+## [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",
@@ -53894,7 +53894,7 @@ function buildDefaultMemberValue(args) {
         `Cannot create a value of missing class "${effectiveClassId}".`
       );
     }
-    if (member.payload !== 1 /* Partial */ && typeof effectiveClass.requiredConstructorId === "string" && args.constructorRoot === void 0 && args.authoredRoot === void 0) {
+    if (member.payload !== 1 /* Partial */ && typeof effectiveClass.requiredConstructorId === "string" && args.constructorRoot === void 0 && args.authoredRoot === void 0 && args.declarationRoot !== true) {
       throw new Error(
         `Class "${effectiveClass.name}" declares a required constructor; provide its constructor arguments.`
       );
@@ -53967,6 +53967,9 @@ function buildDefaultMemberValue(args) {
         anchorsParentClassPartition = true;
       }
       if (record4[schemaKey] !== void 0) continue;
+      if (args.declarationRoot === true && !isLiteralValueContent(resolvedChildMember.defaultValue)) {
+        continue;
+      }
       if (args.authoredRoot?.suppliedSchemaKeys.has(schemaKey) === true) {
         continue;
       }
@@ -81273,10 +81276,10 @@ function materializeMemberDefaultValue(args) {
   args.readTracking?.recordUnattributableValueRead(
     `declaration-owner-resolution:${args.envelope.id}`
   );
-  const { valuesById, rootOwners } = declarationInitializerContext(
-    args.document
-  );
   const declarationArguments = (member, init, sourceValueId) => {
+    const { valuesById, rootOwners } = declarationInitializerContext(
+      args.document
+    );
     const ownerClass = typeof sourceValueId === "string" ? initializerOwnerContext(
       args.document,
       sourceValueId,
@@ -81308,6 +81311,7 @@ function materializeMemberDefaultValue(args) {
     member: args.member,
     createdValues,
     storageKeyDeclarations,
+    declarationRoot: args.declarationRoot,
     ...args.genericEnv === void 0 ? {} : { genericEnv: args.genericEnv },
     // A declaration default may itself be init-backed one level down (P43 §2),
     // and those nested initializers must evaluate against the same document.
@@ -81750,13 +81754,12 @@ function resolveVirtualInstanceGraph(args) {
     const effective = {
       ...mergeExpandedAndMaterializedRow(indexed.expandedRow, materialized),
       id: effectiveId,
-      // Virtual rows inherit partition and timestamps from the root. Real rows
-      // retain their own envelope through the spread above.
+      // Materialization has already resolved each child's storage partition.
+      // Virtual rows inherit root timestamps; real rows retain their envelope.
       ...materialized === null ? {
         projectId: args.instanceRoot.projectId,
         createdAt: args.instanceRoot.createdAt,
-        updatedAt: args.instanceRoot.updatedAt,
-        ...args.instanceRoot.mapKey === void 0 ? {} : { mapKey: args.instanceRoot.mapKey }
+        updatedAt: args.instanceRoot.updatedAt
       } : {}
     };
     if (isMemberClassBase(indexed.member) && effective.value !== null) {
@@ -82036,13 +82039,26 @@ function resolvedStoredInstanceRows(args) {
   const rows = new Map(document.values.map((row) => [row.id, row]));
   const materializedIndex = buildVirtualInstanceMaterializedIndex({ document });
   const queue = [{ root: args.instanceRoot, member: args.rootMember }];
+  const stored = indexExpansion({
+    document,
+    instanceRoot: args.instanceRoot,
+    rootMember: args.rootMember,
+    expandedRoot: rows.get(args.instanceRoot.id) ?? args.instanceRoot,
+    expandedRows: document.values
+  });
+  for (const node of stored.nodesByPath.values()) {
+    if (node.expandedRow.id === args.instanceRoot.id) continue;
+    if (!isMemberClassBase(node.member)) continue;
+    if (!isStoredClassResolutionRoot(node.expandedRow)) continue;
+    queue.push({ root: node.expandedRow, member: node.member });
+  }
   const resolvedRootIds = /* @__PURE__ */ new Set();
   const resolvedFrameByValueId = /* @__PURE__ */ new Map();
   while (queue.length > 0) {
     const next = queue.shift();
     if (next === void 0 || resolvedRootIds.has(next.root.id)) continue;
     resolvedRootIds.add(next.root.id);
-    const expanded = expandStoredInstance({
+    const expanded = expandStoredClassValue({
       evaluateInitializer: args.evaluateInitializer,
       document,
       instanceRoot: next.root,
@@ -82089,6 +82105,63 @@ function resolvedStoredInstanceRows(args) {
   }
   return rows;
 }
+function expandStoredClassValue(args) {
+  if (isLiteralValueContent(args.instanceRoot) && isVirtualInstanceRootShape(args.instanceRoot)) {
+    return expandStoredInstance(args);
+  }
+  const root = literalRow(args.instanceRoot);
+  if (root.constructorArgs !== void 0) return expandStoredInstance(args);
+  const member = resolveMember2(args.rootMember, args.document.members);
+  if (!isMemberClassBase(member)) {
+    throw new Error(
+      `Stored default projection member "${memberIdOf(args.rootMember)}" is not Class-valued.`
+    );
+  }
+  if (member.payload === 1 /* Partial */) {
+    return { root, rows: [], pinnedRootSchemaKeys: /* @__PURE__ */ new Set() };
+  }
+  if (root.value === null) {
+    return { root, rows: [], pinnedRootSchemaKeys: /* @__PURE__ */ new Set() };
+  }
+  const classId = root.classId ?? member.classId;
+  args.readRecorder?.recordValueRead(root.id);
+  args.readRecorder?.recordGlobalRead("declaration-default");
+  const materialized = materializeMemberDefaultValue({
+    evaluateInitializer: args.evaluateInitializer,
+    document: args.document,
+    member: closeClassArgumentsFromRowStamp(
+      {
+        ...member,
+        classId,
+        defaultValue: derivesContentFromMemberDefault({
+          member,
+          instanceRoot: root,
+          effectiveClassId: classId
+        }) ? member.defaultValue : void 0
+      },
+      root
+    ),
+    envelope: root,
+    declarationRoot: true
+  });
+  return {
+    root: { ...root, classId, value: materialized.root.value },
+    rows: materialized.createdValues,
+    pinnedRootSchemaKeys: /* @__PURE__ */ new Set()
+  };
+}
+function isStoredClassResolutionRoot(value) {
+  if (!isLiteralValueContent(value)) return false;
+  if (isVirtualInstanceRootShape(value)) return true;
+  return typeof value.classId === "string" && value.value !== null && typeof value.value === "object" && !Array.isArray(value.value);
+}
+function storedClassResolutionMember(member, row, members) {
+  const resolved = resolveMember2(member, members);
+  if (isMemberClassBase(resolved)) return resolved;
+  if (resolved.kind !== 21 /* Generic */ || typeof row.classId !== "string")
+    return null;
+  return { ...resolved, kind: 7 /* Class */, classId: row.classId };
+}
 function planVirtualOverrideWrite(args) {
   const target = args.graph.locationsById.get(args.valueId);
   if (target === void 0) {
@@ -83569,8 +83642,12 @@ function createHeadlessVirtualInstanceResolver(args) {
       failedRootIds.add(rootId);
       return /* @__PURE__ */ new Map();
     }
-    const member = resolveMember2(declaredMember, document.members);
-    if (!isMemberClassBase(member) || !isLiteralValueContent(instanceRoot)) {
+    const member = storedClassResolutionMember(
+      declaredMember,
+      instanceRoot,
+      document.members
+    );
+    if (member === null || !isLiteralValueContent(instanceRoot)) {
       failedRootIds.add(rootId);
       return /* @__PURE__ */ new Map();
     }
@@ -83580,7 +83657,7 @@ function createHeadlessVirtualInstanceResolver(args) {
         document: resolverDocument,
         materializedRows: document.values
       });
-      const expanded = expandStoredInstance({
+      const expanded = expandStoredClassValue({
         evaluateInitializer: args.evaluateInitializer,
         document: resolverDocument,
         instanceRoot,
@@ -83622,7 +83699,7 @@ function createHeadlessVirtualInstanceResolver(args) {
     while (placement !== null) {
       args.readRecorder?.recordValueRead(placement.valueId);
       const raw = rawById.get(placement.valueId);
-      if (raw !== void 0 && isLiteralValueContent(raw) && isVirtualInstanceRootShape(raw)) {
+      if (raw !== void 0 && isLiteralValueContent(raw) && isStoredClassResolutionRoot(raw)) {
         return [...expandRoot(placement.valueId, placement.memberId).values()];
       }
       placement = placement.parentValueId === null ? null : placements().get(placement.parentValueId) ?? null;
@@ -84032,6 +84109,12 @@ var init_materialize_values = __esm({
 });
 
 // ../src/runtime/virtual-instance-values.ts
+function expandStoredClassValue2(args) {
+  return expandStoredClassValue({
+    ...args,
+    evaluateInitializer: evaluateMemberInitializer
+  });
+}
 function expandStoredInstance2(args) {
   return expandStoredInstance({
     ...args,
@@ -101776,6 +101859,7 @@ var init_project_version_static_value_writes = __esm({
       dialogueIds = /* @__PURE__ */ new Set();
       schemaIndex;
       virtualValueIds;
+      declarationMaterializedIndex = null;
       stack = /* @__PURE__ */ new Set();
       createdCollectionStampByValueId = /* @__PURE__ */ new Map();
       /** Built once and reused by every nested construction-root proof. */
@@ -101902,11 +101986,51 @@ var init_project_version_static_value_writes = __esm({
             args.genericEnv,
             args.path
           );
-          this.validateSemanticNode({ ...args, member, value });
+          const resolved = this.resolveDeclaredDefaults(
+            member,
+            value,
+            args.genericEnv
+          );
+          this.validateSemanticNode({ ...args, member, value: resolved });
         } finally {
           this.stack.delete(value.id);
         }
       }
+      resolveDeclaredDefaults(member, value, genericEnv) {
+        const closed = substituteMember(member, genericEnv, this.document.members);
+        if (!isMemberClassBase(closed)) return value;
+        if (!isLiteralValueContent(value)) return value;
+        if (value.value === null || typeof value.value !== "object" || Array.isArray(value.value))
+          return value;
+        if (value.instanceConstructorId !== void 0 || value.instanceVariantId != null)
+          return value;
+        if (this.virtualValueIds.has(value.id)) return value;
+        const expanded = expandStoredClassValue2({
+          document: this.merged().document,
+          instanceRoot: value,
+          rootMember: closed
+        });
+        const graph = resolveVirtualInstanceGraph({
+          document: this.merged().document,
+          instanceRoot: value,
+          rootMember: closed,
+          expandedRoot: expanded.root,
+          expandedRows: expanded.rows,
+          materializedIndex: this.declarationMaterializedIndex ??= buildVirtualInstanceMaterializedIndex({
+            document: this.merged().document
+          })
+        });
+        for (const [id2, row] of graph.rowsById) {
+          if (this.valueById.has(id2)) continue;
+          this.valueById.set(id2, row);
+        }
+        const resolved = graph.rowsById.get(value.id);
+        if (resolved === void 0 || !isLiteralValueContent(resolved))
+          return value;
+        if (resolved.value === null || typeof resolved.value !== "object" || Array.isArray(resolved.value))
+          return value;
+        return { ...resolved, value: { ...resolved.value, ...value.value } };
+      }
       /**
        * A static graph can contain nested construction roots under an ordinary
        * list or Class root. Replay each reachable root that carries complete
@@ -130834,20 +130958,22 @@ function createPendingProjectSourceIdentityV4(workspace, status, authoredValueSe
       });
     }
     if (seed.valueId === void 0) continue;
-    records2.set(`value:${seed.valueId}`, {
-      recordKind: "value",
-      recordId: seed.valueId,
-      contentHash: "",
-      deleted: false,
-      data: {
-        id: seed.valueId,
-        projectId: workspace.config.projectId,
-        ...encodeStoredValueNode(seed),
-        createdAt: now,
-        updatedAt: now
-      }
-    });
+    if (!records2.has(`value:${seed.valueId}`))
+      records2.set(`value:${seed.valueId}`, {
+        recordKind: "value",
+        recordId: seed.valueId,
+        contentHash: "",
+        deleted: false,
+        data: {
+          id: seed.valueId,
+          projectId: workspace.config.projectId,
+          ...encodeStoredValueNode(seed),
+          createdAt: now,
+          updatedAt: now
+        }
+      });
     for (const value of seed.values ?? []) {
+      if (records2.has(`value:${value.id}`)) continue;
       records2.set(`value:${value.id}`, {
         recordKind: "value",
         recordId: value.id,
@@ -132352,7 +132478,7 @@ var init_registry2 = __esm({
   "schema-contract/registry.mjs"() {
     "use strict";
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
-      cliVersion: "0.50.1",
+      cliVersion: "0.50.3",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -138828,13 +138954,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 +139136,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 +139166,7 @@ async function runExportUnity(workspace, outDir) {
 var init_export = __esm({
   "src/commands/export.ts"() {
     "use strict";
+    init_unity_generated_files();
     init_http();
   }
 });
@@ -138885,7 +139177,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 +139287,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 +139341,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 +139352,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 +139360,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 +139375,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 +139394,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 +139694,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.3");
     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.3",
   "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.3 -->
 
 # 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.3 -->
 ```
 
 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.

package/skills/neocompose-cli/references/values-identities-and-references.md

@@ -136,6 +136,13 @@ member creates a sparse override with its deterministic projected ID; removing
 that member from an existing initializer resets the override and resumes source
 tracking. Require either transition to appear in `neo diff`.
 
+A stored class with no construction record still inherits literal declaration
+defaults for omitted fields. For example, `FoodInfo.Quality = .OneStar` supplies
+the quality of an existing food row that stores only its price. Do not add an
+instance override to repair that omission. Reads do not invent a historical
+constructor, and required fields with no applicable default remain errors.
+Explicit stored overrides and partial payloads keep their existing meaning.
+
 Generic arguments specify types, not default values. A required generic member
 must be supplied at construction unless its member declaration or an inherited
 member declaration supplies a default. Missing required members are compile