@neocompose/cli 0.76.0 → 0.76.1

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## 0.76.1
+
+### Patch Changes
+
+- 80ea491: Instances share a member's declared value whenever it cannot change: the
+  member is `readonly` or Immutable, its declaration reads neither `this` nor a
+  constructor argument, and nothing in the value is writable. A readonly literal
+  is shared under any storage. A readonly initializer or collection is still
+  built per instance, since its value is fixed only at construction. An
+  Immutable value holding a writable member is no longer shared.
+
 ## 0.76.0
 
 ### Minor Changes

package/dist/neo.mjs

@@ -5057,6 +5057,9 @@ var init_project_schema_index = __esm({
         for (const schemaClass2 of source.classes) {
           this.classesById.set(schemaClass2.id, schemaClass2);
           append(this.classesByName, schemaClass2.name, schemaClass2);
+          if (schemaClass2.extendsClassId) {
+            append(this.subclassesById, schemaClass2.extendsClassId, schemaClass2);
+          }
           for (const [schemaKey, memberId] of Object.entries(schemaClass2.schema)) {
             append(this.schemaPlacementsByMemberId, memberId, {
               ownerClass: schemaClass2,
@@ -5101,6 +5104,8 @@ var init_project_schema_index = __esm({
       source;
       classesById = /* @__PURE__ */ new Map();
       classesByName = /* @__PURE__ */ new Map();
+      /** Direct subclasses by the class they extend. */
+      subclassesById = /* @__PURE__ */ new Map();
       membersById = /* @__PURE__ */ new Map();
       membersByName = /* @__PURE__ */ new Map();
       enumsById = /* @__PURE__ */ new Map();
@@ -5226,6 +5231,9 @@ function indexSchema(classes, members) {
 function classIndexFor(classes) {
   return indexClasses(classes).classesById;
 }
+function subclassIndexFor(classes) {
+  return indexClasses(classes).subclassesById;
+}
 function memberIndexFor(members) {
   return projectSchemaIndexFor({ classes: NO_CLASSES, members }).membersById;
 }
@@ -5445,15 +5453,7 @@ function resolveEffectiveIsVirtual(member, members) {
   return modifier === 0 /* Virtual */ || modifier === 2 /* Abstract */;
 }
 function descendantClassIds(classId, allClasses) {
-  const childrenByClassId = /* @__PURE__ */ new Map();
-  for (const schemaClass2 of allClasses) {
-    if (!schemaClass2.extendsClassId) continue;
-    const children = childrenByClassId.get(schemaClass2.extendsClassId);
-    if (children === void 0) {
-      childrenByClassId.set(schemaClass2.extendsClassId, [schemaClass2]);
-    } else children.push(schemaClass2);
-  }
-  return descendantClassIdsInChildIndex(classId, childrenByClassId);
+  return descendantClassIdsInChildIndex(classId, subclassIndexFor(allClasses));
 }
 function descendantClassIdsInChildIndex(classId, childrenByClassId) {
   const result = /* @__PURE__ */ new Set();
@@ -11311,103 +11311,204 @@ function buildDefaultClassMaterializationPlan(document, classId, instanceEnv) {
     ...document,
     constructors: document.constructors ?? []
   });
-  const merged = document.storedInstanceSchema?.(classId) ?? mergeInstanceSurfaceSchema(classId, document.classes, document.members);
-  return merged.flatMap((entry) => {
-    if (entry.memberId === null) return [];
-    const childMember = findMemberInDocument(document, entry.memberId);
-    if (!memberKindOwnsStoredValue(childMember.kind)) return [];
-    if (instanceEnv.size === 0 && isImmutableConstantMember(
-      document,
-      document.resolvedMember?.(childMember) ?? resolveMember(childMember, document.members)
-    ))
-      return [];
-    const member = substituteMember(
-      childMember,
-      instanceEnv,
-      document.members,
-      document.resolvedMember?.(childMember)
-    );
-    return [
-      {
-        schemaKey: entry.schemaKey,
-        member,
-        defaultSettlesConstruction: settlesConstruction(member, instanceEnv),
-        directScalarBody: directScalarDefaultBody(document, member)
-      }
-    ];
-  });
+  return storedSchemaOf(document, classId).flatMap(
+    (entry) => {
+      if (entry.memberId === null) return [];
+      const childMember = findMemberInDocument(document, entry.memberId);
+      if (!memberKindOwnsStoredValue(childMember.kind)) return [];
+      if (instanceEnv.size === 0 && isConstantMember(document, resolvedInDocument(document, childMember)))
+        return [];
+      const member = substituteMember(
+        childMember,
+        instanceEnv,
+        document.members,
+        document.resolvedMember?.(childMember)
+      );
+      return [
+        {
+          schemaKey: entry.schemaKey,
+          member,
+          defaultSettlesConstruction: settlesConstruction(member, instanceEnv),
+          directScalarBody: directScalarDefaultBody(document, member)
+        }
+      ];
+    }
+  );
 }
-function isImmutableConstantMember(document, resolved) {
-  if (resolved.storage !== 1 /* Immutable */) return false;
+function isConstantMember(document, resolved) {
   if (isStaticMember(resolved)) return false;
+  const fixedness = fixednessOf(resolved, 0 /* Writable */);
+  if (fixedness === 0 /* Writable */) return false;
   const declared = resolved.defaultValue;
   if (declared == null) return false;
-  return !declarationReadsInstance(
-    { document, visited: /* @__PURE__ */ new Set() },
+  if (fixedness === 1 /* ReadOnly */ && (isMemberListBase(resolved) || isMemberDictionaryBase(resolved)))
+    return false;
+  return !declarationVaries(
+    {
+      document,
+      rows: /* @__PURE__ */ new Set(),
+      declarations: /* @__PURE__ */ new Set(),
+      classes: /* @__PURE__ */ new Set()
+    },
     resolved,
     declared,
-    null
+    null,
+    { fixedness, ownsReads: true }
   );
 }
-function declarationReadsInstance(walk, member, body, rowId) {
+function fixednessOf(resolved, parent) {
+  const storage = resolved.storage ?? 0 /* Inherit */;
+  if (storage === 1 /* Immutable */) return 2 /* Immutable */;
+  if (storage === 0 /* Inherit */ && parent === 2 /* Immutable */)
+    return 2 /* Immutable */;
+  return isReadOnlyMember(resolved) ? 1 /* ReadOnly */ : 0 /* Writable */;
+}
+function scopeKey(id2, scope) {
+  return `${id2}:${scope.fixedness}:${scope.ownsReads}`;
+}
+function resolvedInDocument(document, member) {
+  return document.resolvedMember?.(member) ?? resolveMember(member, document.members);
+}
+function declarationVaries(walk, member, body, rowId, scope) {
   const { document } = walk;
+  const { ownsReads } = scope;
+  const immutable2 = scope.fixedness === 2 /* Immutable */;
   if (documentHasInitValueContent(document, body)) {
-    const compiled = body.init.compiled;
-    if (compiled === void 0) return true;
-    const instanceParameters = /* @__PURE__ */ new Set();
-    for (const parameter4 of compiled.parameters) {
-      if (parameter4.id !== "__root__") instanceParameters.add(parameter4.id);
-    }
-    return irReadsInstance(
-      compiled.instructions,
-      instanceParameters,
-      /* @__PURE__ */ new Set()
-    );
+    if (!immutable2) return true;
+    if (ownsReads) {
+      const compiled = body.init.compiled;
+      if (compiled === void 0) return true;
+      if (initializerReadsInstance(compiled)) return true;
+    }
+    return typeHoldsWritable(walk, member, 2 /* Immutable */);
   }
   if (!isLiteralValueContent(body)) return true;
-  if (irReadsInstance(body.constructorArgs, /* @__PURE__ */ new Set(), /* @__PURE__ */ new Set())) return true;
+  if (!immutable2 && body.instanceConstructorId !== void 0) return true;
+  if (!immutable2 && body.constructorArgs != null) return true;
+  if (ownsReads && irReadsInstance(body.constructorArgs, /* @__PURE__ */ new Set(), /* @__PURE__ */ new Set()))
+    return true;
   const value = body.value;
-  const ownedEntry = (entryMember) => (valueId) => typeof valueId !== "string" || rowReadsInstance(walk, entryMember, valueId);
   if (isMemberClassBase(member)) {
     if (value === null) return false;
     if (!isStringRecord(value)) return true;
     const classId = typeof body.classId === "string" ? body.classId : member.classId;
-    const entries = getSchemaEntryMap(document, classId);
-    for (const [schemaKey, valueId] of Object.entries(value)) {
-      const memberId = entries.get(schemaKey)?.memberId;
-      if (memberId == null) return true;
-      const child2 = findMemberInDocument(document, memberId);
-      if (ownedEntry(child2)(valueId)) return true;
+    let owned = 0;
+    for (const entry of storedSchemaOf(document, classId)) {
+      if (entry.memberId === null) continue;
+      const child2 = resolvedInDocument(
+        document,
+        findMemberInDocument(document, entry.memberId)
+      );
+      const childId = value[entry.schemaKey];
+      if (childId !== void 0) owned++;
+      else if (!memberKindOwnsStoredValue(child2.kind) || isStaticMember(child2))
+        continue;
+      const fixedness = fixednessOf(child2, scope.fixedness);
+      if (fixedness === 0 /* Writable */) return true;
+      if (childId !== void 0) {
+        if (rowVaries(walk, child2, childId, { fixedness, ownsReads }))
+          return true;
+        continue;
+      }
+      const declared = child2.defaultValue;
+      if (declared == null) continue;
+      const childScope = { fixedness, ownsReads: false };
+      const key = scopeKey(entry.memberId, childScope);
+      if (walk.declarations.has(key)) continue;
+      walk.declarations.add(key);
+      if (declarationVaries(walk, child2, declared, null, childScope))
+        return true;
     }
-    return false;
+    return owned !== Object.keys(value).length;
   }
   if (isMemberListBase(member)) {
-    const entryMember = findMemberInDocument(document, member.entryMemberId);
     const entryIds = listKindOf(member) !== 1 /* Unordered */ ? value : rowId === null ? [] : document.unorderedListEntryIds?.(rowId) ?? (walk.membership ??= buildUnorderedListMembershipIndex(
       document.values
     )).get(rowId) ?? [];
     if (entryIds === null) return false;
-    return !Array.isArray(entryIds) || entryIds.some(ownedEntry(entryMember));
+    if (!Array.isArray(entryIds)) return true;
+    return entriesVary(walk, member.entryMemberId, entryIds, scope);
   }
   if (isMemberDictionaryBase(member)) {
     if (value === null) return false;
     if (!isStringRecord(value)) return true;
-    const entryMember = findMemberInDocument(document, member.entryMemberId);
-    return Object.values(value).some(ownedEntry(entryMember));
+    return entriesVary(walk, member.entryMemberId, Object.values(value), scope);
   }
   if (member.kind === 21 /* Generic */) return true;
-  return irReadsInstance(value, /* @__PURE__ */ new Set(), /* @__PURE__ */ new Set());
+  return ownsReads && irReadsInstance(value, /* @__PURE__ */ new Set(), /* @__PURE__ */ new Set());
+}
+function entriesVary(walk, entryMemberId, entryIds, scope) {
+  if (entryIds.length === 0) return false;
+  const entryMember = resolvedInDocument(
+    walk.document,
+    findMemberInDocument(walk.document, entryMemberId)
+  );
+  const fixedness = fixednessOf(entryMember, scope.fixedness);
+  if (fixedness === 0 /* Writable */) return true;
+  const entryScope = { fixedness, ownsReads: scope.ownsReads };
+  return entryIds.some(
+    (entryId) => typeof entryId !== "string" || rowVaries(walk, entryMember, entryId, entryScope)
+  );
 }
-function rowReadsInstance(walk, member, valueId) {
-  if (walk.visited.has(valueId)) return false;
-  walk.visited.add(valueId);
+function rowVaries(walk, member, valueId, scope) {
+  const key = scopeKey(valueId, scope);
+  if (walk.rows.has(key)) return false;
+  walk.rows.add(key);
   const { document } = walk;
   const row = document.valueById?.(valueId) ?? (walk.rowById ??= new Map(
     document.values.map((value) => [value.id, value])
   )).get(valueId);
   if (row === void 0 || row === null) return true;
-  const resolved = document.resolvedMember?.(member) ?? resolveMember(member, document.members);
-  return declarationReadsInstance(walk, resolved, row, row.id);
+  return declarationVaries(walk, member, row, row.id, scope);
+}
+function typeHoldsWritable(walk, member, fixedness) {
+  if (isMemberClassBase(member)) {
+    const { classes } = walk.document;
+    if (!classIndexFor(classes).has(member.classId)) return true;
+    if (classHoldsWritable(walk, member.classId, fixedness)) return true;
+    for (const classId of descendantClassIds(member.classId, classes)) {
+      if (classHoldsWritable(walk, classId, fixedness)) return true;
+    }
+    return false;
+  }
+  if (isMemberListBase(member) || isMemberDictionaryBase(member)) {
+    const entryMember = resolvedInDocument(
+      walk.document,
+      findMemberInDocument(walk.document, member.entryMemberId)
+    );
+    const entryFixedness = fixednessOf(entryMember, fixedness);
+    return entryFixedness === 0 /* Writable */ || typeHoldsWritable(walk, entryMember, entryFixedness);
+  }
+  return member.kind === 21 /* Generic */;
+}
+function classHoldsWritable(walk, classId, fixedness) {
+  const key = `${classId}:${fixedness}`;
+  if (walk.classes.has(key)) return false;
+  walk.classes.add(key);
+  const { document } = walk;
+  for (const entry of storedSchemaOf(document, classId)) {
+    if (entry.memberId === null) continue;
+    const child2 = resolvedInDocument(
+      document,
+      findMemberInDocument(document, entry.memberId)
+    );
+    if (!memberKindOwnsStoredValue(child2.kind) || isStaticMember(child2))
+      continue;
+    const childFixedness = fixednessOf(child2, fixedness);
+    if (childFixedness === 0 /* Writable */) return true;
+    if (typeHoldsWritable(walk, child2, childFixedness)) return true;
+  }
+  return false;
+}
+function storedSchemaOf(document, classId) {
+  return document.storedInstanceSchema?.(classId) ?? resolvedClassSchema(classId, document.classes, document.members).surface;
+}
+function initializerReadsInstance(compiled) {
+  const instanceParameters = /* @__PURE__ */ new Set();
+  for (const parameter4 of compiled.parameters) {
+    if (parameter4.id !== "__root__") instanceParameters.add(parameter4.id);
+  }
+  return irReadsInstance(compiled.instructions, instanceParameters, /* @__PURE__ */ new Set());
 }
 function irReadsInstance(value, instanceParameters, visited) {
   if (typeof value !== "object" || value === null) return false;
@@ -51964,7 +52065,7 @@ var init_registry = __esm({
   "../packages/manifest/schema-contract/registry.mjs"() {
     "use strict";
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
-      cliVersion: "0.76.0",
+      cliVersion: "0.76.1",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -80382,7 +80483,9 @@ function readClassMember(args) {
   const expanded = args.expandedRecord();
   if (expanded !== null && Object.prototype.hasOwnProperty.call(expanded, schemaKey))
     return { kind: "value", value: Reflect.get(expanded, schemaKey) };
-  if (args.mode !== "resolved" && declaration !== void 0)
+  if (args.mode === "resolved")
+    return declaration !== void 0 && args.isConstant() ? { kind: "declaration", content: declaration } : { kind: "missing" };
+  if (declaration !== void 0)
     return { kind: "declaration", content: declaration };
   if (args.mode === "runtime" && !isRequiredMember(member))
     return { kind: "null" };
@@ -81919,6 +82022,7 @@ function withEvaluationRuntime(ctx, writes) {
       constructionTimestamp: Date.now(),
       ownedValueAttachments: /* @__PURE__ */ new Map(),
       constructionStack: [],
+      openConstructions: /* @__PURE__ */ new Map(),
       loopIterations: 0,
       budgetedConstructedRowIds: /* @__PURE__ */ new Set(),
       budgetedProducedEntriesByRowId: /* @__PURE__ */ new Map(),
@@ -82941,14 +83045,16 @@ function evalInstructions(instructions, scope, ctx, options) {
             };
           }
           const assignedReferenceValueId = targetTypeInfo.type === 7 /* Class */ || targetTypeInfo.type === 6 /* List */ || targetTypeInfo.type === 5 /* Dictionary */ ? findKnownRowIdByValueReference(value, ctx) : null;
-          applyOverlayAssignment(
-            ins.target.pointer,
-            targetTypeInfo,
-            value,
-            scope,
-            ctx,
-            destination
-          );
+          if (!bindOmittedConstantSlot(destination, member, value, ctx)) {
+            applyOverlayAssignment(
+              ins.target.pointer,
+              targetTypeInfo,
+              value,
+              scope,
+              ctx,
+              destination
+            );
+          }
           const unorderedReplacement = assignedReferenceValueId === null && member !== null && isMemberListBase(member) && listKindOf(member) === 1 /* Unordered */ && Array.isArray(value) ? unorderedReplacementProjection(
             ins.target.pointer,
             destination,
@@ -83812,6 +83918,36 @@ function applyOverlayStaticAssignment(memberId, value, ctx) {
   bindings.set(member.id, row.id);
   invalidateEvaluatorIndexes(ctx);
 }
+function bindOmittedConstantSlot(destination, member, value, ctx) {
+  if (destination === void 0 || member === null) return false;
+  const { receiver } = destination;
+  if (typeof receiver !== "object" || receiver === null) return false;
+  const construction = ctx.__executionState?.openConstructions.get(receiver);
+  if (construction === void 0) return false;
+  const key = String(destination.key);
+  if (Object.prototype.hasOwnProperty.call(receiver, key)) return false;
+  if (isMemberClassBase(member) || isMemberListBase(member) || isMemberDictionaryBase(member))
+    return false;
+  const resolved = resolveMember(member, ctx.vm.members);
+  if (!isConstantMember(constructorDefaultValueDocument(ctx, member), resolved))
+    return false;
+  const { createdValues } = construction;
+  const staged = createdValues.length;
+  const row = materializeConstructorArgumentValue({
+    member: resolved,
+    value,
+    // A constant has no instance environment.
+    genericEnv: /* @__PURE__ */ new Map(),
+    ctx,
+    createdValues,
+    createdById: /* @__PURE__ */ new Map(),
+    storageKeyDeclarations: construction.storageKeyDeclarations
+  });
+  stageConstructedRows(createdValues.slice(staged), ctx);
+  Reflect.set(receiver, key, row.id);
+  invalidateEvaluatorIndexes(ctx, receiver);
+  return true;
+}
 function touchUnknown(_ins) {
   void _ins;
 }
@@ -86198,7 +86334,7 @@ function readDeclarationDefault(member, ctx) {
       };
     }
     const document = constructorDefaultValueDocument(ctx, member);
-    const constant = shared !== void 0 && known !== false && (known !== void 0 || isImmutableConstantMember(document, member));
+    const constant = shared !== void 0 && known !== false && (known !== void 0 || isConstantMember(document, member));
     if (shared !== void 0 && !constant) shared.set(member.id, false);
     const created = [];
     const closeFrame = pushConstructionFrame(ctx, `${member.name} declaration`);
@@ -90691,39 +90827,50 @@ function constructDeclaredClassValueWithinFrame(descriptor, record7, info, scope
   stageConstructedRows(createdValues, ctx);
   bindConstructedDelegateTargets(createdValues, ctx);
   if (record7 !== null) {
-    runDeclaredConstructorChain({
-      record: record7,
-      argumentValues,
-      preparedArgumentScopes,
-      thisValue: root.value,
-      ctx,
-      visitedConstructorIds: /* @__PURE__ */ new Set(),
-      applyBaseInitializerBlock: (chainRecord, chainArguments, chainThisValue) => {
-        const supplied2 = evaluateBaseInitializerFields({
-          record: chainRecord,
-          argumentValues: chainArguments,
-          thisValue: chainThisValue,
-          constructedClassId: classId,
-          instanceEnv: descriptor.instanceEnv,
-          ctx
-        });
-        if (supplied2.length === 0) return;
-        applyConstructorFields({
-          supplied: supplied2,
-          root,
-          rootRecord,
-          schemaClass: schemaClass2,
-          instanceEnv: descriptor.instanceEnv,
-          createdValues,
-          createdById: new Map(createdValues.map((row) => [row.id, row])),
-          storageKeyDeclarations,
-          // §1.5 base blocks are assignments, not omissions: an explicit null
-          // clears the slot exactly as a call-site block entry does.
-          nullMeansOmit: false,
-          ctx
-        });
-      }
+    const openConstructions = ctx.__executionState?.openConstructions;
+    openConstructions?.set(rootRecord, {
+      createdValues,
+      storageKeyDeclarations
     });
+    try {
+      runDeclaredConstructorChain({
+        record: record7,
+        argumentValues,
+        preparedArgumentScopes,
+        thisValue: root.value,
+        ctx,
+        visitedConstructorIds: /* @__PURE__ */ new Set(),
+        applyBaseInitializerBlock: (chainRecord, chainArguments, chainThisValue) => {
+          const supplied2 = evaluateBaseInitializerFields({
+            record: chainRecord,
+            argumentValues: chainArguments,
+            thisValue: chainThisValue,
+            constructedClassId: classId,
+            instanceEnv: descriptor.instanceEnv,
+            ctx
+          });
+          if (supplied2.length === 0) return;
+          const staged = createdValues.length;
+          applyConstructorFields({
+            supplied: supplied2,
+            root,
+            rootRecord,
+            schemaClass: schemaClass2,
+            instanceEnv: descriptor.instanceEnv,
+            createdValues,
+            createdById: new Map(createdValues.map((row) => [row.id, row])),
+            storageKeyDeclarations,
+            // §1.5 base blocks are assignments, not omissions: an explicit null
+            // clears the slot exactly as a call-site block entry does.
+            nullMeansOmit: false,
+            ctx
+          });
+          stageConstructedRows(createdValues.slice(staged), ctx);
+        }
+      });
+    } finally {
+      openConstructions?.delete(rootRecord);
+    }
   }
   const supplied = evaluateConstructorFields(descriptor, scope, ctx);
   try {
@@ -122203,6 +122350,7 @@ function assertStagedVariantMemberValuesValid(projected, changes) {
       value: entry.value,
       declaration: entry.declaration,
       owner: entry.label,
+      classes: projected.classes,
       classesById,
       variantsById,
       foldersById,
@@ -122275,10 +122423,7 @@ function assertVariantReferenceValid(args) {
   if (target.type === 7 /* Class */ && value.classId !== target.classId) {
     let admitted = args.admittedClassesByTarget.get(target.classId);
     if (admitted === void 0) {
-      admitted = descendantClassIds(
-        target.classId,
-        Array.from(classesById.values())
-      );
+      admitted = descendantClassIds(target.classId, args.classes);
       args.admittedClassesByTarget.set(target.classId, admitted);
     }
     if (!admitted.has(value.classId)) {
@@ -191652,7 +191797,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.76.0");
+    console.log("0.76.1");
     return;
   }
   if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {

package/dist/test-worker.mjs

@@ -5295,6 +5295,9 @@ var ProjectSchemaIndex = class {
     for (const schemaClass2 of source.classes) {
       this.classesById.set(schemaClass2.id, schemaClass2);
       append(this.classesByName, schemaClass2.name, schemaClass2);
+      if (schemaClass2.extendsClassId) {
+        append(this.subclassesById, schemaClass2.extendsClassId, schemaClass2);
+      }
       for (const [schemaKey, memberId] of Object.entries(schemaClass2.schema)) {
         append(this.schemaPlacementsByMemberId, memberId, {
           ownerClass: schemaClass2,
@@ -5339,6 +5342,8 @@ var ProjectSchemaIndex = class {
   source;
   classesById = /* @__PURE__ */ new Map();
   classesByName = /* @__PURE__ */ new Map();
+  /** Direct subclasses by the class they extend. */
+  subclassesById = /* @__PURE__ */ new Map();
   membersById = /* @__PURE__ */ new Map();
   membersByName = /* @__PURE__ */ new Map();
   enumsById = /* @__PURE__ */ new Map();
@@ -5523,6 +5528,9 @@ function indexSchema(classes, members) {
 function classIndexFor(classes) {
   return indexClasses(classes).classesById;
 }
+function subclassIndexFor(classes) {
+  return indexClasses(classes).subclassesById;
+}
 function memberIndexFor(members) {
   return projectSchemaIndexFor({ classes: NO_CLASSES, members }).membersById;
 }
@@ -5724,15 +5732,7 @@ function resolveMemberWithIndex(member, memberIndex) {
   return Object.freeze(merged);
 }
 function descendantClassIds(classId, allClasses) {
-  const childrenByClassId = /* @__PURE__ */ new Map();
-  for (const schemaClass2 of allClasses) {
-    if (!schemaClass2.extendsClassId) continue;
-    const children = childrenByClassId.get(schemaClass2.extendsClassId);
-    if (children === void 0) {
-      childrenByClassId.set(schemaClass2.extendsClassId, [schemaClass2]);
-    } else children.push(schemaClass2);
-  }
-  return descendantClassIdsInChildIndex(classId, childrenByClassId);
+  return descendantClassIdsInChildIndex(classId, subclassIndexFor(allClasses));
 }
 function descendantClassIdsInChildIndex(classId, childrenByClassId) {
   const result = /* @__PURE__ */ new Set();
@@ -10667,103 +10667,204 @@ function buildDefaultClassMaterializationPlan(document2, classId, instanceEnv) {
     ...document2,
     constructors: document2.constructors ?? []
   });
-  const merged = document2.storedInstanceSchema?.(classId) ?? mergeInstanceSurfaceSchema(classId, document2.classes, document2.members);
-  return merged.flatMap((entry) => {
-    if (entry.memberId === null) return [];
-    const childMember = findMemberInDocument(document2, entry.memberId);
-    if (!memberKindOwnsStoredValue(childMember.kind)) return [];
-    if (instanceEnv.size === 0 && isImmutableConstantMember(
-      document2,
-      document2.resolvedMember?.(childMember) ?? resolveMember(childMember, document2.members)
-    ))
-      return [];
-    const member = substituteMember(
-      childMember,
-      instanceEnv,
-      document2.members,
-      document2.resolvedMember?.(childMember)
-    );
-    return [
-      {
-        schemaKey: entry.schemaKey,
-        member,
-        defaultSettlesConstruction: settlesConstruction(member, instanceEnv),
-        directScalarBody: directScalarDefaultBody(document2, member)
-      }
-    ];
-  });
+  return storedSchemaOf(document2, classId).flatMap(
+    (entry) => {
+      if (entry.memberId === null) return [];
+      const childMember = findMemberInDocument(document2, entry.memberId);
+      if (!memberKindOwnsStoredValue(childMember.kind)) return [];
+      if (instanceEnv.size === 0 && isConstantMember(document2, resolvedInDocument(document2, childMember)))
+        return [];
+      const member = substituteMember(
+        childMember,
+        instanceEnv,
+        document2.members,
+        document2.resolvedMember?.(childMember)
+      );
+      return [
+        {
+          schemaKey: entry.schemaKey,
+          member,
+          defaultSettlesConstruction: settlesConstruction(member, instanceEnv),
+          directScalarBody: directScalarDefaultBody(document2, member)
+        }
+      ];
+    }
+  );
 }
-function isImmutableConstantMember(document2, resolved) {
-  if (resolved.storage !== 1 /* Immutable */) return false;
+function isConstantMember(document2, resolved) {
   if (isStaticMember(resolved)) return false;
+  const fixedness = fixednessOf(resolved, 0 /* Writable */);
+  if (fixedness === 0 /* Writable */) return false;
   const declared = resolved.defaultValue;
   if (declared == null) return false;
-  return !declarationReadsInstance(
-    { document: document2, visited: /* @__PURE__ */ new Set() },
+  if (fixedness === 1 /* ReadOnly */ && (isMemberListBase(resolved) || isMemberDictionaryBase(resolved)))
+    return false;
+  return !declarationVaries(
+    {
+      document: document2,
+      rows: /* @__PURE__ */ new Set(),
+      declarations: /* @__PURE__ */ new Set(),
+      classes: /* @__PURE__ */ new Set()
+    },
     resolved,
     declared,
-    null
+    null,
+    { fixedness, ownsReads: true }
   );
 }
-function declarationReadsInstance(walk, member, body, rowId) {
+function fixednessOf(resolved, parent) {
+  const storage = resolved.storage ?? 0 /* Inherit */;
+  if (storage === 1 /* Immutable */) return 2 /* Immutable */;
+  if (storage === 0 /* Inherit */ && parent === 2 /* Immutable */)
+    return 2 /* Immutable */;
+  return isReadOnlyMember(resolved) ? 1 /* ReadOnly */ : 0 /* Writable */;
+}
+function scopeKey(id, scope) {
+  return `${id}:${scope.fixedness}:${scope.ownsReads}`;
+}
+function resolvedInDocument(document2, member) {
+  return document2.resolvedMember?.(member) ?? resolveMember(member, document2.members);
+}
+function declarationVaries(walk, member, body, rowId, scope) {
   const { document: document2 } = walk;
+  const { ownsReads } = scope;
+  const immutable2 = scope.fixedness === 2 /* Immutable */;
   if (documentHasInitValueContent(document2, body)) {
-    const compiled = body.init.compiled;
-    if (compiled === void 0) return true;
-    const instanceParameters = /* @__PURE__ */ new Set();
-    for (const parameter3 of compiled.parameters) {
-      if (parameter3.id !== "__root__") instanceParameters.add(parameter3.id);
-    }
-    return irReadsInstance(
-      compiled.instructions,
-      instanceParameters,
-      /* @__PURE__ */ new Set()
-    );
+    if (!immutable2) return true;
+    if (ownsReads) {
+      const compiled = body.init.compiled;
+      if (compiled === void 0) return true;
+      if (initializerReadsInstance(compiled)) return true;
+    }
+    return typeHoldsWritable(walk, member, 2 /* Immutable */);
   }
   if (!isLiteralValueContent(body)) return true;
-  if (irReadsInstance(body.constructorArgs, /* @__PURE__ */ new Set(), /* @__PURE__ */ new Set())) return true;
+  if (!immutable2 && body.instanceConstructorId !== void 0) return true;
+  if (!immutable2 && body.constructorArgs != null) return true;
+  if (ownsReads && irReadsInstance(body.constructorArgs, /* @__PURE__ */ new Set(), /* @__PURE__ */ new Set()))
+    return true;
   const value = body.value;
-  const ownedEntry = (entryMember) => (valueId) => typeof valueId !== "string" || rowReadsInstance(walk, entryMember, valueId);
   if (isMemberClassBase(member)) {
     if (value === null) return false;
     if (!isStringRecord(value)) return true;
     const classId = typeof body.classId === "string" ? body.classId : member.classId;
-    const entries = getSchemaEntryMap(document2, classId);
-    for (const [schemaKey, valueId] of Object.entries(value)) {
-      const memberId = entries.get(schemaKey)?.memberId;
-      if (memberId == null) return true;
-      const child = findMemberInDocument(document2, memberId);
-      if (ownedEntry(child)(valueId)) return true;
+    let owned = 0;
+    for (const entry of storedSchemaOf(document2, classId)) {
+      if (entry.memberId === null) continue;
+      const child = resolvedInDocument(
+        document2,
+        findMemberInDocument(document2, entry.memberId)
+      );
+      const childId = value[entry.schemaKey];
+      if (childId !== void 0) owned++;
+      else if (!memberKindOwnsStoredValue(child.kind) || isStaticMember(child))
+        continue;
+      const fixedness = fixednessOf(child, scope.fixedness);
+      if (fixedness === 0 /* Writable */) return true;
+      if (childId !== void 0) {
+        if (rowVaries(walk, child, childId, { fixedness, ownsReads }))
+          return true;
+        continue;
+      }
+      const declared = child.defaultValue;
+      if (declared == null) continue;
+      const childScope = { fixedness, ownsReads: false };
+      const key = scopeKey(entry.memberId, childScope);
+      if (walk.declarations.has(key)) continue;
+      walk.declarations.add(key);
+      if (declarationVaries(walk, child, declared, null, childScope))
+        return true;
     }
-    return false;
+    return owned !== Object.keys(value).length;
   }
   if (isMemberListBase(member)) {
-    const entryMember = findMemberInDocument(document2, member.entryMemberId);
     const entryIds = listKindOf(member) !== 1 /* Unordered */ ? value : rowId === null ? [] : document2.unorderedListEntryIds?.(rowId) ?? (walk.membership ??= buildUnorderedListMembershipIndex(
       document2.values
     )).get(rowId) ?? [];
     if (entryIds === null) return false;
-    return !Array.isArray(entryIds) || entryIds.some(ownedEntry(entryMember));
+    if (!Array.isArray(entryIds)) return true;
+    return entriesVary(walk, member.entryMemberId, entryIds, scope);
   }
   if (isMemberDictionaryBase(member)) {
     if (value === null) return false;
     if (!isStringRecord(value)) return true;
-    const entryMember = findMemberInDocument(document2, member.entryMemberId);
-    return Object.values(value).some(ownedEntry(entryMember));
+    return entriesVary(walk, member.entryMemberId, Object.values(value), scope);
   }
   if (member.kind === 21 /* Generic */) return true;
-  return irReadsInstance(value, /* @__PURE__ */ new Set(), /* @__PURE__ */ new Set());
+  return ownsReads && irReadsInstance(value, /* @__PURE__ */ new Set(), /* @__PURE__ */ new Set());
+}
+function entriesVary(walk, entryMemberId, entryIds, scope) {
+  if (entryIds.length === 0) return false;
+  const entryMember = resolvedInDocument(
+    walk.document,
+    findMemberInDocument(walk.document, entryMemberId)
+  );
+  const fixedness = fixednessOf(entryMember, scope.fixedness);
+  if (fixedness === 0 /* Writable */) return true;
+  const entryScope = { fixedness, ownsReads: scope.ownsReads };
+  return entryIds.some(
+    (entryId) => typeof entryId !== "string" || rowVaries(walk, entryMember, entryId, entryScope)
+  );
 }
-function rowReadsInstance(walk, member, valueId) {
-  if (walk.visited.has(valueId)) return false;
-  walk.visited.add(valueId);
+function rowVaries(walk, member, valueId, scope) {
+  const key = scopeKey(valueId, scope);
+  if (walk.rows.has(key)) return false;
+  walk.rows.add(key);
   const { document: document2 } = walk;
   const row = document2.valueById?.(valueId) ?? (walk.rowById ??= new Map(
     document2.values.map((value) => [value.id, value])
   )).get(valueId);
   if (row === void 0 || row === null) return true;
-  const resolved = document2.resolvedMember?.(member) ?? resolveMember(member, document2.members);
-  return declarationReadsInstance(walk, resolved, row, row.id);
+  return declarationVaries(walk, member, row, row.id, scope);
+}
+function typeHoldsWritable(walk, member, fixedness) {
+  if (isMemberClassBase(member)) {
+    const { classes } = walk.document;
+    if (!classIndexFor(classes).has(member.classId)) return true;
+    if (classHoldsWritable(walk, member.classId, fixedness)) return true;
+    for (const classId of descendantClassIds(member.classId, classes)) {
+      if (classHoldsWritable(walk, classId, fixedness)) return true;
+    }
+    return false;
+  }
+  if (isMemberListBase(member) || isMemberDictionaryBase(member)) {
+    const entryMember = resolvedInDocument(
+      walk.document,
+      findMemberInDocument(walk.document, member.entryMemberId)
+    );
+    const entryFixedness = fixednessOf(entryMember, fixedness);
+    return entryFixedness === 0 /* Writable */ || typeHoldsWritable(walk, entryMember, entryFixedness);
+  }
+  return member.kind === 21 /* Generic */;
+}
+function classHoldsWritable(walk, classId, fixedness) {
+  const key = `${classId}:${fixedness}`;
+  if (walk.classes.has(key)) return false;
+  walk.classes.add(key);
+  const { document: document2 } = walk;
+  for (const entry of storedSchemaOf(document2, classId)) {
+    if (entry.memberId === null) continue;
+    const child = resolvedInDocument(
+      document2,
+      findMemberInDocument(document2, entry.memberId)
+    );
+    if (!memberKindOwnsStoredValue(child.kind) || isStaticMember(child))
+      continue;
+    const childFixedness = fixednessOf(child, fixedness);
+    if (childFixedness === 0 /* Writable */) return true;
+    if (typeHoldsWritable(walk, child, childFixedness)) return true;
+  }
+  return false;
+}
+function storedSchemaOf(document2, classId) {
+  return document2.storedInstanceSchema?.(classId) ?? resolvedClassSchema(classId, document2.classes, document2.members).surface;
+}
+function initializerReadsInstance(compiled) {
+  const instanceParameters = /* @__PURE__ */ new Set();
+  for (const parameter3 of compiled.parameters) {
+    if (parameter3.id !== "__root__") instanceParameters.add(parameter3.id);
+  }
+  return irReadsInstance(compiled.instructions, instanceParameters, /* @__PURE__ */ new Set());
 }
 function irReadsInstance(value, instanceParameters, visited) {
   if (typeof value !== "object" || value === null) return false;
@@ -15468,7 +15569,9 @@ function readClassMember(args) {
   const expanded = args.expandedRecord();
   if (expanded !== null && Object.prototype.hasOwnProperty.call(expanded, schemaKey))
     return { kind: "value", value: Reflect.get(expanded, schemaKey) };
-  if (args.mode !== "resolved" && declaration !== void 0)
+  if (args.mode === "resolved")
+    return declaration !== void 0 && args.isConstant() ? { kind: "declaration", content: declaration } : { kind: "missing" };
+  if (declaration !== void 0)
     return { kind: "declaration", content: declaration };
   if (args.mode === "runtime" && !isRequiredMember(member))
     return { kind: "null" };
@@ -16974,6 +17077,7 @@ function withEvaluationRuntime(ctx, writes) {
       constructionTimestamp: Date.now(),
       ownedValueAttachments: /* @__PURE__ */ new Map(),
       constructionStack: [],
+      openConstructions: /* @__PURE__ */ new Map(),
       loopIterations: 0,
       budgetedConstructedRowIds: /* @__PURE__ */ new Set(),
       budgetedProducedEntriesByRowId: /* @__PURE__ */ new Map(),
@@ -18109,14 +18213,16 @@ function evalInstructions(instructions, scope, ctx, options) {
             };
           }
           const assignedReferenceValueId = targetTypeInfo.type === 7 /* Class */ || targetTypeInfo.type === 6 /* List */ || targetTypeInfo.type === 5 /* Dictionary */ ? findKnownRowIdByValueReference(value, ctx) : null;
-          applyOverlayAssignment(
-            ins.target.pointer,
-            targetTypeInfo,
-            value,
-            scope,
-            ctx,
-            destination
-          );
+          if (!bindOmittedConstantSlot(destination, member, value, ctx)) {
+            applyOverlayAssignment(
+              ins.target.pointer,
+              targetTypeInfo,
+              value,
+              scope,
+              ctx,
+              destination
+            );
+          }
           const unorderedReplacement = assignedReferenceValueId === null && member !== null && isMemberListBase(member) && listKindOf(member) === 1 /* Unordered */ && Array.isArray(value) ? unorderedReplacementProjection(
             ins.target.pointer,
             destination,
@@ -18971,6 +19077,36 @@ function applyOverlayStaticAssignment(memberId, value, ctx) {
   bindings.set(member.id, row.id);
   invalidateEvaluatorIndexes(ctx);
 }
+function bindOmittedConstantSlot(destination, member, value, ctx) {
+  if (destination === void 0 || member === null) return false;
+  const { receiver } = destination;
+  if (typeof receiver !== "object" || receiver === null) return false;
+  const construction = ctx.__executionState?.openConstructions.get(receiver);
+  if (construction === void 0) return false;
+  const key = String(destination.key);
+  if (Object.prototype.hasOwnProperty.call(receiver, key)) return false;
+  if (isMemberClassBase(member) || isMemberListBase(member) || isMemberDictionaryBase(member))
+    return false;
+  const resolved = resolveMember(member, ctx.vm.members);
+  if (!isConstantMember(constructorDefaultValueDocument(ctx, member), resolved))
+    return false;
+  const { createdValues } = construction;
+  const staged = createdValues.length;
+  const row = materializeConstructorArgumentValue({
+    member: resolved,
+    value,
+    // A constant has no instance environment.
+    genericEnv: /* @__PURE__ */ new Map(),
+    ctx,
+    createdValues,
+    createdById: /* @__PURE__ */ new Map(),
+    storageKeyDeclarations: construction.storageKeyDeclarations
+  });
+  stageConstructedRows(createdValues.slice(staged), ctx);
+  Reflect.set(receiver, key, row.id);
+  invalidateEvaluatorIndexes(ctx, receiver);
+  return true;
+}
 function touchUnknown(_ins) {
   void _ins;
 }
@@ -21358,7 +21494,7 @@ function readDeclarationDefault(member, ctx) {
       };
     }
     const document2 = constructorDefaultValueDocument(ctx, member);
-    const constant = shared !== void 0 && known !== false && (known !== void 0 || isImmutableConstantMember(document2, member));
+    const constant = shared !== void 0 && known !== false && (known !== void 0 || isConstantMember(document2, member));
     if (shared !== void 0 && !constant) shared.set(member.id, false);
     const created = [];
     const closeFrame = pushConstructionFrame(ctx, `${member.name} declaration`);
@@ -25865,39 +26001,50 @@ function constructDeclaredClassValueWithinFrame(descriptor, record4, info, scope
   stageConstructedRows(createdValues, ctx);
   bindConstructedDelegateTargets(createdValues, ctx);
   if (record4 !== null) {
-    runDeclaredConstructorChain({
-      record: record4,
-      argumentValues,
-      preparedArgumentScopes,
-      thisValue: root.value,
-      ctx,
-      visitedConstructorIds: /* @__PURE__ */ new Set(),
-      applyBaseInitializerBlock: (chainRecord, chainArguments, chainThisValue) => {
-        const supplied2 = evaluateBaseInitializerFields({
-          record: chainRecord,
-          argumentValues: chainArguments,
-          thisValue: chainThisValue,
-          constructedClassId: classId,
-          instanceEnv: descriptor.instanceEnv,
-          ctx
-        });
-        if (supplied2.length === 0) return;
-        applyConstructorFields({
-          supplied: supplied2,
-          root,
-          rootRecord,
-          schemaClass: schemaClass2,
-          instanceEnv: descriptor.instanceEnv,
-          createdValues,
-          createdById: new Map(createdValues.map((row) => [row.id, row])),
-          storageKeyDeclarations,
-          // §1.5 base blocks are assignments, not omissions: an explicit null
-          // clears the slot exactly as a call-site block entry does.
-          nullMeansOmit: false,
-          ctx
-        });
-      }
+    const openConstructions = ctx.__executionState?.openConstructions;
+    openConstructions?.set(rootRecord, {
+      createdValues,
+      storageKeyDeclarations
     });
+    try {
+      runDeclaredConstructorChain({
+        record: record4,
+        argumentValues,
+        preparedArgumentScopes,
+        thisValue: root.value,
+        ctx,
+        visitedConstructorIds: /* @__PURE__ */ new Set(),
+        applyBaseInitializerBlock: (chainRecord, chainArguments, chainThisValue) => {
+          const supplied2 = evaluateBaseInitializerFields({
+            record: chainRecord,
+            argumentValues: chainArguments,
+            thisValue: chainThisValue,
+            constructedClassId: classId,
+            instanceEnv: descriptor.instanceEnv,
+            ctx
+          });
+          if (supplied2.length === 0) return;
+          const staged = createdValues.length;
+          applyConstructorFields({
+            supplied: supplied2,
+            root,
+            rootRecord,
+            schemaClass: schemaClass2,
+            instanceEnv: descriptor.instanceEnv,
+            createdValues,
+            createdById: new Map(createdValues.map((row) => [row.id, row])),
+            storageKeyDeclarations,
+            // §1.5 base blocks are assignments, not omissions: an explicit null
+            // clears the slot exactly as a call-site block entry does.
+            nullMeansOmit: false,
+            ctx
+          });
+          stageConstructedRows(createdValues.slice(staged), ctx);
+        }
+      });
+    } finally {
+      openConstructions?.delete(rootRecord);
+    }
   }
   const supplied = evaluateConstructorFields(descriptor, scope, ctx);
   try {
@@ -55950,7 +56097,7 @@ var SPECIALIZED_RELATION_KINDS = /* @__PURE__ */ new Set([
 
 // ../packages/manifest/schema-contract/registry.mjs
 var PROJECT_SCHEMA_CONTRACT = Object.freeze({
-  cliVersion: "0.76.0",
+  cliVersion: "0.76.1",
   projectFileUploadBatchSize: 32,
   documentRecords: {
     member: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neocompose/cli",
-  "version": "0.76.0",
+  "version": "0.76.1",
   "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.76.0 -->
+<!-- reviewed-through-cli: 0.76.1 -->
 
 # Neo Compose CLI
 

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

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

package/skills/neocompose-cli/references/declarations-and-construction.md

@@ -184,6 +184,12 @@ Readonly is shallow. A readonly collection's membership is fixed, while its
 entries' members follow their own storage and mutability. User class members
 still declare no storage.
 
+A readonly member declared as a literal (no initializer or constructor call)
+that reads neither `this` nor a constructor argument and holds nothing
+writable is a constant. Instances share its declared value and store nothing
+until a constructor or initializer block writes it. A readonly collection or
+initializer is still built per instance.
+
 `@index(member: Field, kind: .Unique)` and
 `@column(member: Field, width: ..., visibility: ..., pin: ..., overflow: ...)`
 are repeatable List annotations. `member:` is a bare field name on the entry
@@ -459,12 +465,13 @@ construction remain subject to storage and `readonly` restrictions.
 Runtime construction never supplies an Immutable member: an initializer block,
 constructor body, base-clause argument, or generated C# factory cannot set one.
 The value is never stored with the instance. When the declaration, including
-every row it owns, reads neither `this` nor a constructor argument, the member
-is a constant and every instance shares one value. Otherwise each instance
-evaluates the declared initializer with its own `this` and constructor
-arguments, again after a reload. A method group such as `selector: SelectTorso`
-binds `this`. `Clone()` shares an authored or constant Immutable value and
-re-evaluates a per-instance one. A class with a required Immutable member and
+every row it owns, reads neither `this` nor a constructor argument, and no
+value of its type holds a writable member, the member is a constant and every
+instance shares one value. Otherwise each instance evaluates the declared
+initializer with its own `this` and constructor arguments, again after a
+reload. A method group such as `selector: SelectTorso` binds `this`.
+`Clone()` shares an authored Immutable value or a constant and re-evaluates a
+per-instance one. A class with a required Immutable member and
 no initializer cannot be constructed at runtime; only authored values construct
 it.