@neocompose/cli 0.52.3 → 0.52.5

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## [0.52.5] - 2026-09-17
+
+- Materialize computed collection defaults, including `List.Repeat<T?>(null, count)`, as stored entries when seeding new instances.
+
+## [0.52.4] - 2026-09-17
+
+- Accept declared list-index lookups in constructor arguments, including readable string keys such as `root.Assets.Items.Index.Slug["stone"]!`.
+- Convert session-constructed tiles with either `TryConvert` overload, preserving their identity and Cell, and persist their final class in migrations.
+- Allow object initializers in executable NeoScript and specs. Construct first, then apply entries in order using ordinary assignment rules, including property setters and readonly checks.
+- Encode constructor-assigned collections as value rows when exporting initializers so seeding an Assets list preserves existing NeoCellPattern values. List-shape errors name the list kind.
+
 ## [0.52.3] - 2026-09-17
 
 - Replay stored collection constructor arguments as typed literals, including evaluated NeoCellPattern values.

package/dist/neo.mjs

@@ -6401,6 +6401,7 @@ var init_strict_resolver = __esm({
       callSiteCounter = 0;
       lambdaDepth = 0;
       delegateClosureCounter = 0;
+      objectInitializerCounter = 0;
       delegateCaptureContexts = [];
       sourceTokens;
       source;
@@ -8013,6 +8014,14 @@ var init_strict_resolver = __esm({
               expression.pos
             );
             const declaredTarget = this.project.typeByName.get(className);
+            if (declaredTarget?.kind === "class" && (expression.initializer?.length ?? 0) > 0 && this.context.storedConstructionReplay !== true) {
+              return this.resolveExecutableObjectInitializer(
+                declaredTarget,
+                expression,
+                scope,
+                expected
+              );
+            }
             const declared = declaredTarget?.declaredConstructors ?? [];
             const requiredConstructor = neoScriptRequiredConstructor(declaredTarget);
             const generatedPositionalCall = requiredConstructor === null && declaredTarget?.constructorSignature !== void 0 && expression.argumentNames === void 0 && callHasPositionalArguments(expression);
@@ -8031,12 +8040,6 @@ var init_strict_resolver = __esm({
                 expression.pos
               );
             }
-            if (expression.initializer && expression.initializer.length > 0 && !generatedPositionalCall && this.context.storedConstructionReplay !== true) {
-              throw new CompileError(
-                "Object initializers are available to project source construction and are not executable NeoScript constructors.",
-                expression.pos
-              );
-            }
             return this.resolveClassConstructor(
               className,
               expression,
@@ -10263,6 +10266,75 @@ var init_strict_resolver = __esm({
           type: optional2 ? { ...delegateType.returnType, nullable: true } : delegateType.returnType
         };
       }
+      resolveExecutableObjectInitializer(schemaClass2, expression, scope, expected) {
+        const constructed = this.resolveExpression(
+          { ...expression, className: schemaClass2.name, initializer: [] },
+          scope,
+          expected
+        );
+        const name = `$initialized_${this.objectInitializerCounter++}`;
+        const receiver = variable(
+          name,
+          constructed.type,
+          constructed.pointer,
+          this.project
+        );
+        const initializerScope = new Scope(scope);
+        initializerScope.define(
+          scopeVariable(
+            name,
+            receiver,
+            constructed.type,
+            "local" /* Local */,
+            "session" /* Session */,
+            "local"
+          )
+        );
+        const assignments = [];
+        const seen = /* @__PURE__ */ new Set();
+        for (const entry of expression.initializer ?? []) {
+          const key = entry.name.toLowerCase();
+          if (seen.has(key)) {
+            throw new CompileError(
+              `Object initializer sets '${entry.name}' more than once.`,
+              entry.pos
+            );
+          }
+          seen.add(key);
+          const assignment = this.resolveAssignment(
+            {
+              kind: "assign",
+              op: "=",
+              pos: entry.pos,
+              value: entry.value,
+              target: {
+                kind: "member",
+                name: entry.name,
+                pos: entry.pos,
+                receiver: { kind: "ident", name, pos: entry.pos }
+              }
+            },
+            initializerScope
+          );
+          if (assignment.type !== "assign" /* Assign */) {
+            throw new CompileError(
+              "Object initializer entries must be assignments.",
+              entry.pos
+            );
+          }
+          assignments.push(assignment);
+        }
+        return {
+          pointer: {
+            type: "objectInitializer" /* ObjectInitializer */,
+            receiver,
+            assignments
+          },
+          type: constructed.type,
+          writability: "session" /* Session */,
+          writeRoot: "local"
+        };
+      }
       resolveClassConstructor(className, expression, scope, pos, expected) {
         const schemaClass2 = this.project.typeByName.get(className);
         if (!schemaClass2 || schemaClass2.kind !== "class") {
@@ -12371,11 +12443,7 @@ var init_strict_resolver = __esm({
        */
       localWriteTargetRoot(initial, scope) {
         if (this.context.kind !== "constructor") return "local";
-        if (initial.pointer.type === "function" /* Function */) {
-          return CONSTRUCTING_FUNCTION_KINDS.has(initial.pointer.function.type) ? "local" : "unknown";
-        }
-        if (initial.pointer.type === "value" /* Value */) return "local";
-        return this.writeThroughRoot(initial.pointer, scope);
+        return this.expressionWriteRoot(initial, scope);
       }
       validateCallableInContext(symbol, pos) {
         if (symbol.native === true && !NEO_CELL_PATTERN_PURE_NATIVE_MEMBER_IDS.has(symbol.id) && isNeoScriptConstructionDocumentKind(this.context.kind)) {
@@ -22364,7 +22432,7 @@ function validateDeclaration(uri, declaration, documentKind, environment, diagno
     }
   }
   for (const member of declaration.members) {
-    scope.set(member.name, semanticType(member.type));
+    scope.set(member.name, semanticMemberType(member, environment));
   }
   for (const member of declaration.members) {
     validateMember(
@@ -23748,7 +23816,7 @@ function validateExpression(expression, expected, scope, environment, uri, range
   if (expression.kind === "unary" || expression.kind === "force") {
     validateExpression(
       expression.operand,
-      expected,
+      expression.kind === "force" && expected ? { ...expected, nullable: true } : expected,
       scope,
       environment,
       uri,
@@ -23780,7 +23848,9 @@ function validateExpression(expression, expected, scope, environment, uri, range
     );
     validateExpression(
       expression.index,
-      primitiveType("int"),
+      subscriptKeyType(
+        inferExpressionType2(expression.receiver, scope, environment)
+      ),
       scope,
       environment,
       uri,
@@ -23867,10 +23937,10 @@ function anchorPosition(anchor, offset) {
   }
   return { line: anchor.start.line + line, character };
 }
-function sourceClassFieldByName(declaration, name, environment) {
+function sourceClassFieldByName(declaration, name, environment, initialBindings = /* @__PURE__ */ new Map()) {
   const visited = /* @__PURE__ */ new Set();
   let current = declaration;
-  let bindings = /* @__PURE__ */ new Map();
+  let bindings = initialBindings;
   while (current !== void 0 && !visited.has(current.name)) {
     visited.add(current.name);
     const member = current.members.find(
@@ -24013,6 +24083,21 @@ function inferExpressionType2(expression, scope, environment) {
     return primitiveType("string");
   if (expression.kind === "new")
     return expression.className ? { name: expression.className } : void 0;
+  if (expression.kind === "force") {
+    const operand = inferExpressionType2(expression.operand, scope, environment);
+    return operand ? { ...operand, nullable: false } : void 0;
+  }
+  if (expression.kind === "index") {
+    const receiver = inferExpressionType2(
+      expression.receiver,
+      scope,
+      environment
+    );
+    if (receiver?.name !== "Dictionary" && receiver?.name !== "List")
+      return void 0;
+    const value = receiver.arguments?.[receiver.name === "Dictionary" ? 1 : 0];
+    return expression.optional && value ? { ...value, nullable: true } : value;
+  }
   if (expression.kind === "conditional") {
     const whenTrue = inferExpressionType2(
       expression.whenTrue,
@@ -24030,15 +24115,48 @@ function inferExpressionType2(expression, scope, environment) {
     if (expression.receiver.kind === "ident" && environment.enums.has(expression.receiver.name)) {
       return { name: expression.receiver.name };
     }
-    const receiver = inferExpressionType2(
+    const receiverType = inferExpressionType2(
       expression.receiver,
       scope,
       environment
     );
+    const staticDeclaration = receiverType === void 0 && expression.receiver.kind === "ident" ? environment.types.get(expression.receiver.name) : void 0;
+    const receiver = receiverType ?? (staticDeclaration ? { name: staticDeclaration.name } : void 0);
+    if (receiver?.name === "Root") {
+      const slot = PROJECT_ROOT_SOURCE_SLOTS.find(
+        (slot2) => slot2.name === expression.name
+      );
+      return slot ? { name: slot.type } : void 0;
+    }
+    if (receiver?.name === "List" && receiver.listIndexes && expression.name === "Index") {
+      return { name: "Index", listIndexes: receiver.listIndexes };
+    }
+    if (receiver?.name === "Index" && receiver.listIndexes)
+      return receiver.listIndexes.get(expression.name);
     const declaration = receiver ? environment.types.get(receiver.name) : void 0;
-    const member = declaration?.members.find(
+    if (!declaration) return void 0;
+    const bindings = new Map(
+      declaration.genericParameters.flatMap((parameter4, index) => {
+        const argument2 = receiver?.arguments?.[index];
+        return argument2 ? [[parameter4.name, argument2]] : [];
+      })
+    );
+    const field = sourceClassFieldByName(
+      declaration,
+      expression.name,
+      environment,
+      bindings
+    );
+    if (field) {
+      if (staticDeclaration && !field.member.modifiers.includes("static"))
+        return void 0;
+      return semanticMemberType(field.member, environment, field.bindings);
+    }
+    const member = declaration.members.find(
       (candidate) => candidate.name === expression.name
     );
+    if (staticDeclaration && !member?.modifiers.includes("static"))
+      return void 0;
     return member ? semanticType(member.type) : void 0;
   }
   if (expression.kind === "call" && expression.callee.kind === "ident") {
@@ -24052,6 +24170,34 @@ function inferExpressionType2(expression, scope, environment) {
   }
   return void 0;
 }
+function semanticMemberType(member, environment, bindings = /* @__PURE__ */ new Map()) {
+  const type = substituteSemanticType(semanticType(member.type), bindings);
+  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);
+    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, {
+      name: "Dictionary",
+      arguments: [semanticType(field.type), valueType]
+    });
+  }
+  return indexes2.size === 0 ? type : { ...type, listIndexes: indexes2 };
+}
+function subscriptKeyType(receiver) {
+  if (receiver?.name === "Dictionary") return receiver.arguments?.[0];
+  if (receiver?.name === "List") return primitiveType("int");
+  return void 0;
+}
 function validateReferenceExpression(expression, expected, environment, uri, range2, diagnostics) {
   const typeArguments = expression.typeArguments ?? [];
   const names = expression.argumentNames ?? [];
@@ -45932,6 +46078,13 @@ function isNSPointerCallFunction(value) {
   }
   return true;
 }
+function isNSPointerObjectInitializer(value) {
+  if (typeof value !== "object" || value === null) return false;
+  if (!("type" in value) || value.type !== "objectInitializer" /* objectInitializer */)
+    return false;
+  if (!("receiver" in value) || !isNSVariable(value.receiver)) return false;
+  return "assignments" in value && Array.isArray(value.assignments) && value.assignments.every(isNSInstructionAssign);
+}
 function isNSPointerCallDelegate(value) {
   const v = value;
   if (v?.type !== "callDelegate" /* callDelegate */) return false;
@@ -45970,7 +46123,7 @@ function isNSPointerFunctionErrorCheck(value) {
   return isNSFunctionErrorCheckMode(v.mode);
 }
 function isNSPointer(value) {
-  return isNSPointerReference(value) || isNSPointerVariable(value) || isNSPointerStaticMember(value) || isNSPointerValue(value) || isNSPointerOperation(value) || isNSPointerFunction(value) || isNSPointerKeyOf(value) || isNSPointerListLiteral(value) || isNSPointerDictLiteral(value) || isNSPointerForceUnwrap(value) || isNSPointerIsCheck(value) || isNSPointerCallGetter(value) || isNSPointerCoalesce(value) || isNSPointerConditional(value) || isNSPointerDelegateClosure(value) || isNSPointerToBool(value) || isNSPointerStringify(value) || isNSPointerTileConvert(value) || isNSPointerCallFunction(value) || isNSPointerCallDelegate(value) || isNSPointerCallAction(value) || isNSPointerVariant(value) || isNSPointerFunctionErrorCheck(value);
+  return isNSPointerReference(value) || isNSPointerVariable(value) || isNSPointerStaticMember(value) || isNSPointerValue(value) || isNSPointerOperation(value) || isNSPointerFunction(value) || isNSPointerKeyOf(value) || isNSPointerListLiteral(value) || isNSPointerDictLiteral(value) || isNSPointerForceUnwrap(value) || isNSPointerIsCheck(value) || isNSPointerCallGetter(value) || isNSPointerCoalesce(value) || isNSPointerConditional(value) || isNSPointerDelegateClosure(value) || isNSPointerObjectInitializer(value) || isNSPointerToBool(value) || isNSPointerStringify(value) || isNSPointerTileConvert(value) || isNSPointerCallFunction(value) || isNSPointerCallDelegate(value) || isNSPointerCallAction(value) || isNSPointerVariant(value) || isNSPointerFunctionErrorCheck(value);
 }
 function isNSPointers(value) {
   return Array.isArray(value) && value.every(isNSPointer);
@@ -54907,7 +55060,8 @@ function evaluateLiteralContainer(args) {
   const evaluated = args.initEvaluator(
     args.member,
     body.init,
-    args.sourceValueId
+    args.sourceValueId,
+    args.genericEnv
   );
   const literal3 = {
     value: evaluated.value,
@@ -54960,6 +55114,7 @@ function buildDefaultMemberValue(args) {
   if (documentHasInitValueContent(args.document, declaredDefault)) {
     const initializerCreatedValuesStart = args.createdValues.length;
     const evaluated = evaluateLiteralContainer({
+      genericEnv: args.genericEnv,
       body: declaredDefault,
       member,
       initEvaluator: args.initEvaluator
@@ -54981,7 +55136,7 @@ function buildDefaultMemberValue(args) {
       value2.genericBindings = { ...evaluated.genericBindings };
     }
     if (evaluated.provisionalRootId !== void 0) {
-      retargetDelegateReceiverValueIds(
+      retargetInitializerRootValueIds(
         [value2, ...args.createdValues.slice(initializerCreatedValuesStart)],
         evaluated.provisionalRootId,
         value2.id
@@ -55283,7 +55438,7 @@ function buildNewValue(projectId, body, timestamp2 = Date.now()) {
   }
   return props;
 }
-function retargetDelegateReceiverValueIds(rows, fromValueId, toValueId) {
+function retargetInitializerRootValueIds(rows, fromValueId, toValueId) {
   const visited = /* @__PURE__ */ new WeakSet();
   const visit = (value) => {
     if (typeof value !== "object" || value === null) return;
@@ -55300,6 +55455,7 @@ function retargetDelegateReceiverValueIds(rows, fromValueId, toValueId) {
     for (const entry of Object.values(value)) visit(entry);
   };
   for (const row of rows) {
+    if (row.containerId === fromValueId) row.containerId = toValueId;
     if (!isLiteralValueContent(row)) continue;
     visit(row.value);
     visit(row.constructorArgs);
@@ -55429,6 +55585,7 @@ function cloneDefaultValueForMember(args) {
   if (documentHasInitValueContent(args.document, sourceValue)) {
     const initializerCreatedValuesStart = args.createdValues.length;
     const evaluated = evaluateLiteralContainer({
+      genericEnv: args.genericEnv,
       body: sourceValue,
       member,
       initEvaluator: args.initEvaluator,
@@ -55451,7 +55608,7 @@ function cloneDefaultValueForMember(args) {
       evaluatedRow.genericBindings = { ...evaluated.genericBindings };
     }
     if (evaluated.provisionalRootId !== void 0) {
-      retargetDelegateReceiverValueIds(
+      retargetInitializerRootValueIds(
         [
           evaluatedRow,
           ...args.createdValues.slice(initializerCreatedValuesStart)
@@ -71060,10 +71217,98 @@ function createdSessionValuesSince(ctx, checkpoint) {
   }
   return created;
 }
+function exportInitializerCollections(created, writes, ctx) {
+  const assignedValues = /* @__PURE__ */ new Set();
+  for (const write of writes) {
+    if (write.kind === "assign" && write.valueId === void 0 && typeof write.value === "object" && write.value !== null) {
+      assignedValues.add(write.value);
+    }
+  }
+  const candidates = /* @__PURE__ */ new Set();
+  for (const row of created) {
+    if (assignedValues.has(row.value) || Array.isArray(row.value) && row.value.length > 0 && ctx.__unorderedListProjections?.byContainerId.has(row.id)) {
+      candidates.add(row.id);
+    }
+  }
+  if (candidates.size === 0) return created;
+  invalidateEvaluatorIndexes(ctx, null);
+  const extra = [];
+  const exported = created.map((row) => {
+    if (!candidates.has(row.id)) return row;
+    const member = memberForValueRow(row, ctx);
+    if (member === null) return row;
+    if (!isMemberListBase(member) && !isMemberDictionaryBase(member))
+      return row;
+    if (isMemberListBase(member) && listKindOf(member) === 1 /* Unordered */) {
+      return { ...row, value: [] };
+    }
+    if (!assignedValues.has(row.value)) return row;
+    const values = [];
+    const declarations = /* @__PURE__ */ new Map();
+    const genericEnv = runtimeGenericEnvForValueRow(row, ctx, /* @__PURE__ */ new Set());
+    overlayConcreteGenericEntries(
+      genericEnv,
+      envFromStamp(row.genericBindings)
+    );
+    const materialized = materializeConstructorArgumentValue({
+      member,
+      value: row.value,
+      genericEnv,
+      ctx,
+      createdValues: values,
+      createdById: /* @__PURE__ */ new Map(),
+      storageKeyDeclarations: declarations,
+      collectionEntriesAreReferences: false,
+      collectionOwnerId: row.id
+    });
+    const encoded = { ...row, value: materialized.value };
+    const children = values.filter((value) => value !== materialized);
+    declarations.delete(materialized.id);
+    const groupId = constructorGroupForRow(row.id, ctx);
+    retargetConstructorGroupDependencies(
+      materialized.id,
+      groupId ?? row.id,
+      ctx
+    );
+    if (groupId !== null) {
+      const state = ctx.__executionState;
+      const group = state?.constructorGroups.get(groupId);
+      for (const child of children) {
+        retargetConstructorGroupDependencies(child.id, groupId, ctx);
+        group?.add(child.id);
+        state?.constructorGroupByRowId.set(child.id, groupId);
+      }
+    }
+    stampCreatedValuesMapKey(children, row.mapKey);
+    applyDeclaredStorageKeyOverrides({
+      createdValues: [encoded, ...children],
+      declarationByValueId: declarations
+    });
+    consumeBudget(
+      ctx,
+      "constructedSessionRows",
+      children.length,
+      "constructed Session row"
+    );
+    for (const child of children) {
+      if (!isLiteralValueContent(child)) {
+        throw new NSGetterRuntimeError(
+          "Initializer collection produced an unevaluated row."
+        );
+      }
+      extra.push(child);
+    }
+    for (const [id2, declaration] of declarations) {
+      ctx.__createdStorageKeyDeclarations?.set(id2, declaration);
+    }
+    return encoded;
+  });
+  return [...exported, ...extra];
+}
 function evaluateNSGetter(getter, ctx) {
   return evaluateNSGetterWithEffects(getter, ctx).value;
 }
-function evaluateNSGetterWithEffects(getter, ctx, argumentValues = []) {
+function evaluateNSGetterWithEffects(getter, ctx, argumentValues = [], options = {}) {
   const ownsInvocationState = ctx.__executionState === void 0;
   const requestedWrites = [];
   const runtimeCtx = withEvaluationRuntime(ctx, requestedWrites);
@@ -71093,6 +71338,50 @@ function evaluateNSGetterWithEffects(getter, ctx, argumentValues = []) {
       if (getter.typeInfo.type === 20 /* Decimal */ && typeof result.value === "number") {
         result.value = coerceDecimalOperand(result.value, "return");
       }
+      const initializerResult = options.initializerResult;
+      if (initializerResult !== void 0 && result.value !== null && (isMemberListBase(initializerResult.member) || isMemberDictionaryBase(initializerResult.member)) && findKnownRowIdByValueReference(result.value, runtimeCtx) === null) {
+        const createdValues = createdSessionValuesSince(runtimeCtx, creationCheckpoint);
+        const declarations = /* @__PURE__ */ new Map();
+        const root = materializeConstructorArgumentValue({
+          member: initializerResult.member,
+          value: result.value,
+          genericEnv: initializerResult.genericEnv ?? /* @__PURE__ */ new Map(),
+          ctx: runtimeCtx,
+          createdValues,
+          createdById: new Map(createdValues.map((row) => [row.id, row])),
+          storageKeyDeclarations: declarations,
+          collectionEntriesAreReferences: false
+        });
+        declarations.delete(root.id);
+        publishConstructedRows({
+          root,
+          createdValues,
+          storageKeyDeclarations: declarations,
+          ctx: runtimeCtx
+        });
+        result.value = root.value;
+      }
+      if (options.exportInitializerValues) {
+        const created = createdSessionValuesSince(
+          runtimeCtx,
+          creationCheckpoint
+        );
+        const rootIndex = created.findIndex(
+          (row) => row.value === result.value
+        );
+        const exported = exportInitializerCollections(
+          created,
+          writes,
+          runtimeCtx
+        );
+        if (exported !== created) {
+          for (const row of exported)
+            registerRuntimeSessionValue(runtimeCtx, row);
+          invalidateEvaluatorIndexes(runtimeCtx, null);
+        }
+        const exportedRoot = exported[rootIndex];
+        if (exportedRoot !== void 0) result.value = exportedRoot.value;
+      }
       finalizeConstructorAllocations(
         runtimeCtx,
         result.value,
@@ -73454,6 +73743,18 @@ function evalPointer(pointer, scope, ctx) {
         state.functionStack.pop();
       }
     }
+    case "objectInitializer" /* objectInitializer */: {
+      const receiver = evalPointer(pointer.receiver.pointer, scope, ctx);
+      const initializerScope = createChildScope(scope);
+      initializerScope.setLocal(pointer.receiver.id, receiver);
+      evalInstructions(
+        pointer.assignments,
+        initializerScope,
+        ctx,
+        evaluationOptions(ctx, true)
+      );
+      return receiver;
+    }
     case "callDelegate" /* callDelegate */: {
       const delegate = evalPointer(pointer.delegate, scope, ctx);
       if (delegate === null || delegate === void 0) {
@@ -74723,17 +75024,19 @@ function readDeclarationDefault(member, ctx) {
         projectId: ctx.vm.project.id,
         member,
         createdValues: created,
-        initEvaluator: (child, init, sourceValueId) => withConstructionGenericSlots(
+        initEvaluator: (child, init, sourceValueId, genericEnv = /* @__PURE__ */ new Map()) => withConstructionGenericSlots(
           child,
           ctx,
-          /* @__PURE__ */ new Map(),
+          genericEnv,
           () => evaluateInitializerInContext(
             init,
             child,
             ctx,
             created,
             [],
-            sourceValueId
+            sourceValueId,
+            void 0,
+            genericEnv
           )
         )
       });
@@ -75172,8 +75475,6 @@ function evalTileConvert(pointer, scope, ctx) {
     );
   }
   if (receiverClassId === targetClassId) return true;
-  const storedReceiver = ctx.vm.databaseVM?.storedValueById?.(receiverRow.id) ?? ctx.vm.values.find((row) => row.id === receiverRow.id) ?? null;
-  if (storedReceiver === null) return false;
   const cell = readSystemNativeField(receiver, "Cell", ctx);
   const cellRow = trackedRowForValueReference(cell, ctx);
   const nextValue = { Cell: cellRow?.id ?? cell };
@@ -75194,6 +75495,13 @@ function evalTileConvert(pointer, scope, ctx) {
     targetClassId
   );
   ctx.__valueOverlay?.set(receiverRow.id, nextRow);
+  const sessionRow = ctx.__runtimeSessionValues?.get(receiverRow.id);
+  if (sessionRow !== void 0) {
+    for (const key of Object.keys(sessionRow)) {
+      if (!Object.hasOwn(nextRow, key)) Reflect.deleteProperty(sessionRow, key);
+    }
+    Object.assign(sessionRow, nextRow);
+  }
   ctx.__executionState?.writes.push({
     kind: "replaceClass",
     target: receiver,
@@ -77517,7 +77825,7 @@ function constructionInitEvaluator(ctx, createdValues, argumentScopes, construct
     }
     return null;
   };
-  return (member, init, sourceValueId) => {
+  return (member, init, sourceValueId, genericEnv = instanceEnv) => {
     const memberId = Reflect.get(member, "id");
     const effectiveMemberId = typeof memberId === "string" ? memberId : null;
     const scopeMemberId = indexes2.initializerScopeMemberIds.get(init) ?? (typeof sourceValueId !== "string" ? void 0 : indexes2.initializerScopeMemberIdsByValueId.get(sourceValueId)) ?? effectiveMemberId;
@@ -77532,7 +77840,7 @@ function constructionInitEvaluator(ctx, createdValues, argumentScopes, construct
       return withConstructionGenericSlots(
         member,
         ctx,
-        instanceEnv,
+        genericEnv,
         () => evaluateInitializerInContext(
           init,
           member,
@@ -77540,7 +77848,8 @@ function constructionInitEvaluator(ctx, createdValues, argumentScopes, construct
           createdValues,
           argumentValues,
           sourceValueId ?? null,
-          scopeMemberId
+          scopeMemberId,
+          genericEnv
         )
       );
     };
@@ -77677,7 +77986,7 @@ function runtimeValueReferencesVariable(value, variableId, visited = /* @__PURE_
     (child) => runtimeValueReferencesVariable(child, variableId, visited)
   );
 }
-function evaluateInitializerInContext(init, member, ctx, createdValues, argumentValues = [], sourceValueId = null, compileMemberId) {
+function evaluateInitializerInContext(init, member, ctx, createdValues, argumentValues = [], sourceValueId = null, compileMemberId, genericEnv = /* @__PURE__ */ new Map()) {
   ctx.__constructedArgumentsByValue ??= /* @__PURE__ */ new WeakMap();
   const compiled = ensureInitializerCompiled({
     init,
@@ -77693,7 +78002,8 @@ function evaluateInitializerInContext(init, member, ctx, createdValues, argument
     result = evaluateNSGetterWithEffects(
       compiled,
       initializerCtx,
-      argumentValues
+      argumentValues,
+      { initializerResult: { member, genericEnv } }
     );
   } finally {
     closeFrame();
@@ -79341,6 +79651,9 @@ function cloneConstructorLiteralValue(value) {
 }
 function materializeConstructorArgumentValue(args) {
   const trackedValueId = findKnownRowIdByValueReference(args.value, args.ctx);
+  if (args.value === null && !isRequiredMember2(args.member) && (isMemberListBase(args.member) || isMemberDictionaryBase(args.member))) {
+    return registerConstructorArgumentRow(args, null);
+  }
   if (isMemberClassBase(args.member)) {
     if (args.value === null || args.value === void 0) {
       if (isRequiredMember2(args.member)) {
@@ -79429,20 +79742,25 @@ function materializeConstructorArgumentValue(args) {
       for (const entry of rows) sourceEntries.push(entry.value);
     }
     const ids = [];
+    const referenceIndexes = args.ctx.__unorderedListProjections?.referenceEntryIndexesByArray.get(
+      sourceEntries
+    );
     for (const [index, rawEntry] of sourceEntries.entries()) {
       const entryValue = constructorCollectionEntryValue(
         rawEntry,
         args.ctx,
-        trackedValueId !== null
+        isMemberClassBase(resolvedEntry) || isMemberListBase(resolvedEntry) || isMemberDictionaryBase(resolvedEntry) || (referenceIndexes?.has(index) ?? args.collectionEntriesAreReferences ?? trackedValueId !== null)
       );
       const child = materializeConstructorArgumentValue({
         ...args,
+        collectionEntriesAreReferences: void 0,
+        collectionOwnerId: void 0,
         member: resolvedEntry,
         genericEnv: entryEnv,
         value: entryValue,
         owner: {
-          identity: `value:${row.id}:index:${index}`,
-          label: row.id
+          identity: `value:${args.collectionOwnerId ?? row.id}:index:${index}`,
+          label: args.collectionOwnerId ?? row.id
         },
         destinationName: `${args.member.name}[${index}]`
       });
@@ -79479,16 +79797,18 @@ function materializeConstructorArgumentValue(args) {
       const entry = constructorCollectionEntryValue(
         rawEntry,
         args.ctx,
-        trackedValueId !== null
+        isMemberClassBase(resolvedEntry) || isMemberListBase(resolvedEntry) || isMemberDictionaryBase(resolvedEntry) || (args.collectionEntriesAreReferences ?? trackedValueId !== null)
       );
       record6[key] = materializeConstructorArgumentValue({
         ...args,
+        collectionEntriesAreReferences: void 0,
+        collectionOwnerId: void 0,
         member: resolvedEntry,
         genericEnv: entryEnv,
         value: entry,
         owner: {
-          identity: `value:${row.id}:slot:${key}`,
-          label: row.id
+          identity: `value:${args.collectionOwnerId ?? row.id}:slot:${key}`,
+          label: args.collectionOwnerId ?? row.id
         },
         destinationName: `${args.member.name}[${key}]`
       }).id;
@@ -79669,7 +79989,8 @@ function cloneClassValueGraph(receiver, expectedClassId, ctx) {
       initializerCreatedValues,
       argumentValues,
       sourceRow.id,
-      compileMemberId
+      compileMemberId,
+      isMemberListBase(sourceMember) || isMemberDictionaryBase(sourceMember) ? runtimeGenericEnvForValueRow(sourceRow, ctx, /* @__PURE__ */ new Set()) : void 0
     );
     if (evaluated.existingValueRow !== void 0) {
       const adoptedClone = cloneRow2(
@@ -79704,7 +80025,7 @@ function cloneClassValueGraph(receiver, expectedClassId, ctx) {
       Reflect.deleteProperty(clone, "containerId");
     }
     if (evaluated.provisionalRootId !== void 0) {
-      retargetDelegateReceiverValueIds(
+      retargetInitializerRootValueIds(
         [clone, ...initializerCreatedValues],
         evaluated.provisionalRootId,
         clone.id
@@ -80269,6 +80590,7 @@ function evaluateInitializerMaterialization(args) {
   const createdValues = [];
   const storageKeyDeclarations = /* @__PURE__ */ new Map();
   const evaluated = args.evaluateInitializer({
+    genericEnv: args.genericEnv,
     init: args.init,
     member: args.member,
     document: args.document,
@@ -80317,6 +80639,7 @@ function materializeInitializerValue(args) {
     ...args.storedConstructionReplay === true ? { storedConstructionReplay: true } : {},
     ...args.constructionBaselineReplay === true ? { constructionBaselineReplay: true } : {},
     ...args.argumentValues === void 0 ? {} : { argumentValues: args.argumentValues },
+    genericEnv: envFromStamp(args.row.genericBindings),
     sourceValueId: args.row.id,
     readTracking: args.readTracking,
     saveStaticBindings: args.saveStaticBindings,
@@ -80345,7 +80668,7 @@ function materializeInitializerValue(args) {
   };
   const allCreated = [root, ...createdValues];
   if (evaluated.provisionalRootId !== void 0) {
-    retargetDelegateReceiverValueIds(
+    retargetInitializerRootValueIds(
       allCreated,
       evaluated.provisionalRootId,
       root.id
@@ -80408,7 +80731,9 @@ function materializeMemberDefaultValue(args) {
     ...args.genericEnv === void 0 ? {} : { genericEnv: args.genericEnv },
     // A declaration default may itself be init-backed one level down (P43 §2),
     // and those nested initializers must evaluate against the same document.
-    initEvaluator: (member, init, sourceValueId) => args.evaluateInitializer({
+    initEvaluator: (member, init, sourceValueId, genericEnv) => args.evaluateInitializer({
+      genericEnv,
+      storageKeyDeclarations,
       init,
       member,
       document: args.document,
@@ -80433,7 +80758,7 @@ function materializeMemberDefaultValue(args) {
     ...built.genericBindings == null ? {} : { genericBindings: { ...built.genericBindings } }
   };
   const allCreated = [root, ...interior];
-  retargetDelegateReceiverValueIds(allCreated, built.id, root.id);
+  retargetInitializerRootValueIds(allCreated, built.id, root.id);
   finalizeMaterializedRoot({
     root,
     allCreated,
@@ -80450,6 +80775,7 @@ var init_initializer_materialization = __esm({
     init_deep_clone_plain_data();
     init_members();
     init_inheritance();
+    init_generics();
     init_evaluateNSGetter();
     init_initializer_context();
     init_value_row_owner_members();
@@ -83485,7 +83811,11 @@ function evaluateMemberInitializer(args) {
   const result = evaluateNSGetterWithEffects(
     compiled,
     ctx,
-    args.argumentValues ?? []
+    args.argumentValues ?? [],
+    {
+      exportInitializerValues: true,
+      initializerResult: { member: args.member, genericEnv: args.genericEnv }
+    }
   );
   const created = result.createdSessionValues ?? [];
   if (isMemberLookupBase(args.member)) {
@@ -94462,7 +94792,7 @@ function inspectCollection(options, member) {
   if (member.kind === 6 /* List */) {
     listKind = listKindOf(member);
     if (!isValidListValueShape(member, body)) {
-      const label = options.diagnosticStyle === "project" ? String(listKind) : ListKind[listKind].toLowerCase();
+      const label = ListKind[listKind].toLowerCase();
       fail(`${options.path} has an invalid ${label} List value shape.`);
     }
     if (listKind === 1 /* Unordered */) body = [];
@@ -98696,7 +99026,8 @@ function isStringValueRecord(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value) && Object.values(value).every((entry) => typeof entry === "string");
 }
 function commitInitEvaluator(document, createdValues) {
-  return (member, init, sourceValueId) => evaluateMemberInitializer({
+  return (member, init, sourceValueId, genericEnv) => evaluateMemberInitializer({
+    genericEnv,
     init,
     member,
     document,
@@ -98715,10 +99046,19 @@ function assertConstructedGraphReferencesResolve(args) {
   const valueIds = new Set(args.document.values.map((value) => value.id));
   for (const site of sites) {
     if ((site.init.compiled?.parameters.length ?? 2) > 2) continue;
+    if (site.sourceValueId === void 0 && [
+      ...referencedGenericParams(
+        resolveMember2(site.member, args.document.members),
+        args.document.members
+      )
+    ].some((paramId) => site.genericEnv.get(paramId)?.kind !== "member"))
+      continue;
     const createdValues = [];
     const produced = evaluateMemberInitializer({
       init: site.init,
       member: site.member,
+      genericEnv: site.genericEnv,
+      sourceValueId: site.sourceValueId,
       document: args.document,
       createdValues
     });
@@ -98750,6 +99090,10 @@ function collectTouchedInitializerSites(args) {
     if (!isInitValueContent(member.defaultValue)) continue;
     if (!changedConstructor && !changedMemberIds.has(member.id)) continue;
     sites.push({
+      genericEnv: resolveDeclaringClassGenericEnv(
+        member.id,
+        args.document.classes
+      ),
       label: `Member "${member.name}" (${member.id})`,
       member,
       init: member.defaultValue.init
@@ -98777,6 +99121,8 @@ function collectTouchedInitializerSites(args) {
       );
     }
     sites.push({
+      genericEnv: envFromStamp(row.genericBindings),
+      sourceValueId: row.id,
       label: `Value "${row.id}"`,
       member,
       init: row.init
@@ -98793,11 +99139,19 @@ function assertProducedGraphLookupsResolve(args) {
     projectId: args.document.project.id,
     value: args.produced.value,
     classId: args.produced.classId,
+    ...args.produced.genericBindings === void 0 ? {} : { genericBindings: { ...args.produced.genericBindings } },
     ...args.produced.constructorArgs === void 0 ? {} : { constructorArgs: args.produced.constructorArgs },
     ...args.produced.instanceConstructorId === void 0 ? {} : { instanceConstructorId: args.produced.instanceConstructorId },
     createdAt: 0,
     updatedAt: 0
   };
+  if (args.produced.provisionalRootId !== void 0) {
+    retargetInitializerRootValueIds(
+      graphValues,
+      args.produced.provisionalRootId,
+      rootRow.id
+    );
+  }
   const ownerByValueId = resolveSemanticOwnerMembersForValues(
     { ...args.document, values: [...graphValues, rootRow] },
     new Set(args.createdValues.map((value) => value.id)),
@@ -137435,7 +137789,7 @@ var init_registry2 = __esm({
   "schema-contract/registry.mjs"() {
     "use strict";
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
-      cliVersion: "0.52.3",
+      cliVersion: "0.52.5",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -141699,6 +142053,7 @@ async function runPendingMigrations(workspace, raw, migrations, onlyRef) {
                 `Migration "${migrationName}" produced an invalid tile class replacement.`
               );
             }
+            if (createdById.has(write.valueId)) continue;
             const storedRoot = valueById.get(write.valueId);
             if (storedRoot === void 0 || !isMemberValue(storedRoot)) {
               throw new Error(
@@ -145307,7 +145662,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.52.3");
+    console.log("0.52.5");
     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.52.3",
+  "version": "0.52.5",
   "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.52.3 -->
+<!-- reviewed-through-cli: 0.52.5 -->
 
 # 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.52.3 -->
+<!-- reviewed-through-cli: 0.52.5 -->
 ```
 
 The quoted version above is checked too, so this instruction cannot go stale

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

@@ -120,6 +120,16 @@ runtime Class's one-argument `Equals` Function or NSFunction when it returns
 `bool`, including the effective override. Values without that member fall back
 to ordinary NeoScript equality.
 
+Object initializers are available in method bodies and `.spec.neo` tests:
+
+```neo
+var tile = new DirtWetTile { Cell = Vector2Int(3, -2) };
+```
+
+Construction runs first. Each initializer entry then uses ordinary assignment
+rules in source order, including property setters, access checks, and readonly
+restrictions. Initializer expressions read the caller's scope.
+
 ## Nullability and ownership
 
 Do not access a nullable receiver directly. First narrow it with a condition, or