@neocompose/cli 0.36.8 → 0.36.9

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # 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

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();
@@ -89764,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);
@@ -89784,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)
@@ -89812,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])
   );
@@ -89875,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;
@@ -89890,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;
@@ -93209,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);
@@ -93245,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);
@@ -93286,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,
@@ -93300,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) {
@@ -93313,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;
@@ -93339,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";
@@ -93352,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();
@@ -93393,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]
+    ]);
   }
 });
 
@@ -97826,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 {}") {
@@ -102887,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,
@@ -102894,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(", ")})`;
@@ -102950,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.");
@@ -103033,7 +103172,8 @@ function storedConstructorArgumentSource(context, type, value, environment, visi
         environment,
         visited,
         false,
-        partial
+        partial,
+        constructorOwnsGraph
       );
     }
     case "generic": {
@@ -103057,7 +103197,8 @@ function storedConstructorArgumentSource(context, type, value, environment, visi
         environment,
         visited,
         cloneAggregateArguments,
-        partial
+        partial,
+        constructorOwnsGraph
       );
     }
     case "interface":
@@ -103077,7 +103218,9 @@ function storedConstructorArgumentSource(context, type, value, environment, visi
         value,
         environment,
         visited,
-        false
+        false,
+        false,
+        constructorOwnsGraph
       );
     case "lookup":
       return referenceValue(
@@ -103351,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);
@@ -103360,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}.`
@@ -103410,7 +103556,9 @@ ${ids.map(
             id2,
             environment,
             visited,
-            true
+            true,
+            false,
+            constructorOwnsGraph
           ),
           2
         )
@@ -103438,7 +103586,9 @@ ${entries.flatMap(
               id2,
               environment,
               visited,
-              false
+              false,
+              false,
+              constructorOwnsGraph
             )}`,
             2
           )
@@ -104201,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();
@@ -114185,7 +114336,7 @@ var init_registry2 = __esm({
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
       formatVersion: 3,
       contractVersion: "3.14",
-      cliVersion: "0.36.8",
+      cliVersion: "0.36.9",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -120789,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.8");
+    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.8",
+  "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.8 -->
+<!-- reviewed-through-cli: 0.36.9 -->
 
 # Neo Compose CLI
 

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.8 -->
+<!-- reviewed-through-cli: 0.36.9 -->
 ```
 
 The quoted version above is checked too, so this instruction cannot go stale