@neocompose/cli 0.50.2 → 0.50.4

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## [0.50.4] - 2026-09-14
+
+- Resolve inherited lookup metadata when reading sparse member overrides in NeoScript. Single-select lookups return their referenced values for comparisons and member access; multi-select lookups remain collections.
+
+## [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.

package/dist/neo.mjs

@@ -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;
       }
@@ -76010,12 +76013,13 @@ function resolveRuntimeSchemaMember(receiver, schemaKey, ctx) {
   if (!runtimeClassId) return null;
   const memberId = cachedMergedSchemaMemberId(runtimeClassId, schemaKey, ctx);
   if (memberId === null) return null;
-  const member = evalMemberById(ctx.vm, memberId);
-  if (member === null) return null;
+  const rawMember = evalMemberById(ctx.vm, memberId);
+  if (rawMember === null) return null;
+  const member = cachedResolvedMember(rawMember, ctx);
   if (member.kind !== 21 /* Generic */) return member;
   const env = runtimeGenericEnvForValueRow(row, ctx, /* @__PURE__ */ new Set());
   try {
-    return substituteMember(member, env, ctx.vm.members);
+    return substituteMember(member, env, ctx.vm.members, member);
   } catch (error) {
     throw new NSGetterRuntimeError(
       `Cannot resolve runtime member '${member.name}' for Class '${runtimeClassId}': ${error instanceof Error ? error.message : String(error)}`
@@ -81273,10 +81277,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 +81312,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 +81755,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 +82040,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 +82106,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 +83643,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 +83658,7 @@ function createHeadlessVirtualInstanceResolver(args) {
         document: resolverDocument,
         materializedRows: document.values
       });
-      const expanded = expandStoredInstance({
+      const expanded = expandStoredClassValue({
         evaluateInitializer: args.evaluateInitializer,
         document: resolverDocument,
         instanceRoot,
@@ -83622,7 +83700,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 +84110,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 +101860,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 +101987,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 +130959,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 +132479,7 @@ var init_registry2 = __esm({
   "schema-contract/registry.mjs"() {
     "use strict";
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
-      cliVersion: "0.50.2",
+      cliVersion: "0.50.4",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -139568,7 +139695,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.2");
+    console.log("0.50.4");
     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.2",
+  "version": "0.50.4",
   "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.2 -->
+<!-- reviewed-through-cli: 0.50.4 -->
 
 # 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.2 -->
+<!-- reviewed-through-cli: 0.50.4 -->
 ```
 
 The quoted version above is checked too, so this instruction cannot go stale

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