@neocompose/cli 0.52.3 → 0.52.4

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [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);
@@ -71060,10 +71213,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 +71334,27 @@ function evaluateNSGetterWithEffects(getter, ctx, argumentValues = []) {
       if (getter.typeInfo.type === 20 /* Decimal */ && typeof result.value === "number") {
         result.value = coerceDecimalOperand(result.value, "return");
       }
+      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 +73716,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) {
@@ -75172,8 +75446,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 +75466,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,
@@ -79429,20 +79708,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 +79763,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;
@@ -83485,7 +83771,8 @@ function evaluateMemberInitializer(args) {
   const result = evaluateNSGetterWithEffects(
     compiled,
     ctx,
-    args.argumentValues ?? []
+    args.argumentValues ?? [],
+    { exportInitializerValues: true }
   );
   const created = result.createdSessionValues ?? [];
   if (isMemberLookupBase(args.member)) {
@@ -94462,7 +94749,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 = [];
@@ -137435,7 +137722,7 @@ var init_registry2 = __esm({
   "schema-contract/registry.mjs"() {
     "use strict";
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
-      cliVersion: "0.52.3",
+      cliVersion: "0.52.4",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -141699,6 +141986,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 +145595,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.4");
     return;
   }
   if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neocompose/cli",
-  "version": "0.52.3",
+  "version": "0.52.4",
   "description": "Neo Compose native project-source CLI with bidirectional sync.",
   "license": "MIT",
   "type": "module",

package/skills/neocompose-cli/SKILL.md

@@ -9,7 +9,7 @@ description: >-
   `@neocompose/cli` or `node cli/bin/neo.mjs` in the neo-compose repository.
 ---
 
-<!-- reviewed-through-cli: 0.52.3 -->
+<!-- reviewed-through-cli: 0.52.4 -->
 
 # 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.4 -->
 ```
 
 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