@neocompose/cli 0.48.1 → 0.48.3

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [0.48.3] - 2026-09-10
+
+- Show inherited generic binding defaults in implicit constructions, so sparse
+  instances expose their effective values and no longer warn about unsettled
+  required members. Matching defaults remain virtual through pull/status and
+  edits create ordinary sparse overrides. Recorded constructors keep their
+  own settlement behavior.
+- Preserve hidden collection argument defaults and ordering when lowering
+  unchanged generic types.
+
+## [0.48.2] - 2026-09-10
+
+- Emit class member defaults with contextual `new()` when they construct the declared type, while keeping an explicit concrete type for subclass defaults.
+
 ## [0.48.1] - 2026-09-10
 
 - Emit empty class member defaults as `new Type()` even when their backing value row is virtual. Required members now read as initialized, and adding a `new() { ... }` override preserves sparse storage.

package/dist/neo.mjs

@@ -64603,6 +64603,22 @@ function manifestTypeForMember(context, member) {
     }
     return primitive3;
   }
+  if (member.kind === "list" || member.kind === "dictionary") {
+    const entry = context.baseMembers.get(member.entryMemberId);
+    if (entry === void 0)
+      throw new Error(
+        `Collection ${member.name} has no entry member ${member.entryMemberId}.`
+      );
+    const entryType = manifestTypeForMember(context, entry);
+    if (member.kind === "list")
+      return { name: "List", nullable: nullable2, arguments: [entryType] };
+    const keyType = {
+      name: member.key.kind === "string" ? "string" : context.baseEnums.get(member.key.enumId)?.name ?? "object",
+      nullable: false,
+      arguments: []
+    };
+    return { name: "Dictionary", nullable: nullable2, arguments: [keyType, entryType] };
+  }
   if (member.kind === "class") {
     const schemaClass2 = context.baseClasses.get(member.classId);
     const classType = {
@@ -64848,6 +64864,16 @@ function lowerGenericArgument(context, ownerClass, type, memberId, genericParamI
   const base = context.baseMembers.get(memberId);
   if (base && JSON.stringify(manifestTypeForMember(context, base)) === JSON.stringify(type)) {
     context.loweredMembers.set(memberId, { ...base, owner });
+    if (base.kind === "list" || base.kind === "dictionary") {
+      lowerCollectionEntry(
+        context,
+        ownerClass,
+        requiredTypeArgument(type, base.kind === "list" ? 0 : 1),
+        base.entryMemberId,
+        memberId,
+        memberId
+      );
+    }
     return;
   }
   const declaration = {
@@ -113263,6 +113289,7 @@ function buildValueEmitContext(records2, manifest) {
     },
     members,
     classes,
+    implicitGenericMembersByClassId: /* @__PURE__ */ new Map(),
     manifestMembers,
     manifestClasses: new Map(
       manifest.classes.map((schemaClass2) => [schemaClass2.id, schemaClass2])
@@ -113680,9 +113707,7 @@ function emitMemberDefaultSourcesV4(records2, manifest) {
         member,
         { classId: defaultValue.classId ?? null, value: backed.body },
         visited,
-        (defaultValue.classId ?? member.classId) === member.classId && manifestMember?.kind === "class" && Object.values(manifestMember.classArguments).some(
-          (argument2) => argument2.kind === "generic"
-        ),
+        (defaultValue.classId ?? member.classId) === member.classId && manifestMember?.kind === "class",
         environment
       );
     } else if (backed.kind === "list") {
@@ -116499,18 +116524,32 @@ function lowerClassValue(context, member, expression, base, source, outerEnviron
           `Class value ${String(base.id)}.${assignment.name} cannot place existing value ${symbolId2} into a new structural slot. Create the nested value inline so the atomic construction transaction can own it.`
         );
       }
-      body[assignment.name] = lowerSeedChild(
+      const rows = /* @__PURE__ */ new Map();
+      const localizedTexts = /* @__PURE__ */ new Map();
+      const seededId = lowerSeedChild(
         context,
         recursivePartialMember(member, childMember),
         assignment.value,
         source,
         `${String(base.id)}.${assignment.name}`,
-        /* @__PURE__ */ new Map(),
-        /* @__PURE__ */ new Map(),
+        rows,
+        localizedTexts,
         void 0,
         environment,
         assignmentSlices.get(assignment.name)
       );
+      if (!partial && freshChildReplaysDeclaredDefault({
+        context,
+        childMember,
+        childId: seededId,
+        rows,
+        localizedTexts,
+        environment
+      })) {
+        deleteSeedRow(context, rows, seededId);
+        continue;
+      }
+      body[assignment.name] = seededId;
       continue;
     }
     const symbolId = sourceValueSymbol(context, assignment.value);
@@ -118311,23 +118350,33 @@ function freshChildReplaysDeclaredDefault(args) {
   if (child.instanceVariantId != null) return false;
   if (child.instanceVariantRowValueId != null) return false;
   if (context.collectionBindingMemberIds.has(childMember.id)) return false;
-  const defaultValue = childMember.defaultValue;
-  if (defaultValue === null || defaultValue === void 0) return false;
-  if (!("value" in defaultValue)) return false;
   const resolved = resolveGenericSchemaMember(
     context,
     childMember,
     environment
   );
+  let defaultValue = null;
+  if (resolved.defaultValue && "value" in resolved.defaultValue) {
+    defaultValue = resolved.defaultValue;
+  } else if (resolved.defaultValue && "serverValueId" in resolved.defaultValue) {
+    const storedMember = context.state[`member:${resolved.id}`]?.data;
+    const storedDefault = isObjectRecord2(storedMember) ? storedMember.defaultValue : null;
+    if (isObjectRecord2(storedDefault) && "value" in storedDefault) {
+      defaultValue = {
+        value: storedDefault.value,
+        classId: storedDefault.classId
+      };
+    }
+  }
+  if (defaultValue === null) return false;
   if (resolved.kind === "lookup" || resolved.kind === "dialogueLookup") {
     return false;
   }
   if (resolved.kind === "class") {
-    return freshConstructionReplaysDeclaredDefault(
-      resolved,
-      child,
-      defaultValue
-    );
+    return freshConstructionReplaysDeclaredDefault(resolved, child, {
+      value: defaultValue.value,
+      classId: defaultValue.classId
+    });
   }
   if (resolved.kind === "list") {
     return Array.isArray(child.value) && child.value.length === 0 && !context.pendingContainerChildCounts.has(childId) && Array.isArray(defaultValue.value) && defaultValue.value.length === 0 && child.classId == null && (child.constructorArgs == null || Object.keys(child.constructorArgs).length === 0) && child.instanceConstructorId == null;
@@ -118905,6 +118954,41 @@ function classValue(context, member, value, visited, targetTyped, outerEnvironme
     );
     overrideKeys.add(key);
   }
+  if (!partial && value.instanceVariantId == null && value.instanceVariantRowValueId == null) {
+    for (const [key, genericMember] of implicitGenericMembers(
+      context,
+      classId
+    )) {
+      if (key in value.value) continue;
+      const parameterId = stringField3(genericMember, "genericParamId");
+      if (!environment.has(parameterId)) continue;
+      const binding = resolveGenericValueMember(
+        context,
+        genericMember,
+        environment
+      );
+      const kind = numberField(binding, "kind");
+      if (!IMPLICIT_GENERIC_DEFAULT_KINDS.has(kind)) continue;
+      if (kind === 3 /* String */ && isLocalizedStringMember(binding))
+        continue;
+      if (binding.payload === 1 /* Partial */) continue;
+      const defaultValue = binding.defaultValue;
+      if (!isObjectRecord2(defaultValue) || !("value" in defaultValue)) continue;
+      const body = defaultValue.value;
+      if (body === null) continue;
+      if (Array.isArray(body) && body.length > 0) continue;
+      if (isObjectRecord2(body) && Object.keys(body).length > 0) continue;
+      const expression = emitValueBody(
+        context,
+        binding,
+        defaultValue,
+        /* @__PURE__ */ new Set(),
+        (defaultValue.classId ?? binding.classId) === binding.classId,
+        environment
+      );
+      fields.push(`${key} = ${expression}`);
+    }
+  }
   if (partial) {
     return fields.length === 0 ? "new { }" : `new {
 ${fields.map((field) => indentNeoSourceNonEmptyLines(field, 2)).join(",\n")}
@@ -118923,6 +119007,33 @@ ${fields.map((field) => indentNeoSourceNonEmptyLines(field, 2)).join(",\n")}
 ${fields.map((field) => indentNeoSourceNonEmptyLines(field, 2)).join(",\n")}
 }`;
 }
+function implicitGenericMembers(context, classId) {
+  const cached = context.implicitGenericMembersByClassId.get(classId);
+  if (cached !== void 0) return cached;
+  const result = /* @__PURE__ */ new Map();
+  const seenKeys = /* @__PURE__ */ new Set();
+  const seenClasses = /* @__PURE__ */ new Set();
+  let current = context.manifestClasses.get(classId);
+  while (current !== void 0 && !seenClasses.has(current.id)) {
+    seenClasses.add(current.id);
+    if (current.requiredConstructorId || current.constructorIds?.length) {
+      result.clear();
+      context.implicitGenericMembersByClassId.set(classId, result);
+      return result;
+    }
+    for (const [key, memberId] of Object.entries(current.schema)) {
+      if (seenKeys.has(key)) continue;
+      seenKeys.add(key);
+      const member = context.members.get(memberId);
+      if (member?.kind === 21 /* Generic */ && !isObjectRecord2(member.init)) {
+        result.set(key, member);
+      }
+    }
+    current = current.extendsClassId === null ? void 0 : context.manifestClasses.get(current.extendsClassId);
+  }
+  context.implicitGenericMembersByClassId.set(classId, result);
+  return result;
+}
 function emitsAsMemberDefaultDerivedAbsence(context, member, valueId) {
   const value = context.values.get(valueId);
   if (value === void 0) return false;
@@ -120458,7 +120569,7 @@ function memberDefaultBody(member) {
   if (!("value" in defaultValue)) return null;
   return defaultValue.value;
 }
-var INFERRED_GENERIC_CLASS_PREFIX, MEMBER_KIND_DICTIONARY2, MEMBER_KIND_LIST2, MEMBER_KIND_CLASS2, LEADING_AUTHORED_ROW_ID, CANONICAL_CONSTRUCTOR_INLINE_WIDTH;
+var INFERRED_GENERIC_CLASS_PREFIX, MEMBER_KIND_DICTIONARY2, MEMBER_KIND_LIST2, MEMBER_KIND_CLASS2, IMPLICIT_GENERIC_DEFAULT_KINDS, LEADING_AUTHORED_ROW_ID, CANONICAL_CONSTRUCTOR_INLINE_WIDTH;
 var init_value_sources = __esm({
   "src/project-source/value-sources.ts"() {
     "use strict";
@@ -120498,6 +120609,16 @@ var init_value_sources = __esm({
     MEMBER_KIND_DICTIONARY2 = 5;
     MEMBER_KIND_LIST2 = 6;
     MEMBER_KIND_CLASS2 = 7;
+    IMPLICIT_GENERIC_DEFAULT_KINDS = /* @__PURE__ */ new Set([
+      1 /* Bool */,
+      2 /* Int */,
+      4 /* Float */,
+      20 /* Decimal */,
+      3 /* String */,
+      7 /* Class */,
+      6 /* List */,
+      5 /* Dictionary */
+    ]);
     LEADING_AUTHORED_ROW_ID = /^@id\(\s*"((?:[^"\\]|\\.)*)"\s*\)/;
     CANONICAL_CONSTRUCTOR_INLINE_WIDTH = 88;
   }
@@ -131456,7 +131577,7 @@ var init_registry2 = __esm({
   "schema-contract/registry.mjs"() {
     "use strict";
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
-      cliVersion: "0.48.1",
+      cliVersion: "0.48.3",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -138506,7 +138627,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.48.1");
+    console.log("0.48.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.48.1",
+  "version": "0.48.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.48.1 -->
+<!-- reviewed-through-cli: 0.48.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.48.1 -->
+<!-- reviewed-through-cli: 0.48.3 -->
 ```
 
 The quoted version above is checked too, so this instruction cannot go stale

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

@@ -121,12 +121,14 @@ membership rules as member defaults.
 
 ## Defaults and localization
 
-A class member with an empty construction default emits `= new Type()` even
-when its value row is virtual. Edit that declaration with `new() { ... }` to
-change the shared default, or assign the member inside an instance initializer
-to override only that instance. Leaving the emitted construction unchanged
-creates no redundant value rows. A nullable member with no default remains bare;
-an explicit null default emits `= null`.
+A class member whose default constructs its declared type emits a contextual
+`= new()`, including populated defaults and defaults whose value row is
+virtual. A default that constructs a subclass keeps the concrete type, such as
+`Base Value = new Derived();`. Edit the declaration to change the shared
+default, or assign the member inside an instance initializer to override only
+that instance. Leaving the emitted construction unchanged creates no redundant
+value rows. A nullable member with no default remains bare; an explicit null
+default emits `= null`.
 
 Omitted members are virtual projections of the instance's recorded constructor
 or variant. Later edits to that source update every omitted member. Writing a
@@ -134,6 +136,12 @@ 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 concrete generic argument can carry a default that its type spelling does
+not show. Pull writes nonlocalized scalar and empty aggregate binding defaults at implicit
+construction sites, for example `DefaultData = new()`. Keeping that expression
+unchanged or omitting it retains the virtual default; editing it creates an
+override. A default that selects a subtype keeps the explicit subtype name.
+
 Editing an initializer updates sparse override rows in place: projected member
 IDs remain stable, and omitted virtual rows are never emitted as authored seed
 records. Spelling a declared default verbatim in a new initializer lowers to