@neocompose/cli 0.36.7 → 0.36.9

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## [0.36.9] - 2026-08-20
+
+### Fixed
+
+- Preserve shared aggregate constructor arguments as value references during
+  canonical pull emission, preventing web-created placements from duplicating
+  catalog rows or reporting false value-containment cycles.
+
+## [0.36.8] - 2026-08-20
+
+### Fixed
+
+- Ignore server-compiled initializer IR when deciding whether both sides of a
+  pull changed authored value source, preventing compiler-only refreshes from
+  producing false conflicts.
+- Let `neo resolve --mine` and `neo resolve --theirs` clear metadata-only
+  record conflicts retained by older pulls even when no textual marker was
+  written.
+
 ## [0.36.7] - 2026-08-20
 
 ### Fixed

package/dist/neo.mjs

@@ -45228,6 +45228,21 @@ function findSchemaPlacement(memberId, classes) {
   }
   return null;
 }
+function findNearestAncestorSchemaPlacement(ownerClass, schemaKey, classesById) {
+  const visited = /* @__PURE__ */ new Set([ownerClass.id]);
+  let ancestorId = ownerClass.extendsClassId;
+  while (typeof ancestorId === "string") {
+    if (visited.has(ancestorId)) return null;
+    visited.add(ancestorId);
+    const ancestor = classesById.get(ancestorId);
+    if (ancestor === void 0) return null;
+    if (typeof ancestor.schema[schemaKey] === "string") {
+      return { ownerClass: ancestor, schemaKey };
+    }
+    ancestorId = ancestor.extendsClassId;
+  }
+  return null;
+}
 function walkExtendsMemberChain(startId, members, pick, options) {
   const requireKind = options?.requireKind;
   const maxHops = options?.maxHops ?? 16;
@@ -57224,6 +57239,104 @@ var init_dialogue_sources = __esm({
   }
 });
 
+// ../src/models/variants/variants.ts
+function isNonEmptyString2(value) {
+  if (typeof value !== "string") return false;
+  return value.length > 0;
+}
+function isNeoClassVariant(value) {
+  if (typeof value !== "object" || value === null) return false;
+  if (Array.isArray(value)) return false;
+  const v = value;
+  if (!isNonEmptyString2(v.id)) return false;
+  if (!isNonEmptyString2(v.classId)) return false;
+  if (!isNonEmptyString2(v.name)) return false;
+  if (!isNonEmptyString2(v.valueId)) return false;
+  if (v.folderId !== null && !isNonEmptyString2(v.folderId)) return false;
+  return true;
+}
+function isNeoClassVariantFolder(value) {
+  if (typeof value !== "object" || value === null) return false;
+  if (Array.isArray(value)) return false;
+  const v = value;
+  if (!isNonEmptyString2(v.id)) return false;
+  if (!isNonEmptyString2(v.classId)) return false;
+  if (typeof v.path !== "string") return false;
+  if (v.binding === void 0 || v.binding === null) return v.path.length > 0;
+  if (typeof v.binding !== "object" || Array.isArray(v.binding)) return false;
+  const binding = v.binding;
+  if (!isNonEmptyString2(binding.collectionMemberId)) return false;
+  if (!isNonEmptyString2(binding.collectionValueId)) return false;
+  return true;
+}
+var NEO_VARIANT_INITIALIZE_SCHEMA_KEY, NEO_VARIANT_APPLY_SCHEMA_KEY, NEO_VARIANT_OVERRIDES_SCHEMA_KEY, NEO_VARIANT_CHILD_OVERRIDES_SCHEMA_KEY;
+var init_variants = __esm({
+  "../src/models/variants/variants.ts"() {
+    "use strict";
+    NEO_VARIANT_INITIALIZE_SCHEMA_KEY = "Initialize";
+    NEO_VARIANT_APPLY_SCHEMA_KEY = "Apply";
+    NEO_VARIANT_OVERRIDES_SCHEMA_KEY = "Overrides";
+    NEO_VARIANT_CHILD_OVERRIDES_SCHEMA_KEY = "ChildOverrides";
+  }
+});
+
+// ../src/models/variants/variant-member.ts
+function neoVariantSystemClass(classes, lookup = false) {
+  const declared = classes.find(
+    (item) => item.system?.worldKind === (lookup ? NeoWorldSystemClassKind.LookupVariant : NeoWorldSystemClassKind.Variant)
+  );
+  if (declared === void 0) return null;
+  const targetParamId = declared.genericParams?.[0]?.id;
+  if (targetParamId === void 0) return null;
+  const valueParamId = declared.genericParams?.[1]?.id;
+  return {
+    classId: declared.id,
+    targetParamId,
+    ...valueParamId === void 0 ? {} : { valueParamId }
+  };
+}
+var init_variant_member = __esm({
+  "../src/models/variants/variant-member.ts"() {
+    "use strict";
+    init_core();
+    init_member_kind_enum();
+  }
+});
+
+// ../src/models/variants/variant-naming.ts
+var init_variant_naming = __esm({
+  "../src/models/variants/variant-naming.ts"() {
+    "use strict";
+  }
+});
+
+// ../src/models/variants/variant-write.ts
+var init_variant_write = __esm({
+  "../src/models/variants/variant-write.ts"() {
+    "use strict";
+  }
+});
+
+// ../src/models/variants/variant-initialize-source.ts
+var init_variant_initialize_source = __esm({
+  "../src/models/variants/variant-initialize-source.ts"() {
+    "use strict";
+    init_member_kind_enum();
+  }
+});
+
+// ../src/models/variants/index.ts
+var init_variants2 = __esm({
+  "../src/models/variants/index.ts"() {
+    "use strict";
+    init_variants();
+    init_variant_member();
+    init_variant_naming();
+    init_variant_write();
+    init_variant_initialize_source();
+  }
+});
+
 // src/project-source/lower-support.ts
 function identityMap(declarations, kind) {
   return new Map(
@@ -61184,99 +61297,6 @@ var init_member_value_id = __esm({
   }
 });
 
-// ../src/models/variants/variants.ts
-function isNonEmptyString2(value) {
-  if (typeof value !== "string") return false;
-  return value.length > 0;
-}
-function isNeoClassVariant(value) {
-  if (typeof value !== "object" || value === null) return false;
-  if (Array.isArray(value)) return false;
-  const v = value;
-  if (!isNonEmptyString2(v.id)) return false;
-  if (!isNonEmptyString2(v.classId)) return false;
-  if (!isNonEmptyString2(v.name)) return false;
-  if (!isNonEmptyString2(v.valueId)) return false;
-  if (v.folderId !== null && !isNonEmptyString2(v.folderId)) return false;
-  return true;
-}
-function isNeoClassVariantFolder(value) {
-  if (typeof value !== "object" || value === null) return false;
-  if (Array.isArray(value)) return false;
-  const v = value;
-  if (!isNonEmptyString2(v.id)) return false;
-  if (!isNonEmptyString2(v.classId)) return false;
-  if (typeof v.path !== "string") return false;
-  if (v.binding === void 0 || v.binding === null) return v.path.length > 0;
-  if (typeof v.binding !== "object" || Array.isArray(v.binding)) return false;
-  const binding = v.binding;
-  if (!isNonEmptyString2(binding.collectionMemberId)) return false;
-  if (!isNonEmptyString2(binding.collectionValueId)) return false;
-  return true;
-}
-var init_variants = __esm({
-  "../src/models/variants/variants.ts"() {
-    "use strict";
-  }
-});
-
-// ../src/models/variants/variant-member.ts
-function neoVariantSystemClass(classes, lookup = false) {
-  const declared = classes.find(
-    (item) => item.system?.worldKind === (lookup ? NeoWorldSystemClassKind.LookupVariant : NeoWorldSystemClassKind.Variant)
-  );
-  if (declared === void 0) return null;
-  const targetParamId = declared.genericParams?.[0]?.id;
-  if (targetParamId === void 0) return null;
-  const valueParamId = declared.genericParams?.[1]?.id;
-  return {
-    classId: declared.id,
-    targetParamId,
-    ...valueParamId === void 0 ? {} : { valueParamId }
-  };
-}
-var init_variant_member = __esm({
-  "../src/models/variants/variant-member.ts"() {
-    "use strict";
-    init_core();
-    init_member_kind_enum();
-  }
-});
-
-// ../src/models/variants/variant-naming.ts
-var init_variant_naming = __esm({
-  "../src/models/variants/variant-naming.ts"() {
-    "use strict";
-  }
-});
-
-// ../src/models/variants/variant-write.ts
-var init_variant_write = __esm({
-  "../src/models/variants/variant-write.ts"() {
-    "use strict";
-  }
-});
-
-// ../src/models/variants/variant-initialize-source.ts
-var init_variant_initialize_source = __esm({
-  "../src/models/variants/variant-initialize-source.ts"() {
-    "use strict";
-    init_member_kind_enum();
-  }
-});
-
-// ../src/models/variants/index.ts
-var init_variants2 = __esm({
-  "../src/models/variants/index.ts"() {
-    "use strict";
-    init_variants();
-    init_variant_member();
-    init_variant_naming();
-    init_variant_write();
-    init_variant_initialize_source();
-  }
-});
-
 // ../src/models/project/project-root-members.ts
 function buildRootStorageMap(project) {
   const map = /* @__PURE__ */ new Map();
@@ -76389,6 +76409,23 @@ var init_workspace = __esm({
   }
 });
 
+// src/project-sync/value-record-comparison.ts
+function valueRecordComparisonBody(value) {
+  if (!isObjectRecord2(value)) return value;
+  const init = value.init;
+  const body = value.value;
+  const normalizedInit = isObjectRecord2(init) && init.compiled !== void 0 ? { ...init, compiled: void 0 } : init;
+  const normalizedBody = isObjectRecord2(body) && typeof body.code === "string" && body.action !== void 0 ? { ...body, action: void 0 } : body;
+  if (normalizedInit === init && normalizedBody === body) return value;
+  return { ...value, init: normalizedInit, value: normalizedBody };
+}
+var init_value_record_comparison = __esm({
+  "src/project-sync/value-record-comparison.ts"() {
+    "use strict";
+    init_projection();
+  }
+});
+
 // src/project-source/lower-configuration.ts
 function lowerConfiguration(base, analysis) {
   const globals = analysis.configuration.globals;
@@ -89747,6 +89784,97 @@ var init_localizable_member_value_writes = __esm({
 });
 
 // ../src/database/project-version-schema-commit.ts
+function indexRecordsById(records2) {
+  const recordsById2 = /* @__PURE__ */ new Map();
+  for (const record3 of records2) recordsById2.set(record3.id, record3);
+  return recordsById2;
+}
+function indexLiveContentHashesByRecordId(heads, recordKind) {
+  const hashes = /* @__PURE__ */ new Map();
+  for (const head of heads) {
+    if (head.recordKind !== recordKind || head.deleted) continue;
+    hashes.set(head.recordId, head.contentHash);
+  }
+  return hashes;
+}
+function indexLiveContentHashesByRecordKey(heads) {
+  const hashes = /* @__PURE__ */ new Map();
+  for (const head of heads) {
+    if (head.deleted) continue;
+    hashes.set(`${head.recordKind}:${head.recordId}`, head.contentHash);
+  }
+  return hashes;
+}
+function indexChangesByRecordId(changes, recordKind) {
+  const indexes = /* @__PURE__ */ new Map();
+  for (let index = 0; index < changes.length; index += 1) {
+    const change = changes[index];
+    if (change?.recordKind === recordKind) indexes.set(change.recordId, index);
+  }
+  return indexes;
+}
+function reconcileDirectOverrideChains(args) {
+  if (!args.changes.some(
+    (change) => change.recordKind === "class" || change.recordKind === "member"
+  )) {
+    return;
+  }
+  const postDocument = applyProjectVersionWriteChanges(
+    args.document,
+    args.changes
+  );
+  const postClassesById = indexRecordsById(postDocument.classes);
+  const postMembersById = indexRecordsById(postDocument.members);
+  const changeIndexByMemberId = indexChangesByRecordId(args.changes, "member");
+  let baseHashByMemberId = null;
+  for (const schemaClass2 of postDocument.classes) {
+    for (const [schemaKey, memberId] of Object.entries(schemaClass2.schema)) {
+      const member = postMembersById.get(memberId);
+      if (member === void 0 || typeof member.extendsMemberId !== "string") {
+        continue;
+      }
+      const expectedPlacement = findNearestAncestorSchemaPlacement(
+        schemaClass2,
+        schemaKey,
+        postClassesById
+      );
+      const expected = expectedPlacement?.ownerClass.schema[expectedPlacement.schemaKey];
+      if (expected === member.extendsMemberId) continue;
+      if (typeof expected !== "string") continue;
+      const nextMember = { ...member, extendsMemberId: expected };
+      postMembersById.set(member.id, nextMember);
+      const existingIndex = changeIndexByMemberId.get(member.id);
+      if (existingIndex !== void 0) {
+        const existing = args.changes[existingIndex];
+        if (existing !== void 0) {
+          args.changes[existingIndex] = { ...existing, nextData: nextMember };
+        }
+        continue;
+      }
+      baseHashByMemberId ??= indexLiveContentHashesByRecordId(
+        args.contentHashHeads,
+        "member"
+      );
+      const expectedBaseContentHash = baseHashByMemberId.get(member.id);
+      if (expectedBaseContentHash === void 0) {
+        throw new Error(
+          `Cannot safely repair override chain for member "${member.name}" (${member.id}): its current content hash is unavailable.`
+        );
+      }
+      changeIndexByMemberId.set(member.id, args.changes.length);
+      args.changes.push({
+        recordKind: "member",
+        recordId: member.id,
+        operation: "update",
+        nextData: nextMember,
+        expectedBaseContentHash,
+        intent: createProjectVersionIntent("member.update", {
+          source: "server-direct-override-chain-reconcile"
+        })
+      });
+    }
+  }
+}
 function prepareServerOwnedSchemaCommit(args) {
   if (args.forceRecompile === true) clearNeoScriptBodyCompileCache();
   assertUniqueChanges(args.changes);
@@ -89767,6 +89895,18 @@ function prepareServerOwnedSchemaCommit(args) {
     ),
     changes: authoredChanges
   });
+  const explicitlyChangedMemberIds = /* @__PURE__ */ new Set();
+  for (const change of authoredChanges) {
+    if (change.recordKind !== "member" || change.operation === "delete") {
+      continue;
+    }
+    explicitlyChangedMemberIds.add(change.recordId);
+  }
+  reconcileDirectOverrideChains({
+    document: args.document,
+    changes: authoredChanges,
+    contentHashHeads: args.contentHashHeads
+  });
   assertNoLegacyWorldLayerBindingFields(authoredChanges);
   const hasSchemaChange = authoredChanges.some(
     (change) => SCHEMA_RECORD_KINDS.has(change.recordKind)
@@ -89795,11 +89935,6 @@ function prepareServerOwnedSchemaCommit(args) {
     additionalImpactedIds: args.additionalImpactedIds,
     forceRecompile: args.forceRecompile
   });
-  const explicitlyChangedMemberIds = new Set(
-    authoredChanges.filter(
-      (change) => change.recordKind === "member" && change.operation !== "delete"
-    ).map((change) => change.recordId)
-  );
   const currentById = new Map(
     args.document.members.map((member) => [member.id, member])
   );
@@ -89858,9 +89993,12 @@ function prepareServerOwnedSchemaCommit(args) {
   const compiledById = new Map(
     sourceMembers.map((member) => [member.id, member])
   );
-  const explicitMemberIds = new Set(
-    authoredChanges.filter((change) => change.recordKind === "member").map((change) => change.recordId)
-  );
+  const explicitMemberIds = /* @__PURE__ */ new Set();
+  for (const change of authoredChanges) {
+    if (change.recordKind === "member") {
+      explicitMemberIds.add(change.recordId);
+    }
+  }
   const prepared = authoredChanges.map((change) => {
     if (change.recordKind !== "member" || change.operation === "delete") {
       return change;
@@ -89873,9 +90011,7 @@ function prepareServerOwnedSchemaCommit(args) {
     }
     return { ...change, nextData: compiled };
   });
-  const hashByKey = new Map(
-    args.contentHashHeads.filter((head) => !head.deleted).map((head) => [`${head.recordKind}:${head.recordId}`, head.contentHash])
-  );
+  const hashByKey = indexLiveContentHashesByRecordKey(args.contentHashHeads);
   for (const compiled of sourceMembers) {
     if (!recompileTargets.memberIds.has(compiled.id)) continue;
     if (explicitMemberIds.has(compiled.id)) continue;
@@ -93192,32 +93328,17 @@ function reconcileVariantConstructorArgs(args) {
   );
   const variants = postDocument.variants ?? [];
   if (variants.length === 0) return;
-  const valueById = new Map(
-    postDocument.values.map((value) => [value.id, value])
-  );
-  const classById = new Map(
-    postDocument.classes.map((schemaClass2) => [schemaClass2.id, schemaClass2])
-  );
-  const memberById = new Map(
-    postDocument.members.map((member) => [member.id, member])
-  );
-  const constructorById = new Map(
-    (postDocument.constructors ?? []).map((record3) => [record3.id, record3])
-  );
-  const changeIndexByValueId = /* @__PURE__ */ new Map();
-  args.prepared.forEach((change, index) => {
-    if (change.recordKind !== "value") return;
-    changeIndexByValueId.set(change.recordId, index);
-  });
-  const baseHashByValueId = new Map(
-    args.contentHashHeads.filter((head) => head.recordKind === "value" && !head.deleted).map((head) => [head.recordId, head.contentHash])
-  );
+  const valueById = indexRecordsById(postDocument.values);
+  const classById = indexRecordsById(postDocument.classes);
+  const memberById = indexRecordsById(postDocument.members);
+  const constructorById = indexRecordsById(postDocument.constructors ?? []);
+  const changeIndexByValueId = indexChangesByRecordId(args.prepared, "value");
+  let baseHashByValueId = null;
   for (const variant of variants) {
     const root = valueById.get(variant.valueId);
     if (root === void 0) continue;
     if (!isLiteralValueContent(root)) continue;
-    const existingArgs = root.constructorArgs;
-    if (existingArgs === void 0 || existingArgs === null) continue;
+    const existingArgs = root.constructorArgs ?? {};
     const rootClassId = root.classId;
     if (typeof rootClassId !== "string") continue;
     const schemaClass2 = classById.get(rootClassId);
@@ -93228,37 +93349,46 @@ function reconcileVariantConstructorArgs(args) {
     if (constructorRecord === void 0) continue;
     if (typeof root.value !== "object" || root.value === null) continue;
     if (Array.isArray(root.value)) continue;
-    const nextArgs = { ...existingArgs };
-    let changed = false;
-    constructorRecord.argumentTypes.forEach((argument2, index) => {
+    const nextArgs = {};
+    for (let index = 0; index < constructorRecord.argumentTypes.length; index += 1) {
+      const argument2 = constructorRecord.argumentTypes[index];
+      if (argument2 === void 0) continue;
       const parameterId = constructorActionParameterId(
         constructorRecord,
         index
       );
-      if (!(parameterId in nextArgs)) return;
-      const schemaKey = Object.keys(schemaClass2.schema).find(
-        (key) => key.toLowerCase() === argument2.name.toLowerCase()
+      const schemaKey = NEO_VARIANT_SCHEMA_KEY_BY_ARGUMENT_NAME.get(
+        argument2.name.toLowerCase()
       );
-      if (schemaKey === void 0) return;
+      if (schemaKey === void 0) continue;
       const memberId = schemaClass2.schema[schemaKey];
       const member = memberId === void 0 ? void 0 : memberById.get(memberId);
-      if (member?.kind !== 25 /* NSDelegate */) return;
+      if (member === void 0) continue;
       const childId = root.value[schemaKey];
-      if (typeof childId !== "string") return;
+      if (typeof childId !== "string") continue;
       const childRow = valueById.get(childId);
-      if (childRow === void 0 || !isLiteralValueContent(childRow)) return;
+      if (childRow === void 0 || !isLiteralValueContent(childRow)) continue;
       const rowValue = childRow.value;
-      if (typeof rowValue !== "object" || rowValue === null) return;
-      if (Array.isArray(rowValue)) return;
-      const rowCode = rowValue.code;
-      if (typeof rowCode !== "string") return;
-      const derived = { code: rowCode };
-      if (canonicalJsonStringify(nextArgs[parameterId]) === canonicalJsonStringify(derived)) {
-        return;
+      if (variantConstructorArgumentIsRestValue(schemaKey, rowValue)) {
+        continue;
       }
-      nextArgs[parameterId] = derived;
-      changed = true;
-    });
+      if (member.kind === 25 /* NSDelegate */) {
+        if (typeof rowValue !== "object" || rowValue === null) continue;
+        if (Array.isArray(rowValue)) continue;
+        const rowCode = rowValue.code;
+        if (typeof rowCode !== "string") continue;
+        nextArgs[parameterId] = { code: rowCode };
+        continue;
+      }
+      if (member.kind === 7 /* Class */ || member.kind === 22 /* Interface */ || member.kind === 21 /* Generic */ || member.kind === 6 /* List */ || member.kind === 5 /* Dictionary */) {
+        nextArgs[parameterId] = childId;
+        continue;
+      }
+      const defaultValue = argument2.defaultValue?.value;
+      if (canonicallyEqual2(rowValue, defaultValue)) continue;
+      nextArgs[parameterId] = rowValue;
+    }
+    const changed = !canonicallyEqual2(existingArgs, nextArgs);
     if (!changed) continue;
     const nextRoot = { ...root, constructorArgs: nextArgs };
     const existingIndex = changeIndexByValueId.get(root.id);
@@ -93269,8 +93399,13 @@ function reconcileVariantConstructorArgs(args) {
       }
       continue;
     }
+    baseHashByValueId ??= indexLiveContentHashesByRecordId(
+      args.contentHashHeads,
+      "value"
+    );
     const baseContentHash = baseHashByValueId.get(root.id);
     if (baseContentHash === void 0) continue;
+    changeIndexByValueId.set(root.id, args.prepared.length);
     args.prepared.push({
       recordKind: "value",
       recordId: root.id,
@@ -93283,6 +93418,13 @@ function reconcileVariantConstructorArgs(args) {
     });
   }
 }
+function variantConstructorArgumentIsRestValue(schemaKey, value) {
+  if (value === null) return true;
+  if (schemaKey === NEO_VARIANT_OVERRIDES_SCHEMA_KEY) {
+    return typeof value === "object" && value !== null && !Array.isArray(value) && Object.keys(value).length === 0;
+  }
+  return schemaKey === NEO_VARIANT_CHILD_OVERRIDES_SCHEMA_KEY && Array.isArray(value) && value.length === 0;
+}
 function appendVariantGraphCascadeDeletes(args) {
   const deletedVariantIds = /* @__PURE__ */ new Set();
   for (const change of args.prepared) {
@@ -93296,11 +93438,13 @@ function appendVariantGraphCascadeDeletes(args) {
     variants: args.document.variants ?? [],
     variantIds: deletedVariantIds
   });
-  const alreadyChanged = new Set(
-    args.prepared.filter((change) => change.recordKind === "value").map((change) => change.recordId)
-  );
-  const baseHashByValueId = new Map(
-    args.contentHashHeads.filter((head) => head.recordKind === "value").map((head) => [head.recordId, head.contentHash])
+  const alreadyChanged = /* @__PURE__ */ new Set();
+  for (const change of args.prepared) {
+    if (change.recordKind === "value") alreadyChanged.add(change.recordId);
+  }
+  const baseHashByValueId = indexLiveContentHashesByRecordId(
+    args.contentHashHeads,
+    "value"
   );
   for (const valueId of valueIds) {
     if (alreadyChanged.has(valueId)) continue;
@@ -93322,7 +93466,7 @@ function appendVariantGraphCascadeDeletes(args) {
     });
   }
 }
-var SERVER_COMPILATION_PROJECT_CACHE_LIMIT, serverCompilationProjectCache, READ_ONLY_SOURCE_CONVERSION_INTENT_SOURCE, SCHEMA_RECORD_KINDS, DIALOGUE_SOURCE_RECORD_KINDS;
+var SERVER_COMPILATION_PROJECT_CACHE_LIMIT, serverCompilationProjectCache, READ_ONLY_SOURCE_CONVERSION_INTENT_SOURCE, SCHEMA_RECORD_KINDS, DIALOGUE_SOURCE_RECORD_KINDS, NEO_VARIANT_SCHEMA_KEY_BY_ARGUMENT_NAME;
 var init_project_version_schema_commit = __esm({
   "../src/database/project-version-schema-commit.ts"() {
     "use strict";
@@ -93335,6 +93479,7 @@ var init_project_version_schema_commit = __esm({
     init_project2();
     init_member_access_modifier_validation();
     init_variant_value_graph();
+    init_variants2();
     init_localization2();
     init_internal_record_relations();
     init_project_content_hash();
@@ -93376,6 +93521,12 @@ var init_project_version_schema_commit = __esm({
       "dialogue-node",
       "dialogue-group"
     ]);
+    NEO_VARIANT_SCHEMA_KEY_BY_ARGUMENT_NAME = /* @__PURE__ */ new Map([
+      ["initialize", NEO_VARIANT_INITIALIZE_SCHEMA_KEY],
+      ["apply", NEO_VARIANT_APPLY_SCHEMA_KEY],
+      ["overrides", NEO_VARIANT_OVERRIDES_SCHEMA_KEY],
+      ["childoverrides", NEO_VARIANT_CHILD_OVERRIDES_SCHEMA_KEY]
+    ]);
   }
 });
 
@@ -96308,15 +96459,6 @@ function recordsSemanticallyEqual(recordKind, left, right) {
   }
   return canonicallyEqual(left, right);
 }
-function valueRecordComparisonBody(value) {
-  if (!isObjectRecord2(value)) return value;
-  const init = value.init;
-  const body = value.value;
-  const normalizedInit = isObjectRecord2(init) && init.compiled !== void 0 ? { ...init, compiled: void 0 } : init;
-  const normalizedBody = isObjectRecord2(body) && typeof body.code === "string" && body.action !== void 0 ? { ...body, action: void 0 } : body;
-  if (normalizedInit === init && normalizedBody === body) return value;
-  return { ...value, init: normalizedInit, value: normalizedBody };
-}
 function describeChange(change) {
   const name = isObjectRecord2(change.nextData) && typeof change.nextData.name === "string" ? change.nextData.name : isObjectRecord2(change.baseData) && typeof change.baseData.name === "string" ? change.baseData.name : change.recordId;
   const location3 = change.file === null ? "" : ` (${change.file})`;
@@ -96347,6 +96489,7 @@ var init_workspace_status_core = __esm({
     init_source_diagnostics();
     init_migration_files();
     init_projection();
+    init_value_record_comparison();
     init_project_manifest();
     init_src();
     init_lower_schema();
@@ -97817,15 +97960,15 @@ function emitVariantValueSourcesV4(records2, manifest) {
         visited
       });
     };
-    const initialize = argument2("Initialize");
+    const initialize = argument2(NEO_VARIANT_INITIALIZE_SCHEMA_KEY);
     if (initialize === null) {
       throw new Error(
         `Variant "${variant.id}" has no Initialize row; every variant constructs a fresh instance.`
       );
     }
-    const apply = argument2("Apply");
-    const overrides = argument2("Overrides");
-    const childOverrides = argument2("ChildOverrides");
+    const apply = argument2(NEO_VARIANT_APPLY_SCHEMA_KEY);
+    const overrides = argument2(NEO_VARIANT_OVERRIDES_SCHEMA_KEY);
+    const childOverrides = argument2(NEO_VARIANT_CHILD_OVERRIDES_SCHEMA_KEY);
     const authored = [["initialize", initialize]];
     if (apply !== null && apply !== "null") authored.push(["apply", apply]);
     if (overrides !== null && overrides !== "new {}") {
@@ -102878,6 +103021,12 @@ function storedConstructorCallSource(context, schemaClass2, value, className, en
         `Stored construction for ${className} is missing evaluated argument ${key}.`
       );
     }
+    const settledMember = settledMemberForConstructorArgument(
+      context,
+      schemaClass2,
+      value,
+      constructorArgs[key]
+    );
     return `${argument2.name}: ${storedConstructorArgumentSource(
       context,
       argument2.type,
@@ -102885,24 +103034,23 @@ function storedConstructorCallSource(context, schemaClass2, value, className, en
       environment,
       visited,
       cloneAggregateArguments,
-      settledMemberIsPartial(context, schemaClass2, value, constructorArgs[key])
+      settledMember?.partial === true,
+      settledMember !== void 0
     )}`;
   });
   return argumentsValue.length === 0 && targetTyped ? "new()" : constructorCallSource(`new ${className}`, argumentsValue);
 }
-function settledMemberIsPartial(context, schemaClass2, value, argument2) {
-  if (typeof argument2 !== "string") return false;
+function settledMemberForConstructorArgument(context, schemaClass2, value, argument2) {
+  if (typeof argument2 !== "string") return void 0;
   const body = value.value;
-  if (!isObjectRecord2(body)) return false;
+  if (!isObjectRecord2(body)) return void 0;
   const schemaKey = Object.entries(body).find(
     ([, rowId]) => rowId === argument2
   )?.[0];
-  if (schemaKey === void 0) return false;
+  if (schemaKey === void 0) return void 0;
   const schema = isObjectRecord2(schemaClass2.schema) ? schemaClass2.schema : {};
   const memberId = schema[schemaKey];
-  if (typeof memberId !== "string") return false;
-  const member = context.members.get(memberId);
-  return member?.partial === true;
+  return typeof memberId === "string" ? context.members.get(memberId) : void 0;
 }
 function constructorCallSource(callee, argumentsValue) {
   const inline = `${callee}(${argumentsValue.join(", ")})`;
@@ -102941,7 +103089,7 @@ function storedValueConstructor(context, schemaClass2, constructorArgs) {
   }
   return selected;
 }
-function storedConstructorArgumentSource(context, type, value, environment, visited, cloneAggregateArguments = false, partial = false) {
+function storedConstructorArgumentSource(context, type, value, environment, visited, cloneAggregateArguments = false, partial = false, constructorOwnsGraph = false) {
   if (value === null) {
     if (!type.nullable) {
       throw new Error("Required constructor argument stores null.");
@@ -103024,7 +103172,8 @@ function storedConstructorArgumentSource(context, type, value, environment, visi
         environment,
         visited,
         false,
-        partial
+        partial,
+        constructorOwnsGraph
       );
     }
     case "generic": {
@@ -103048,7 +103197,8 @@ function storedConstructorArgumentSource(context, type, value, environment, visi
         environment,
         visited,
         cloneAggregateArguments,
-        partial
+        partial,
+        constructorOwnsGraph
       );
     }
     case "interface":
@@ -103068,7 +103218,9 @@ function storedConstructorArgumentSource(context, type, value, environment, visi
         value,
         environment,
         visited,
-        false
+        false,
+        false,
+        constructorOwnsGraph
       );
     case "lookup":
       return referenceValue(
@@ -103342,7 +103494,7 @@ function storedSchemaTypeName(context, type, environment, valueId) {
       return "null";
   }
 }
-function storedTypedRowSource(context, type, valueId, environment, visited, writeIdentity, partial = false) {
+function storedTypedRowSource(context, type, valueId, environment, visited, writeIdentity, partial = false, constructorOwnsGraph = false) {
   const symbol = context.symbolsByValueId.get(valueId);
   if (symbol !== void 0) return symbol;
   const row = context.values.get(valueId);
@@ -103351,6 +103503,9 @@ function storedTypedRowSource(context, type, valueId, environment, visited, writ
       `Stored ${type.kind} constructor argument references missing value row ${valueId}.`
     );
   }
+  if (!constructorOwnsGraph && context.readMaterializedGraph().independentlyOwnedValueIds.has(valueId)) {
+    return `Reference<${storedSchemaTypeName(context, type, environment, valueId)}>(id: ${quote5(valueId)})`;
+  }
   if (visited.has(valueId)) {
     throw new Error(
       `Stored constructor argument containment cycle reaches ${valueId}.`
@@ -103401,7 +103556,9 @@ ${ids.map(
             id2,
             environment,
             visited,
-            true
+            true,
+            false,
+            constructorOwnsGraph
           ),
           2
         )
@@ -103429,7 +103586,9 @@ ${entries.flatMap(
               id2,
               environment,
               visited,
-              false
+              false,
+              false,
+              constructorOwnsGraph
             )}`,
             2
           )
@@ -104192,6 +104351,7 @@ var init_value_sources = __esm({
     "use strict";
     init_src();
     init_projection();
+    init_variants2();
     init_project_file_source();
     init_lower_members();
     init_lower_variants();
@@ -105997,6 +106157,104 @@ var init_conflict_markers = __esm({
   }
 });
 
+// src/project-sync/source-record-comparison.ts
+function sourceAuthoredRecordsSemanticallyEqual(recordKind, left, right, mainLocale) {
+  if (isSchemaRecordKindV4(recordKind)) {
+    return schemaDocumentAuthoredSemanticallyEqual(recordKind, left, right);
+  }
+  return canonicallyEqual(
+    sourceComparableRecord(recordKind, left, mainLocale),
+    sourceComparableRecord(recordKind, right, mainLocale)
+  );
+}
+function sourceComparableObjectRecord(recordKind, value, mainLocale) {
+  const comparable = sourceComparableRecord(recordKind, value, mainLocale);
+  if (!isObjectRecord2(comparable)) {
+    throw new Error(
+      `Cannot merge ${recordKind} record because its source-comparable payload is not an object.`
+    );
+  }
+  return comparable;
+}
+function workspaceMainLocale(records2) {
+  const config = Object.values(records2).find(
+    (record3) => record3.recordKind === "localization-config"
+  );
+  const data = config?.data;
+  return isObjectRecord2(data) && typeof data.mainLocale === "string" ? data.mainLocale : "en-US";
+}
+function acceptSourceEquivalentConflictBases(workspace, mainLocale = workspaceMainLocale(workspace.state.records)) {
+  let accepted = 0;
+  for (const [key, record3] of Object.entries(workspace.state.records)) {
+    if (typeof record3.conflictServerHash !== "string") continue;
+    if (!sourceAuthoredRecordsSemanticallyEqual(
+      record3.recordKind,
+      record3.data,
+      record3.conflictServerData,
+      mainLocale
+    )) {
+      continue;
+    }
+    const next = {
+      ...record3,
+      contentHash: record3.conflictServerHash,
+      data: record3.conflictServerData
+    };
+    delete next.conflictServerHash;
+    delete next.conflictServerData;
+    workspace.state.records[key] = next;
+    accepted += 1;
+  }
+  return accepted;
+}
+function sourceComparableRecord(recordKind, value, mainLocale) {
+  return sourceComparableValue(
+    recordKind,
+    recordKind === "value" ? valueRecordComparisonBody(value) : value,
+    mainLocale
+  );
+}
+function sourceComparableValue(recordKind, value, mainLocale) {
+  if (Array.isArray(value)) {
+    return value.map(
+      (entry) => sourceComparableValue(recordKind, entry, mainLocale)
+    );
+  }
+  if (!isObjectRecord2(value)) return value;
+  const result = {};
+  const hasAuthoredCode = typeof value.code === "string" || typeof value.setterCode === "string";
+  for (const [key, entry] of Object.entries(value)) {
+    if (key === "projectId" || key === "createdAt" || key === "updatedAt") {
+      continue;
+    }
+    if (recordKind === "dialogue-node" && key === "layout") continue;
+    if (hasAuthoredCode && (key === "getter" || key === "setter" || key === "action")) {
+      continue;
+    }
+    if (recordKind === "localized-text" && key === "localeValues" && isObjectRecord2(entry)) {
+      result[key] = Object.hasOwn(entry, mainLocale) ? {
+        [mainLocale]: sourceComparableValue(
+          recordKind,
+          entry[mainLocale],
+          mainLocale
+        )
+      } : {};
+      continue;
+    }
+    result[key] = sourceComparableValue(recordKind, entry, mainLocale);
+  }
+  return result;
+}
+var init_source_record_comparison = __esm({
+  "src/project-sync/source-record-comparison.ts"() {
+    "use strict";
+    init_project_manifest();
+    init_project_documents();
+    init_projection();
+    init_value_record_comparison();
+  }
+});
+
 // src/project-source/reset.ts
 import {
   existsSync as existsSync5,
@@ -107162,77 +107420,6 @@ function projectSourcePathsRequiringRewriteV4(args) {
   }
   return result;
 }
-function sourceAuthoredRecordsSemanticallyEqual(recordKind, left, right, mainLocale) {
-  if (isSchemaRecordKindV4(recordKind)) {
-    return schemaDocumentAuthoredSemanticallyEqual(recordKind, left, right);
-  }
-  return canonicallyEqual(
-    sourceComparableRecord(recordKind, left, mainLocale),
-    sourceComparableRecord(recordKind, right, mainLocale)
-  );
-}
-function sourceComparableRecord(recordKind, value, mainLocale) {
-  if (Array.isArray(value)) {
-    return value.map(
-      (entry) => sourceComparableRecord(recordKind, entry, mainLocale)
-    );
-  }
-  if (!isObjectRecord2(value)) return value;
-  const result = {};
-  const hasAuthoredCode = typeof value.code === "string" || typeof value.setterCode === "string";
-  for (const [key, entry] of Object.entries(value)) {
-    if (key === "projectId" || key === "createdAt" || key === "updatedAt") {
-      continue;
-    }
-    if (recordKind === "dialogue-node" && key === "layout") continue;
-    if (hasAuthoredCode && (key === "getter" || key === "setter" || key === "action")) {
-      continue;
-    }
-    if (recordKind === "localized-text" && key === "localeValues" && isObjectRecord2(entry)) {
-      result[key] = Object.hasOwn(entry, mainLocale) ? {
-        [mainLocale]: sourceComparableRecord(
-          recordKind,
-          entry[mainLocale],
-          mainLocale
-        )
-      } : {};
-      continue;
-    }
-    result[key] = sourceComparableRecord(recordKind, entry, mainLocale);
-  }
-  return result;
-}
-function acceptSourceEquivalentConflictBases(workspace, mainLocale) {
-  let accepted = 0;
-  for (const [key, record3] of Object.entries(workspace.state.records)) {
-    if (typeof record3.conflictServerHash !== "string") continue;
-    if (!sourceAuthoredRecordsSemanticallyEqual(
-      record3.recordKind,
-      record3.data,
-      record3.conflictServerData,
-      mainLocale
-    )) {
-      continue;
-    }
-    const next = {
-      ...record3,
-      contentHash: record3.conflictServerHash,
-      data: record3.conflictServerData
-    };
-    delete next.conflictServerHash;
-    delete next.conflictServerData;
-    workspace.state.records[key] = next;
-    accepted += 1;
-  }
-  return accepted;
-}
-function workspaceMainLocale(records2) {
-  const config = Object.values(records2).find(
-    (record3) => record3.recordKind === "localization-config"
-  );
-  const data = config?.data;
-  return isObjectRecord2(data) && typeof data.mainLocale === "string" ? data.mainLocale : "en-US";
-}
 function mergeProjectDocumentRecord(recordKind, base, server, local, mainLocale) {
   if (isSchemaRecordKindV4(recordKind)) {
     return mergeSchemaDocumentRecord(recordKind, base, server, local);
@@ -107246,15 +107433,6 @@ function mergeProjectDocumentRecord(recordKind, base, server, local, mainLocale)
     }
   });
 }
-function sourceComparableObjectRecord(recordKind, value, mainLocale) {
-  const comparable = sourceComparableRecord(recordKind, value, mainLocale);
-  if (!isObjectRecord2(comparable)) {
-    throw new Error(
-      `Cannot merge ${recordKind} record because its source-comparable payload is not an object.`
-    );
-  }
-  return comparable;
-}
 function buildEmitRecordSet(document, plans, side) {
   const records2 = /* @__PURE__ */ new Map();
   for (const [key, plan] of plans) {
@@ -107313,6 +107491,7 @@ var init_pull = __esm({
     init_conflict_markers();
     init_merge();
     init_projection();
+    init_source_record_comparison();
     init_reset();
     init_project_documents();
     init_project_document_cache();
@@ -114157,7 +114336,7 @@ var init_registry2 = __esm({
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
       formatVersion: 3,
       contractVersion: "3.14",
-      cliVersion: "0.36.7",
+      cliVersion: "0.36.9",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -120473,6 +120652,7 @@ __export(resolve_exports, {
 import { readFileSync as readFileSync19, rmSync as rmSync8, writeFileSync as writeFileSync14 } from "node:fs";
 import { join as join21 } from "node:path";
 function runResolve(workspace, side) {
+  const resolvedRecords = acceptSourceEquivalentConflictBases(workspace);
   let resolvedFiles = 0;
   for (const filePath of listProjectSourceFilesV4(workspace.root)) {
     const source = readFileSync19(filePath, "utf8");
@@ -120506,15 +120686,15 @@ function runResolve(workspace, side) {
     delete binary.conflict;
     resolvedBinaries += 1;
   }
-  if (resolvedBinaries > 0) {
+  if (resolvedRecords > 0 || resolvedBinaries > 0) {
     writeWorkspaceState(workspace.root, workspace.state);
   }
-  if (resolvedFiles === 0 && resolvedBinaries === 0) {
-    console.log("No conflict markers found.");
+  if (resolvedFiles === 0 && resolvedRecords === 0 && resolvedBinaries === 0) {
+    console.log("No conflicts found.");
     return;
   }
   console.log(
-    `Resolved ${resolvedFiles} source file(s) and ${resolvedBinaries} binary file(s) keeping the "${side}" side. Review with "neo diff", then "neo push".`
+    `Resolved ${resolvedFiles} source file(s), ${resolvedRecords} record conflict(s), and ${resolvedBinaries} binary file(s) keeping the "${side}" side. Review with "neo diff", then "neo push".`
   );
 }
 function resolveMarkers(source, side) {
@@ -120563,6 +120743,7 @@ var init_resolve = __esm({
     init_workspace_status();
     init_source_diagnostics();
     init_project_files();
+    init_source_record_comparison();
   }
 });
 
@@ -120759,7 +120940,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.36.7");
+    console.log("0.36.9");
     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.36.7",
+  "version": "0.36.9",
   "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.36.7 -->
+<!-- reviewed-through-cli: 0.36.9 -->
 
 # Neo Compose CLI
 
@@ -210,6 +210,11 @@ Conflict source deliberately fails compilation. Edit the desired final source,
 or use `neo resolve --mine|--theirs` as a whole-side convenience. Then pull,
 review, dry-run, and push again.
 
+Server-derived compilation metadata is not authored source and does not create
+a pull conflict by itself. If an older CLI retained such a metadata-only
+conflict without writing source markers, either `neo resolve` side accepts the
+newer server metadata as the base while preserving any real local source edit.
+
 `neo push` sends the authenticated semantic diff plus a deterministic source
 hash, while the server recompiles the changed NeoScript bodies and
 schema-affected callers and commits only that diff under CAS. Use

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

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

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

@@ -79,6 +79,11 @@ Resolve source conflicts by editing the final intended source. Use
 `neo resolve --mine` or `neo resolve --theirs` only for a deliberate whole-side
 choice. Pull, inspect, dry-run, and retry; there is no force-CAS path.
 
+Compiled initializer IR is server-owned and does not participate in authored
+three-way merge decisions. `neo resolve` also repairs metadata-only conflict
+bookkeeping left by an older pull when no source marker exists; accepting the
+newer server metadata does not overwrite the tracked source.
+
 For `base-hash-conflict`, pull and merge. For `version-bump-required`, inspect
 the classification and use `neo push --accept-bump` only when the bump is
 intended.