@neocompose/cli 0.53.2 → 0.53.3

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## [0.53.3] - 2026-09-19
+
+- Executable object initializers can set immutable stored members during construction. Later mutation and readonly-member restrictions still apply.
+- Evaluator effect results encode assigned lists and dictionaries as entry rows while preserving collection aliases during execution.
+
 ## [0.53.2] - 2026-09-19
 
 - `Reference(Symbol)` and `Reference(LocalValue)` inside a constructed instance's initializer block compile. The stored initializer now carries `Reference<T>(id: "…")`, which the strict resolver accepts, so a list entry created with `new Stop(hour: 7) { MerchantRef = Reference(TestMerchant) }`, a member-default template, and the replay after a class change all push instead of failing with `Unknown function 'Reference'`. A local that carries no `@id` yet is refused by name.

package/dist/neo.mjs

@@ -7456,7 +7456,7 @@ var init_strict_resolver = __esm({
         }
         return resolved.pointer.value;
       }
-      resolveAssignment(statement, scope) {
+      resolveAssignment(statement, scope, assignmentContext = "ordinary") {
         if (!isAssignmentTarget(statement.target)) {
           throw new CompileError(
             "Assignment target must be a variable, member, or indexed value.",
@@ -7494,9 +7494,27 @@ var init_strict_resolver = __esm({
             statement.pos
           );
         }
-        if (!writability || writability === "readOnly" /* ReadOnly */ || writability === "immutable" /* Immutable */) {
+        if (target.symbol?.readonlyDeclaration === true) {
           throw new CompileError(
-            target.symbol?.readonlyDeclaration === true ? `Member '${target.symbol.name}' is readonly and can only be changed through its class default.` : writability === "immutable" /* Immutable */ ? "Cannot assign because the target's effective storage is immutable." : `Cannot assign to a read-only ${this.describe(target.type)} value.`,
+            `Member '${target.symbol.name}' is readonly and can only be changed through its class default.`,
+            statement.pos
+          );
+        }
+        if (writability === void 0) {
+          throw new CompileError(
+            `Cannot assign to a read-only ${this.describe(target.type)} value.`,
+            statement.pos
+          );
+        }
+        if (writability === "readOnly" /* ReadOnly */) {
+          throw new CompileError(
+            `Cannot assign to a read-only ${this.describe(target.type)} value.`,
+            statement.pos
+          );
+        }
+        if (writability === "immutable" /* Immutable */ && assignmentContext !== "initializer") {
+          throw new CompileError(
+            "Cannot assign because the target's effective storage is immutable.",
             statement.pos
           );
         }
@@ -9281,16 +9299,22 @@ var init_strict_resolver = __esm({
         const registryEntry = this.resolveRegistryEntry(receiver, name, pos);
         if (registryEntry) return registryEntry;
         if (receiver.indexSurface) {
-          const index = (this.context.project.listIndexes ?? []).find(
-            (candidate) => candidate.listMemberId === receiver.indexSurface?.listMemberId && candidate.name === name
+          const surface = receiver.indexSurface;
+          const declared = this.indexesFor(surface).find(
+            (candidate) => candidate.name === name
           );
-          if (!index) {
+          if (!declared) {
             throw new CompileError(
               `List index surface has no declared index '${name}'.`,
               pos
             );
           }
-          const viewValueType = index.unique ? index.valueType : {
+          const index = {
+            ...declared,
+            keyType: this.boundIndexKeyType(declared, surface.elementType),
+            valueType: surface.elementType
+          };
+          const viewValueType = index.unique ? { ...index.valueType, nullable: true } : {
             kind: "list",
             elementType: { ...index.valueType, nullable: false },
             readOnly: true
@@ -9309,10 +9333,7 @@ var init_strict_resolver = __esm({
             indexCollectionPointer: receiver.pointer
           };
         }
-        const receiverListMemberId = receiver.type.kind === "list" ? receiver.type.listMemberId : void 0;
-        if (receiver.type.kind === "list" && name === "Index" && receiverListMemberId && (this.context.project.listIndexes ?? []).some(
-          (candidate) => candidate.listMemberId === receiverListMemberId
-        )) {
+        if (receiver.type.kind === "list" && name === "Index" && this.indexesFor(receiver.type).length > 0) {
           return {
             pointer: receiver.pointer,
             type: { kind: "primitive", name: "unknown" },
@@ -9462,6 +9483,23 @@ var init_strict_resolver = __esm({
           pos
         );
       }
+      boundIndexKeyType(index, entryType) {
+        const entry = neoScriptMemberLookupType(entryType);
+        if (entry.kind !== "named") return index.keyType;
+        const declaring = this.project.typeById.get(entry.typeId);
+        if (!declaring) return index.keyType;
+        const key = declaring.members.find((member) => member.name === index.name);
+        return substituteTypeParameters(
+          key?.type ?? index.keyType,
+          entry,
+          declaring
+        );
+      }
+      /** The indexes declared on a schema-backed List, keyed by its member. */
+      indexesFor(type) {
+        if (type.listMemberId === void 0) return [];
+        return this.project.indexesByListMemberId.get(type.listMemberId) ?? [];
+      }
       /**
        * P42 §2.3. `Images.<Name>` / `AudioClips.<Name>`.
        *
@@ -10341,7 +10379,8 @@ var init_strict_resolver = __esm({
                 receiver: { kind: "ident", name, pos: entry.pos }
               }
             },
-            initializerScope
+            initializerScope,
+            "initializer"
           );
           if (assignment.type !== "assign" /* Assign */) {
             throw new CompileError(
@@ -16354,6 +16393,28 @@ function effectiveSourceAccessModifier(modifiers, ownerKind) {
   if (explicit !== void 0) return explicit;
   return ownerKind === "interface" ? "public" : "private";
 }
+function sourceMemberKeyArgument(annotation2) {
+  const positional = annotation2.arguments[0];
+  const argument2 = annotation2.arguments.find((entry) => entry.name === "member") ?? (positional !== void 0 && positional.name === void 0 ? positional : void 0);
+  if (argument2 === void 0) return null;
+  const text = argument2.text.trim();
+  return {
+    key: /^[A-Za-z_][A-Za-z0-9_]*$/.test(text) ? text : null,
+    range: argument2.range
+  };
+}
+function* sourceListIndexAnnotations(annotations) {
+  for (const annotation2 of annotations) {
+    if (annotation2.name !== "index") continue;
+    const key = sourceMemberKeyArgument(annotation2)?.key;
+    if (!key) continue;
+    yield {
+      key,
+      unique: annotation2.arguments.find((argument2) => argument2.name === "kind")?.text.trim() === ".Unique",
+      annotation: annotation2
+    };
+  }
+}
 var init_project_source_ast = __esm({
   "../packages/neoscript-language/src/project-source-ast.ts"() {
     "use strict";
@@ -22751,7 +22812,7 @@ function validateMember(uri, member, ownerName, documentKind, ownerScope, enviro
   );
   validateTypeAnnotations(uri, member.type, environment, diagnostics);
   if (documentKind !== "flow") {
-    validateListAnnotations(uri, member, environment, diagnostics);
+    validateListAnnotations(uri, member, ownerName, environment, diagnostics);
   }
   const scope = new Map(ownerScope);
   if (member.kind === "function") {
@@ -23965,14 +24026,21 @@ function anchorPosition(anchor, offset) {
   return { line: anchor.start.line + line, character };
 }
 function sourceClassFieldByName(declaration, name, environment, initialBindings = /* @__PURE__ */ new Map()) {
+  const resolved = sourceClassMemberByName(
+    declaration,
+    name,
+    environment,
+    initialBindings
+  );
+  return resolved?.member.kind === "field" ? resolved : void 0;
+}
+function sourceClassMemberByName(declaration, name, environment, initialBindings = /* @__PURE__ */ new Map()) {
   const visited = /* @__PURE__ */ new Set();
   let current = declaration;
   let bindings = initialBindings;
   while (current !== void 0 && !visited.has(current.name)) {
     visited.add(current.name);
-    const member = current.members.find(
-      (candidate) => candidate.kind === "field" && candidate.name === name
-    );
+    const member = current.members.find((candidate) => candidate.name === name);
     if (member !== void 0) return { member, bindings };
     const base = current.baseTypes.find(
       (candidate) => environment.types.has(candidate.name)
@@ -24202,20 +24270,17 @@ function semanticMemberType(member, environment, bindings = /* @__PURE__ */ new
   if (type.name !== "List") return type;
   const entryType = type.arguments?.[0];
   if (!entryType) return type;
-  const entryClass = environment.types.get(entryType.name);
-  if (!entryClass) return type;
   const indexes2 = /* @__PURE__ */ new Map();
-  for (const annotation2 of member.annotations) {
-    if (annotation2.name !== "index") continue;
-    const key = memberKeyArgument(annotation2)?.key;
-    if (!key) continue;
-    const field = resolveEntryField(entryClass, key, environment);
+  for (const index of sourceListIndexAnnotations(member.annotations)) {
+    const field = sourceClassMemberForType(entryType, index.key, environment);
     if (!field) continue;
-    const unique = contextualAnnotationEnum([annotation2], "index", "kind") === "Unique";
-    const valueType = unique ? { ...entryType, nullable: true } : { name: "List", arguments: [{ ...entryType, nullable: false }] };
-    indexes2.set(key, {
+    const valueType = index.unique ? { ...entryType, nullable: true } : { name: "List", arguments: [{ ...entryType, nullable: false }] };
+    indexes2.set(index.key, {
       name: "Dictionary",
-      arguments: [semanticType(field.type), valueType]
+      arguments: [
+        substituteSemanticType(semanticType(field.member.type), field.bindings),
+        valueType
+      ]
     });
   }
   return indexes2.size === 0 ? type : { ...type, listIndexes: indexes2 };
@@ -24449,15 +24514,18 @@ function contextualAnnotationEnum(annotations, name, field) {
   const value = annotations.find((annotation2) => annotation2.name === name)?.arguments.find((argument2) => argument2.name === field)?.text.trim();
   return value?.startsWith(".") ? value.slice(1) : null;
 }
-function validateListAnnotations(uri, member, environment, diagnostics) {
+function validateListAnnotations(uri, member, ownerName, environment, diagnostics) {
   const declared = member.annotations.filter(
     (annotation2) => annotation2.name === "index" || annotation2.name === "column"
   );
   if (declared.length === 0) return;
-  const entryClass = listEntryClass(member.type, environment);
+  const entryType = listEntryType(
+    member.type,
+    environment.types.get(ownerName)
+  );
   const seen = /* @__PURE__ */ new Set();
   for (const annotation2 of declared) {
-    const target = memberKeyArgument(annotation2);
+    const target = sourceMemberKeyArgument(annotation2);
     if (target === null) {
       pushDiagnostic(
         diagnostics,
@@ -24492,20 +24560,25 @@ function validateListAnnotations(uri, member, environment, diagnostics) {
     if (annotation2.name === "column" && target.key === LIST_COLUMN_INHERITANCE_KEY) {
       continue;
     }
-    if (entryClass === null) continue;
-    const field = resolveEntryField(entryClass, target.key, environment);
-    if (field === null) {
+    if (entryType === null) continue;
+    if (!environment.types.has(entryType.name)) continue;
+    const field = sourceClassMemberForType(entryType, target.key, environment);
+    if (field === void 0) {
       pushDiagnostic(
         diagnostics,
         uri,
         target.range,
         "unresolved-list-annotation-member",
-        `@${annotation2.name}(member: ${target.key}) on '${member.name}' does not resolve on list entry class '${entryClass.name}'.`
+        `@${annotation2.name}(member: ${target.key}) on '${member.name}' does not resolve on list entry class '${entryType.name}'.`
       );
       continue;
     }
     if (annotation2.name !== "index") continue;
-    const domainError = indexKeyDomainError(field, environment);
+    const domainError = indexKeyDomainError(
+      field.member,
+      substituteSemanticType(semanticType(field.member.type), field.bindings),
+      environment
+    );
     if (domainError !== null) {
       pushDiagnostic(
         diagnostics,
@@ -24517,46 +24590,45 @@ function validateListAnnotations(uri, member, environment, diagnostics) {
     }
   }
 }
-function memberKeyArgument(annotation2) {
-  const positional = annotation2.arguments[0];
-  const argument2 = annotation2.arguments.find((entry) => entry.name === "member") ?? (positional !== void 0 && positional.name === void 0 ? positional : void 0);
-  if (argument2 === void 0) return null;
-  const text = argument2.text.trim();
-  return {
-    key: IDENTIFIER_PATTERN.test(text) ? text : null,
-    range: argument2.range
-  };
-}
-function listEntryClass(type, environment) {
+function listEntryType(type, owner) {
   if (type.name !== "List" && type.name !== "Set") return null;
-  const entry = type.typeArguments[0];
-  if (entry === void 0) return null;
-  return environment.types.get(entry.name) ?? null;
-}
-function resolveEntryField(entryClass, key, environment) {
+  let entry = type.typeArguments[0];
   const visited = /* @__PURE__ */ new Set();
-  let current = entryClass;
-  while (current !== void 0 && !visited.has(current.name)) {
-    visited.add(current.name);
-    const match = current.members.find((entry) => entry.name === key);
-    if (match !== void 0) return match;
-    current = current.baseTypes.map((base) => environment.types.get(base.name)).find((base) => base !== void 0);
+  while (entry !== void 0) {
+    const name = entry.name;
+    const parameter4 = owner?.genericParameters.find(
+      (candidate) => candidate.name === name
+    );
+    if (!parameter4) return semanticType(entry);
+    if (visited.has(parameter4.name)) return null;
+    visited.add(parameter4.name);
+    entry = parameter4.constraint;
   }
   return null;
 }
-function indexKeyDomainError(field, environment) {
+function sourceClassMemberForType(type, name, environment) {
+  const declaration = environment.types.get(type.name);
+  if (!declaration) return void 0;
+  const bindings = /* @__PURE__ */ new Map();
+  for (const [index, parameter4] of declaration.genericParameters.entries()) {
+    const argument2 = type.arguments?.[index];
+    if (argument2) bindings.set(parameter4.name, argument2);
+  }
+  return sourceClassMemberByName(declaration, name, environment, bindings);
+}
+function indexKeyDomainError(field, type, environment) {
   if (field.kind !== "field") {
     return `'${field.name}' is a ${field.kind}, and index keys require a stored field`;
   }
-  if (field.type.name === "string") {
+  if (type.name === "string") {
     return annotationEnumOption(field.annotations, "settings", "format") === "Plain" ? null : `'${field.name}' is localized, and String index keys must be plain`;
   }
-  if (environment.enums.has(field.type.name)) return null;
-  const entry = field.type.typeArguments[0];
-  if (field.type.name === "List" && entry !== void 0 && environment.enums.has(entry.name) && annotationEnumOption(field.annotations, "settings", "selection") === "Multi") {
+  if (environment.enums.has(type.name)) return null;
+  const entry = type.arguments?.[0];
+  if (type.name === "List" && entry !== void 0 && environment.enums.has(entry.name) && annotationEnumOption(field.annotations, "settings", "selection") === "Multi") {
     return `'${field.name}' is a multi-select Enum, and index keys require a single-select Enum`;
   }
-  return `'${field.name}' is a ${field.type.name} field, and index keys require a plain String or a single-select Enum`;
+  return `'${field.name}' is a ${type.name} field, and index keys require a plain String or a single-select Enum`;
 }
 function annotationEnumOption(annotations, name, field) {
   const value = annotations.find((annotation2) => annotation2.name === name)?.arguments.find((argument2) => argument2.name === field)?.text.trim();
@@ -24711,10 +24783,11 @@ function classDerivesFromName(name, ancestorName, environment, seen = /* @__PURE
     return classDerivesFromName(base.name, ancestorName, environment, seen);
   });
 }
-var NEO_VARIANT_FOLDER_SETTING, primitiveType, IDENTIFIER_PATTERN, LIST_COLUMN_INHERITANCE_KEY, SEMANTIC_PRIMITIVE_TYPE_NAMES;
+var NEO_VARIANT_FOLDER_SETTING, primitiveType, LIST_COLUMN_INHERITANCE_KEY, SEMANTIC_PRIMITIVE_TYPE_NAMES;
 var init_project_source_semantics = __esm({
   "../packages/neoscript-language/src/project-source-semantics.ts"() {
     "use strict";
+    init_project_source_ast();
     init_project_local_values();
     init_language_spec();
     init_project_schema_contract_generated();
@@ -24727,7 +24800,6 @@ var init_project_source_semantics = __esm({
     init_project_root();
     NEO_VARIANT_FOLDER_SETTING = "folder";
     primitiveType = (name) => ({ name });
-    IDENTIFIER_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
     LIST_COLUMN_INHERITANCE_KEY = "__other__";
     SEMANTIC_PRIMITIVE_TYPE_NAMES = /* @__PURE__ */ new Set([
       "bool",
@@ -25326,8 +25398,29 @@ function buildProjectGraph(documents) {
       writable: false
     });
   }
+  const listIndexes2 = [];
+  for (const { member, symbol, uri } of memberInfo.values()) {
+    if (symbol.type.kind !== "list") continue;
+    const entryType = symbol.type.elementType;
+    const entrySchema = neoScriptMemberLookupType(entryType);
+    if (entrySchema.kind !== "named") continue;
+    const entryMembers = effectiveMembers.get(entrySchema.typeId);
+    for (const index of sourceListIndexAnnotations(member.annotations)) {
+      const key = entryMembers?.find((field) => field.name === index.key);
+      if (key === void 0) continue;
+      listIndexes2.push({
+        id: `${symbol.id}:index:${key.name}`,
+        listMemberId: symbol.id,
+        name: key.name,
+        keyType: key.type,
+        valueType: entryType,
+        unique: index.unique,
+        location: location(uri, index.annotation.range)
+      });
+    }
+  }
   return {
-    project: { version: 1, types, globals, roots },
+    project: { version: 1, types, globals, roots, listIndexes: listIndexes2 },
     declarationsByName,
     typeIdsByName: typeIds,
     memberInfo
@@ -25338,7 +25431,8 @@ function sourceMemberSymbol(member, owner, typeIds, source) {
     member.annotations,
     `member:${owner.id}:${member.name}`
   );
-  const type = sourceTypeRef(member.type, owner, typeIds);
+  const declaredType = sourceTypeRef(member.type, owner, typeIds);
+  const type = declaredType.kind === "list" ? { ...declaredType, listMemberId: id2 } : declaredType;
   const staticMember = member.modifiers.includes("static");
   const readonlyDeclaration = member.modifiers.includes("readonly");
   const common = {
@@ -71294,6 +71388,33 @@ function exportInitializerCollections(created, writes, ctx) {
   });
   return [...exported, ...extra];
 }
+function prepareSessionValueExport(ctx, checkpoint, writes) {
+  const created = createdSessionValuesSince(ctx, checkpoint);
+  if (created.length === 0) return;
+  const invocationWrites = ctx.__executionState?.writes ?? writes;
+  const exported = exportInitializerCollections(
+    created,
+    invocationWrites === writes || writes.length === 0 ? invocationWrites : [...invocationWrites, ...writes],
+    ctx
+  );
+  if (exported === created) return;
+  const replacements = /* @__PURE__ */ new Map();
+  for (const row of exported) {
+    const existing = ctx.__runtimeSessionValues?.get(row.id);
+    if (existing === void 0) registerRuntimeSessionValue(ctx, row);
+    else if (existing !== row) replacements.set(row.id, row);
+  }
+  return replacements;
+}
+function exportedSessionValuesSince(ctx, checkpoint, replacements) {
+  const created = createdSessionValuesSince(ctx, checkpoint);
+  if (replacements !== void 0) {
+    for (const [index, row] of created.entries()) {
+      created[index] = replacements.get(row.id) ?? row;
+    }
+  }
+  return created;
+}
 function evaluateNSGetter(getter, ctx) {
   return evaluateNSGetterWithEffects(getter, ctx).value;
 }
@@ -71358,19 +71479,20 @@ function evaluateNSGetterWithEffects(getter, ctx, argumentValues = [], options =
         const rootIndex = created.findIndex(
           (row) => row.value === result.value
         );
-        const exported = exportInitializerCollections(
+        const exported2 = exportInitializerCollections(
           created,
           writes,
           runtimeCtx
         );
-        if (exported !== created) {
-          for (const row of exported)
+        if (exported2 !== created) {
+          for (const row of exported2)
             registerRuntimeSessionValue(runtimeCtx, row);
           invalidateEvaluatorIndexes(runtimeCtx, null);
         }
-        const exportedRoot = exported[rootIndex];
+        const exportedRoot = exported2[rootIndex];
         if (exportedRoot !== void 0) result.value = exportedRoot.value;
       }
+      const exported = !options.exportInitializerValues && options.sessionValueExport !== "defer" ? prepareSessionValueExport(runtimeCtx, creationCheckpoint, writes) : void 0;
       finalizeConstructorAllocations(
         runtimeCtx,
         result.value,
@@ -71378,9 +71500,10 @@ function evaluateNSGetterWithEffects(getter, ctx, argumentValues = [], options =
         getter.typeInfo
       );
       result.value = preserveReadOnlyReturnIdentity(result.value, runtimeCtx);
-      const createdSessionValues = createdSessionValuesSince(
+      const createdSessionValues = exportedSessionValuesSince(
         runtimeCtx,
-        creationCheckpoint
+        creationCheckpoint,
+        exported
       );
       return createdSessionValues.length === 0 ? { value: result.value, writes } : { value: result.value, writes, createdSessionValues };
     }
@@ -71399,6 +71522,7 @@ function evaluateNSVoidBody(action, ctx) {
   consumeBudget(runtimeCtx, "workUnits", 1, "work unit");
   const creationCheckpoint = sessionCreationCheckpoint(runtimeCtx);
   const scope = createTopLevelScope(runtimeCtx);
+  let exported;
   try {
     const result = evalInstructions(action.instructions, scope, runtimeCtx, {
       allowFallthroughReturn: true,
@@ -71412,14 +71536,20 @@ function evaluateNSVoidBody(action, ctx) {
       }
     }
     rejectEscapedLoopTransfer(result, "NeoScript action");
+    exported = prepareSessionValueExport(
+      runtimeCtx,
+      creationCheckpoint,
+      writes
+    );
     finalizeConstructorAllocations(runtimeCtx, void 0, ownsInvocationState);
   } catch (error) {
     finalizeConstructorAllocations(runtimeCtx, void 0, ownsInvocationState);
     throw error;
   }
-  const createdSessionValues = createdSessionValuesSince(
+  const createdSessionValues = exportedSessionValuesSince(
     runtimeCtx,
-    creationCheckpoint
+    creationCheckpoint,
+    exported
   );
   return createdSessionValues.length === 0 ? { writes } : { writes, createdSessionValues };
 }
@@ -71431,6 +71561,7 @@ function evaluateNSFunction(action, ctx, args) {
   const creationCheckpoint = sessionCreationCheckpoint(runtimeCtx);
   const runtimeArgs = remapRuntimeArguments(args, runtimeCtx);
   let value;
+  let exported;
   try {
     value = executeCompiledFunction(
       action,
@@ -71438,6 +71569,11 @@ function evaluateNSFunction(action, ctx, args) {
       runtimeArgs,
       action.typeInfo.type === 0 /* Null */
     );
+    exported = prepareSessionValueExport(
+      runtimeCtx,
+      creationCheckpoint,
+      writes
+    );
     finalizeConstructorAllocations(
       runtimeCtx,
       value,
@@ -71448,9 +71584,10 @@ function evaluateNSFunction(action, ctx, args) {
     finalizeConstructorAllocations(runtimeCtx, void 0, ownsInvocationState);
     throw error;
   }
-  const createdSessionValues = createdSessionValuesSince(
+  const createdSessionValues = exportedSessionValuesSince(
     runtimeCtx,
-    creationCheckpoint
+    creationCheckpoint,
+    exported
   );
   return createdSessionValues.length === 0 ? { value, writes } : { value, writes, createdSessionValues };
 }
@@ -74686,10 +74823,15 @@ function dispatchNSGetterById(memberId, receiver, ctx) {
   }
   const innerStack = new Set(stack);
   innerStack.add(memberId);
-  return evaluateNSGetter(getter, {
-    ...bindThisValue(ctx, receiver),
-    __getterCallStack: innerStack
-  });
+  return evaluateNSGetterWithEffects(
+    getter,
+    {
+      ...bindThisValue(ctx, receiver),
+      __getterCallStack: innerStack
+    },
+    [],
+    { sessionValueExport: "defer" }
+  ).value;
 }
 function resolveCompiledGetter(memberId, ctx) {
   const cache = evaluatorResolutionCache(ctx).compiledGetterByMemberId;
@@ -78015,7 +78157,10 @@ function evaluateInitializerInContext(init, member, ctx, createdValues, argument
       compiled,
       initializerCtx,
       argumentValues,
-      { initializerResult: { member, genericEnv } }
+      {
+        initializerResult: { member, genericEnv },
+        sessionValueExport: "defer"
+      }
     );
   } finally {
     closeFrame();
@@ -79953,15 +80098,22 @@ function cloneClassValueGraph(receiver, expectedClassId, ctx) {
   }
   const active = /* @__PURE__ */ new Set();
   const clonedBySourceId = /* @__PURE__ */ new Map();
-  const constructorArgumentReferenceCounts = /* @__PURE__ */ new Map();
   ctx.onUnattributableValueRead?.(`class-clone:${sourceId3}`);
-  for (const candidate of evaluatorValues(ctx)) {
-    for (const argument2 of ownedConstructorArgumentValues(candidate, ctx)) {
-      constructorArgumentReferenceCounts.set(
-        argument2.id,
-        (constructorArgumentReferenceCounts.get(argument2.id) ?? 0) + 1
-      );
+  const constructorArgumentCandidates = evaluatorValues(ctx);
+  let constructorArgumentReferenceCounts = null;
+  function constructorArgumentReferenceCount(valueId) {
+    if (constructorArgumentReferenceCounts === null) {
+      constructorArgumentReferenceCounts = /* @__PURE__ */ new Map();
+      for (const candidate of constructorArgumentCandidates) {
+        for (const argument2 of ownedConstructorArgumentValues(candidate, ctx)) {
+          constructorArgumentReferenceCounts.set(
+            argument2.id,
+            (constructorArgumentReferenceCounts.get(argument2.id) ?? 0) + 1
+          );
+        }
+      }
     }
+    return constructorArgumentReferenceCounts.get(valueId) ?? 0;
   }
   function cloneInitializerRow(sourceRow, sourceMember, id2, clonedContainerId, sourceTypeInfo) {
     if (sourceMember === null) {
@@ -80154,7 +80306,6 @@ function cloneClassValueGraph(receiver, expectedClassId, ctx) {
           constructorArgs[argument2.parameterId] = alreadyCloned.id;
           continue;
         }
-        if (constructorArgumentReferenceCounts.get(argument2.id) !== 1) continue;
         const argumentRow = evalValueById(
           ctx,
           argument2.id,
@@ -80165,6 +80316,7 @@ function cloneClassValueGraph(receiver, expectedClassId, ctx) {
         if (activeStaticBindingRoot(argument2.id, ctx) !== null || memberForValueRow(argumentRow, ctx) !== null) {
           continue;
         }
+        if (constructorArgumentReferenceCount(argument2.id) !== 1) continue;
         constructorArgs[argument2.parameterId] = cloneRow2(
           argumentRow,
           null,
@@ -83106,7 +83258,7 @@ function rewriteExpandedRow(node, expansion) {
   const rewrite = (id2) => expansion.nodesByExpandedId.get(id2)?.virtualId ?? id2;
   const row = cloneRow(node.expandedRow);
   row.id = node.virtualId;
-  if (isMemberClassBase(node.member) || isMemberDictionaryBase(node.member)) {
+  if (row.value !== null && (isMemberClassBase(node.member) || isMemberDictionaryBase(node.member))) {
     row.value = Object.fromEntries(
       Object.entries(stringRecord2(row.value)).map(([key, childId]) => [
         key,
@@ -109271,7 +109423,7 @@ function inheritedMember(context, memberId) {
 function lowerListIndexes(ownerClass, declaration) {
   const declared = /* @__PURE__ */ new Set();
   return declaration.annotations.filter((entry) => entry.name === "index").map((entry) => {
-    const schemaKey = memberKeyArgument2(entry, ownerClass, declaration);
+    const schemaKey = memberKeyArgument(entry, ownerClass, declaration);
     if (declared.has(schemaKey)) {
       throw new Error(
         `@index(member: ${schemaKey}) is declared more than once on ${ownerClass.name}.${declaration.name}.`
@@ -109287,7 +109439,7 @@ function lowerListIndexes(ownerClass, declaration) {
 function lowerListColumns(ownerClass, declaration) {
   const declared = /* @__PURE__ */ new Set();
   return declaration.annotations.filter((entry) => entry.name === "column").map((entry) => {
-    const memberKey = memberKeyArgument2(entry, ownerClass, declaration);
+    const memberKey = memberKeyArgument(entry, ownerClass, declaration);
     if (declared.has(memberKey)) {
       throw new Error(
         `@column(member: ${memberKey}) is declared more than once on ${ownerClass.name}.${declaration.name}.`
@@ -109306,7 +109458,7 @@ function lowerListColumns(ownerClass, declaration) {
     };
   });
 }
-function memberKeyArgument2(value, ownerClass, declaration) {
+function memberKeyArgument(value, ownerClass, declaration) {
   const positional = value.arguments[0];
   const raw = argument(value, "member") ?? (positional !== void 0 && positional.name === void 0 ? positional.expression : null);
   if (raw === null) {
@@ -138565,7 +138717,7 @@ var init_registry2 = __esm({
   "schema-contract/registry.mjs"() {
     "use strict";
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
-      cliVersion: "0.53.2",
+      cliVersion: "0.53.3",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -146386,7 +146538,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.53.2");
+    console.log("0.53.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.53.2",
+  "version": "0.53.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.53.2 -->
+<!-- reviewed-through-cli: 0.53.3 -->
 
 # Neo Compose CLI
 

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

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

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

@@ -334,3 +334,5 @@ class PlacedItem<
   public TData Data = item.DefaultData.Clone();
 }
 ```
+
+Executable object initializer blocks can set immutable stored members on the newly constructed instance, including nested `new` expressions. Ordinary assignments after construction remain subject to storage restrictions. `readonly` declarations still change only through class defaults.