@neocompose/cli 0.22.3 → 0.22.5

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## [0.22.5] - 2026-08-04
+
+### Fixed
+
+- Pull reconstructs required constructor calls from legacy declaration rows
+  whose projected fields remain initializer-backed, including animation segment
+  frames that depend on their declaring class's parameters.
+- Existing call-site initializer blocks may repeat a field settled by a required
+  constructor, preserving the language's normal last-write-wins semantics while
+  old canonical source converges.
+- System-schema repair restores tombstoned constructor-projected declaration
+  rows, rewrites only callers that reference retired member identities, and
+  recompiles only the impacted records through the normal push pipeline.
+
+## [0.22.4] - 2026-08-04
+
+### Fixed
+
+- Normal and reset pulls now replay stored immutable system constructions and
+  resolve constructor parameter scopes through deeply nested initializer rows.
+- Pull projection accepts migrated constructor arguments on implicitly typed
+  list entries, including animation segment frames.
+
 ## [0.22.3] - 2026-08-04
 
 ### Fixed

package/dist/neo.mjs

@@ -8954,7 +8954,8 @@ var init_strict_resolver = __esm({
                 className,
                 expression,
                 scope,
-                expression.pos
+                expression.pos,
+                expected
               );
             }
             if (expression.argumentNames && !projectionCall) {
@@ -10396,11 +10397,18 @@ var init_strict_resolver = __esm({
             pos
           );
         }
-        const signature = schemaClass2.constructorSignature;
+        const replayingStoredConstruction = this.context.storedConstructionReplay === true;
+        if (schemaClass2.constructorUnavailableReason === "immutableOnly" && !replayingStoredConstruction) {
+          throw new CompileError(
+            `Cannot construct Immutable-only Class '${className}'; constructors create writable Session values.`,
+            pos
+          );
+        }
+        const signature = schemaClass2.constructorSignature ?? (replayingStoredConstruction ? schemaClass2.storedConstructionReplaySignature : void 0);
         if (!signature) {
           const open = (schemaClass2.typeParameters?.length ?? 0) > 0;
           throw new CompileError(
-            schemaClass2.constructorUnavailableReason === "immutableOnly" ? `Cannot construct Immutable-only Class '${className}'; constructors create writable Session values.` : open ? `Cannot construct open generic Class '${className}'; construct a closed named descendant.` : `Class '${className}' does not expose a generated public constructor.`,
+            open ? `Cannot construct open generic Class '${className}'; construct a closed named descendant.` : `Class '${className}' does not expose a generated public constructor.`,
             pos
           );
         }
@@ -10581,7 +10589,7 @@ var init_strict_resolver = __esm({
        * the call site's initializer block is carried through to be applied last
        * (§6.1 step 4).
        */
-      resolveDeclaredConstructor(className, expression, scope, pos) {
+      resolveDeclaredConstructor(className, expression, scope, pos, expected) {
         const schemaClass2 = this.project.typeByName.get(className);
         if (!schemaClass2 || schemaClass2.kind !== "class") {
           throw new CompileError(
@@ -10595,13 +10603,30 @@ var init_strict_resolver = __esm({
             pos
           );
         }
-        if (schemaClass2.constructorUnavailableReason === "immutableOnly") {
+        if (schemaClass2.constructorUnavailableReason === "immutableOnly" && this.context.storedConstructionReplay !== true) {
           throw new CompileError(
             `Cannot construct Immutable-only Class '${className}'; constructors create writable Session values.`,
             pos
           );
         }
-        const declared = schemaClass2.declaredConstructors ?? [];
+        const targetType = this.constructorTargetType(
+          schemaClass2,
+          expression,
+          expected
+        );
+        const declared = (schemaClass2.declaredConstructors ?? []).map(
+          (constructor2) => ({
+            ...constructor2,
+            parameters: constructor2.parameters.map((parameter3) => ({
+              ...parameter3,
+              type: substituteTypeParameters(
+                parameter3.type,
+                targetType,
+                schemaClass2
+              )
+            }))
+          })
+        );
         const argumentNames = expression.args.map(
           (_, index) => expression.argumentNames?.[index] ?? null
         );
@@ -10642,10 +10667,7 @@ var init_strict_resolver = __esm({
           expression,
           scope
         );
-        const classType = {
-          kind: "named",
-          typeId: schemaClass2.id
-        };
+        const classType = targetType;
         const schemaClassInfo = toWireType(classType, this.project);
         if (schemaClassInfo.type !== 7 /* Class */) {
           throw new Error(
@@ -26032,9 +26054,6 @@ function attachConstructorSignature(type, environment) {
   )) {
     return type;
   }
-  if (resolvedAllowedStorage(type.id, environment) === "immutable") {
-    return { ...type, constructorUnavailableReason: "immutableOnly" };
-  }
   const constructorSignature2 = buildNeoScriptConstructorSignature(
     type.id,
     type.members,
@@ -26052,6 +26071,13 @@ function attachConstructorSignature(type, environment) {
       } : null;
     }
   );
+  if (resolvedAllowedStorage(type.id, environment) === "immutable") {
+    return {
+      ...type,
+      storedConstructionReplaySignature: constructorSignature2,
+      constructorUnavailableReason: "immutableOnly"
+    };
+  }
   return { ...type, constructorSignature: constructorSignature2 };
 }
 function resolvedAllowedStorage(classId, environment) {
@@ -38844,8 +38870,145 @@ function substituteMember(member, env, members) {
     };
     return substituted;
   }
+  if (isMemberDelegateBase(resolved)) {
+    const returnTypeInfo = substituteNestedTypeInfo(
+      resolved.returnTypeInfo,
+      env,
+      members
+    );
+    let argumentsChanged = false;
+    const argumentTypes = resolved.argumentTypes.map((argument2) => {
+      const substituted2 = substituteNestedTypeInfo(argument2, env, members);
+      if (substituted2 === argument2) return argument2;
+      argumentsChanged = true;
+      return { ...substituted2, name: argument2.name };
+    });
+    if (returnTypeInfo === resolved.returnTypeInfo && !argumentsChanged) {
+      return resolved;
+    }
+    const substituted = {
+      ...resolved,
+      returnTypeInfo,
+      argumentTypes
+    };
+    return substituted;
+  }
   return resolved;
 }
+function substituteNestedTypeInfo(typeInfo, env, members) {
+  if (typeInfo.type === 21 /* Generic */) {
+    const entry = env.get(typeInfo.genericParamId);
+    if (entry === void 0) {
+      throw new Error(
+        `substituteMember: callable type references generic param "${typeInfo.genericParamId}", which is not present in the binding environment.`
+      );
+    }
+    if (entry.kind === "unbound") return typeInfo;
+    const binding = members.find(
+      (candidate) => candidate.id === entry.memberId
+    );
+    if (binding === void 0) {
+      throw new Error(
+        `substituteMember: callable type binding member "${entry.memberId}" for generic param "${typeInfo.genericParamId}" does not exist in the document.`
+      );
+    }
+    return genericBindingTypeInfo(binding, env, members);
+  }
+  if (typeInfo.type === 6 /* List */ || typeInfo.type === 5 /* Dictionary */ || typeInfo.type === 9 /* Lookup */) {
+    return {
+      ...typeInfo,
+      entryTypeInfo: substituteNestedTypeInfo(
+        typeInfo.entryTypeInfo,
+        env,
+        members
+      )
+    };
+  }
+  if (typeInfo.type === 7 /* Class */) {
+    const typeArguments = typeInfo.typeArguments;
+    if (typeArguments === void 0) return typeInfo;
+    return {
+      ...typeInfo,
+      typeArguments: Object.fromEntries(
+        Object.entries(typeArguments).map(([parameterId, argument2]) => [
+          parameterId,
+          substituteNestedTypeInfo(argument2, env, members)
+        ])
+      )
+    };
+  }
+  if (typeInfo.type === 25 /* NSDelegate */) {
+    return {
+      ...typeInfo,
+      returnTypeInfo: substituteNestedTypeInfo(
+        typeInfo.returnTypeInfo,
+        env,
+        members
+      ),
+      argumentTypes: typeInfo.argumentTypes.map(
+        (argument2) => substituteNestedTypeInfo(argument2, env, members)
+      )
+    };
+  }
+  return typeInfo;
+}
+function genericBindingTypeInfo(rawMember, env, members) {
+  return typeInfoFromArgumentSignature(
+    typeArgumentSignatureOfMember(rawMember, env, members)
+  );
+}
+function typeInfoFromArgumentSignature(signature) {
+  if (signature.type === 7 /* Class */) {
+    const classSignature = signature;
+    return {
+      type: 7 /* Class */,
+      required: classSignature.required,
+      classId: classSignature.classId,
+      ...Object.keys(classSignature.args).length === 0 ? {} : {
+        typeArguments: Object.fromEntries(
+          Object.entries(classSignature.args).map(
+            ([parameterId, argument2]) => [
+              parameterId,
+              typeInfoFromArgumentSignature(argument2)
+            ]
+          )
+        )
+      }
+    };
+  }
+  if (signature.type === 8 /* Enum */) {
+    const enumSignature = signature;
+    return {
+      type: 8 /* Enum */,
+      required: enumSignature.required,
+      enumId: enumSignature.enumId
+    };
+  }
+  if (signature.type === 6 /* List */) {
+    const listSignature = signature;
+    return {
+      type: 6 /* List */,
+      required: listSignature.required,
+      entryTypeInfo: typeInfoFromArgumentSignature(listSignature.entry)
+    };
+  }
+  if (signature.type === 5 /* Dictionary */) {
+    const dictionarySignature = signature;
+    return {
+      type: 5 /* Dictionary */,
+      required: dictionarySignature.required,
+      entryTypeInfo: typeInfoFromArgumentSignature(dictionarySignature.entry),
+      ...dictionarySignature.keyEnumId === void 0 ? {} : { keyEnumId: dictionarySignature.keyEnumId }
+    };
+  }
+  const typeInfo = { type: signature.type, required: signature.required };
+  if (!isNSTypeInfo(typeInfo)) {
+    throw new Error(
+      `substituteMember: generic binding kind ${signature.type} cannot appear in a NeoScript callable type.`
+    );
+  }
+  return typeInfo;
+}
 function resolveTerminalBinding(genericParamId, slotName, env, members) {
   const entry = env.get(genericParamId);
   if (entry === void 0) {
@@ -39126,6 +39289,7 @@ var init_generics = __esm({
   "../src/models/classes/generics.ts"() {
     "use strict";
     init_member_kinds();
+    init_neoscript();
     init_world_system_classes();
     init_structural_narrow();
     init_inheritance();
@@ -51136,7 +51300,33 @@ function constructorSignature(schemaClass2, members, context, genericEnvironment
     return {};
   }
   if (resolveAllowedStorage(schemaClass2.id, context.vm.classes) === "immutable" /* Immutable */) {
-    return { constructorUnavailableReason: "immutableOnly" };
+    const signature2 = buildNeoScriptConstructorSignature(
+      schemaClass2.id,
+      members,
+      (memberId) => {
+        const record3 = analyzerMemberById(context.vm, memberId);
+        if (!record3) return null;
+        try {
+          const resolved = substituteMember(
+            record3,
+            genericEnvironment,
+            context.vm.members
+          );
+          return {
+            required: resolved.required,
+            defaultValue: "defaultValue" in resolved ? resolved.defaultValue : void 0
+          };
+        } catch {
+          return projections.some(
+            (projection) => projection.memberId === memberId
+          ) ? { required: true } : null;
+        }
+      }
+    );
+    return {
+      storedConstructionReplaySignature: signature2,
+      constructorUnavailableReason: "immutableOnly"
+    };
   }
   const signature = buildNeoScriptConstructorSignature(
     schemaClass2.id,
@@ -52306,6 +52496,7 @@ function compileStrict(code, context) {
     deferred: context.deferred,
     functionName: context.functionName,
     migrationContext: context.migrationContext,
+    storedConstructionReplay: context.storedConstructionReplay,
     valueAliases: context.valueAliases,
     implicitMemberAccess: context.implicitMemberAccess,
     declaringType: context.declaringType,
@@ -52370,9 +52561,10 @@ function createContext(ctx, options) {
     analyzer,
     ctx.compilationProject
   );
-  if (ctx.implicitMemberAccess !== true) return adapted;
+  const replayContext = ctx.storedConstructionReplay === true ? { ...adapted, storedConstructionReplay: true } : adapted;
+  if (ctx.implicitMemberAccess !== true) return replayContext;
   return {
-    ...adapted,
+    ...replayContext,
     ...ctx.staticMember === true ? { thisClass: void 0 } : {},
     implicitMemberAccess: true,
     ...adapted.thisClass ? { declaringType: adapted.thisClass } : {},
@@ -52681,7 +52873,8 @@ function compileValueRowInitializerBody(args) {
           args.initializerOwnerClass,
           args.constructors ?? []
         ),
-        ...args.compilationProject === void 0 ? {} : { compilationProject: args.compilationProject }
+        ...args.compilationProject === void 0 ? {} : { compilationProject: args.compilationProject },
+        ...args.storedConstructionReplay === true ? { storedConstructionReplay: true } : {}
       })
     );
   } catch (error) {
@@ -54975,7 +55168,12 @@ function makeEvaluatorLookups(members, values, options = {}) {
   if (options.includeValueGraphIndexes === true) {
     return {
       ...lookups,
-      evaluatorIndexes: buildEvaluatorBaseIndexes(members, values, valMap)
+      evaluatorIndexes: buildEvaluatorBaseIndexes(members, values, valMap),
+      ...options.constructorInitializerDocument === void 0 ? {} : {
+        constructorInitializerIndexes: buildConstructorInitializerIndexes(
+          options.constructorInitializerDocument
+        )
+      }
     };
   }
   return lookups;
@@ -58891,12 +59089,19 @@ function validateClassConstructorDescriptor(info, ctx, requireEveryRequiredField
       `Cannot construct abstract Class '${schemaClass2.name}'.`
     );
   }
-  if (!isClosedClass(classId, ctx.vm.classes)) {
+  const replaySlot = ctx.__storedConstructionReplaySlot;
+  const classArguments2 = replaySlot?.classId === classId ? replaySlot.classArguments : void 0;
+  const instanceEnv = resolveInstanceEnv(
+    classId,
+    classArguments2,
+    ctx.vm.classes
+  );
+  if (firstUnboundParamId(instanceEnv) !== null) {
     throw new NSGetterRuntimeError(
       `Cannot construct open generic Class '${schemaClass2.name}'.`
     );
   }
-  if (resolveAllowedStorage(classId, ctx.vm.classes) === "immutable" /* Immutable */) {
+  if (resolveAllowedStorage(classId, ctx.vm.classes) === "immutable" /* Immutable */ && ctx.storedConstructionReplay !== true) {
     throw new NSGetterRuntimeError(
       `Cannot construct Immutable-only Class '${schemaClass2.name}'.`
     );
@@ -58916,7 +59121,6 @@ function validateClassConstructorDescriptor(info, ctx, requireEveryRequiredField
   const schemaByKey = new Map(
     mergedSchema.map((entry) => [entry.schemaKey, entry])
   );
-  const instanceEnv = resolveInstanceEnv(classId, void 0, ctx.vm.classes);
   const seenSchemaKeys = /* @__PURE__ */ new Set();
   const seenMemberIds = /* @__PURE__ */ new Set();
   const fields = [];
@@ -58967,7 +59171,7 @@ function validateClassConstructorDescriptor(info, ctx, requireEveryRequiredField
     );
   }
   if (!requireEveryRequiredField) {
-    return { schemaClass: schemaClass2, fields, instanceEnv };
+    return { schemaClass: schemaClass2, fields, instanceEnv, classArguments: classArguments2 };
   }
   for (const entry of mergedSchema) {
     const rawMember = evalMemberById(ctx.vm, entry.memberId);
@@ -58990,7 +59194,7 @@ function validateClassConstructorDescriptor(info, ctx, requireEveryRequiredField
       );
     }
   }
-  return { schemaClass: schemaClass2, fields, instanceEnv };
+  return { schemaClass: schemaClass2, fields, instanceEnv, classArguments: classArguments2 };
 }
 function assertConstructorFieldSlotWritable(args) {
   const surfaceEntry = mergeInstanceSchema(
@@ -59073,11 +59277,12 @@ function evaluateConstructorFields(descriptor, scope, ctx) {
     return { validated, value };
   });
 }
-function syntheticConstructorMember(schemaClass2) {
+function syntheticConstructorMember(schemaClass2, classArguments2) {
   return {
     name: `new ${schemaClass2.name}`,
     kind: 7 /* Class */,
     classId: schemaClass2.id,
+    ...classArguments2 === void 0 ? {} : { classArguments: classArguments2 },
     locked: false,
     required: true,
     isStatic: false,
@@ -59308,7 +59513,10 @@ function constructClassValueWithinFrame(descriptor, scope, ctx) {
   const schemaClass2 = descriptor.schemaClass;
   const classId = schemaClass2.id;
   const supplied = evaluateConstructorFields(descriptor, scope, ctx);
-  const syntheticMember = syntheticConstructorMember(schemaClass2);
+  const syntheticMember = syntheticConstructorMember(
+    schemaClass2,
+    descriptor.classArguments
+  );
   const createdValues = [];
   const storageKeyDeclarations = /* @__PURE__ */ new Map();
   let root;
@@ -59778,55 +59986,70 @@ function constructorInitializerIndexes(ctx) {
   if (ctx.__constructorInitializerIndexes !== void 0) {
     return ctx.__constructorInitializerIndexes;
   }
+  const shared = ctx.vm.databaseVM?.constructorInitializerIndexes;
+  if (shared !== void 0) {
+    ctx.__constructorInitializerIndexes = shared;
+    return shared;
+  }
+  const built = buildConstructorInitializerIndexes(ctx.vm);
+  ctx.__constructorInitializerIndexes = built;
+  return built;
+}
+function buildConstructorInitializerIndexes(vm) {
   const initializerScopeMemberIds = /* @__PURE__ */ new WeakMap();
   const initializerByValueId = /* @__PURE__ */ new Map();
-  for (const row of ctx.vm.values) {
+  for (const row of vm.values) {
     const initializer = Reflect.get(row, "init");
     if (initializer !== void 0)
       initializerByValueId.set(row.id, initializer);
   }
-  for (const member of ctx.vm.members) {
+  for (const member of vm.members) {
     const defaultValue = member.defaultValue;
     if (isInitValueContent(defaultValue)) {
       initializerScopeMemberIds.set(defaultValue.init, member.id);
-      continue;
     }
-    if (!isLiteralValueContent(defaultValue)) continue;
-    const value = defaultValue.value;
-    const valueIds = Array.isArray(value) ? value : typeof value === "object" && value !== null ? Object.values(value) : [];
-    for (const valueId of valueIds) {
-      if (typeof valueId !== "string") continue;
-      const initializer = initializerByValueId.get(valueId);
-      if (initializer !== void 0) {
-        initializerScopeMemberIds.set(initializer, member.id);
-      }
+  }
+  const initializerRootOwners = /* @__PURE__ */ new Map();
+  resolveOwnerMembersForValues(
+    {
+      classes: vm.classes,
+      members: vm.members,
+      values: vm.values
+    },
+    new Set(initializerByValueId.keys()),
+    void 0,
+    initializerRootOwners
+  );
+  for (const [valueId, initializer] of initializerByValueId) {
+    const rootOwnerId = Reflect.get(
+      initializerRootOwners.get(valueId) ?? {},
+      "id"
+    );
+    if (typeof rootOwnerId === "string") {
+      initializerScopeMemberIds.set(initializer, rootOwnerId);
     }
   }
   const declaringClassIdsByMemberId = /* @__PURE__ */ new Map();
-  for (const schemaClass2 of ctx.vm.classes) {
+  for (const schemaClass2 of vm.classes) {
     for (const memberId of Object.values(schemaClass2.schema)) {
       const owners = declaringClassIdsByMemberId.get(memberId) ?? /* @__PURE__ */ new Set();
       owners.add(schemaClass2.id);
       declaringClassIdsByMemberId.set(memberId, owners);
     }
   }
-  const memberById = new Map(
-    ctx.vm.members.map((member) => [member.id, member])
-  );
+  const memberById = new Map(vm.members.map((member) => [member.id, member]));
   const containerMemberIdByEntryId = /* @__PURE__ */ new Map();
-  for (const member of ctx.vm.members) {
+  for (const member of vm.members) {
     if (isMemberList(member) || isMemberDictionary(member)) {
       containerMemberIdByEntryId.set(member.entryMemberId, member.id);
     }
   }
-  const built = {
+  return {
     initializerScopeMemberIds,
     declaringClassIdsByMemberId,
     memberById,
     containerMemberIdByEntryId
   };
-  ctx.__constructorInitializerIndexes = built;
-  return built;
 }
 function prepareConstructorArgumentScopes(record3, argumentValues, ctx) {
   const values = /* @__PURE__ */ new Map();
@@ -60077,7 +60300,10 @@ function constructDeclaredClassValueWithinFrame(descriptor, record3, info, scope
         textureTemplates: ctx.vm.textureTemplates ?? []
       },
       projectId: ctx.vm.project.id,
-      member: syntheticConstructorMember(schemaClass2),
+      member: syntheticConstructorMember(
+        schemaClass2,
+        descriptor.classArguments
+      ),
       topLevelClassId: classId,
       createdValues,
       storageKeyDeclarations,
@@ -61173,6 +61399,7 @@ var init_evaluateNSGetter = __esm({
     init_interfaces();
     init_neoscript();
     init_NSGetterRuntimeError();
+    init_value_row_owner_members();
     init_decimal();
     init_members();
     init_core();
@@ -61279,17 +61506,20 @@ var init_evaluateNSGetter = __esm({
 
 // ../src/view-models/neoscript-evaluator/evaluateInitializer.ts
 function initializerEvaluatorLookups(document) {
-  const key = document;
+  const key = document.evaluatorCache?.key ?? document;
+  const revision = document.evaluatorCache?.revision;
   const cached = evaluatorLookupsByDocument.get(key);
-  if (cached !== void 0 && cached.members === document.members && cached.values === document.values) {
+  if (cached !== void 0 && (revision === void 0 ? cached.members === document.members && cached.values === document.values : cached.revision === revision)) {
     return cached.lookups;
   }
   const lookups = makeEvaluatorLookups(document.members, document.values, {
-    includeValueGraphIndexes: true
+    includeValueGraphIndexes: true,
+    constructorInitializerDocument: document
   });
   evaluatorLookupsByDocument.set(key, {
     members: document.members,
     values: document.values,
+    revision,
     lookups
   });
   return lookups;
@@ -61339,6 +61569,15 @@ function evaluateMemberInitializer(args) {
     rootValue: buildInitializerRootValue(args.document),
     saveStaticBindings: args.saveStaticBindings,
     sessionStaticBindings: args.sessionStaticBindings,
+    ...args.storedConstructionReplay === true ? {
+      storedConstructionReplay: true,
+      ...isMemberClassBase(args.member) ? {
+        __storedConstructionReplaySlot: {
+          classId: args.member.classId,
+          classArguments: args.member.classArguments ?? {}
+        }
+      } : {}
+    } : {},
     __constructedArgumentsByValue: /* @__PURE__ */ new WeakMap(),
     __createdStorageKeyDeclarations: args.storageKeyDeclarations ?? /* @__PURE__ */ new Map()
   };
@@ -61361,6 +61600,7 @@ var evaluatorLookupsByDocument;
 var init_evaluateInitializer = __esm({
   "../src/view-models/neoscript-evaluator/evaluateInitializer.ts"() {
     "use strict";
+    init_members();
     init_project2();
     init_NSGetterRuntimeError();
     init_evaluateNSGetter();
@@ -61387,7 +61627,8 @@ function evaluateInitializerMaterialization(args) {
     member: args.member,
     document: args.document,
     createdValues,
-    storageKeyDeclarations
+    storageKeyDeclarations,
+    ...args.storedConstructionReplay === true ? { storedConstructionReplay: true } : {}
   });
   return { evaluated, createdValues, storageKeyDeclarations };
 }
@@ -61395,7 +61636,8 @@ function materializeInitializerValue(args) {
   const { evaluated, createdValues, storageKeyDeclarations } = evaluateInitializerMaterialization({
     init: args.row.init,
     member: args.member,
-    document: args.document
+    document: args.document,
+    ...args.storedConstructionReplay === true ? { storedConstructionReplay: true } : {}
   });
   const {
     init: _init,
@@ -77143,22 +77385,29 @@ function prepareServerOwnedDelegateValueBodies(args) {
         `Value "${row.id}" carries a NeoDelegate closure but no NeoDelegate member in this project version stores it.`
       );
     }
-    row.value = compileDelegateClosureValue(row.value.code, {
-      project: document.project,
-      projectFiles: document.projectFiles,
-      members: document.members,
-      classes: document.classes,
-      enums: document.enums,
-      interfaces: document.interfaces,
-      constructors: document.constructors ?? [],
-      thisClass: findSchemaPlacement(
-        rootOwnerByValueId.get(row.id)?.id ?? "",
-        document.classes
-      )?.ownerClass ?? null,
-      returnTypeInfo: member.returnTypeInfo,
-      argumentTypes: member.argumentTypes,
-      name: `${member.name} value`
-    });
+    const rootOwner = rootOwnerByValueId.get(row.id);
+    const thisClass = findSchemaPlacement(rootOwner?.id ?? "", document.classes)?.ownerClass ?? null;
+    try {
+      row.value = compileDelegateClosureValue(row.value.code, {
+        project: document.project,
+        projectFiles: document.projectFiles,
+        members: document.members,
+        classes: document.classes,
+        enums: document.enums,
+        interfaces: document.interfaces,
+        constructors: document.constructors ?? [],
+        thisClass,
+        returnTypeInfo: member.returnTypeInfo,
+        argumentTypes: member.argumentTypes,
+        name: `${member.name} value`
+      });
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : String(error);
+      throw new Error(
+        `Value "${row.id}" NeoDelegate closure failed under member "${member.name}" (${getOptionalString(member, "id") ?? "unknown"}), root owner "${rootOwner?.name ?? "unknown"}" (${getOptionalString(rootOwner, "id") ?? "unknown"}), lexical class "${thisClass?.name ?? "none"}" (${thisClass?.id ?? "none"}), and return type ${canonicalJsonStringify(member.returnTypeInfo)}: ${detail}`,
+        { cause: error }
+      );
+    }
   };
   for (const [index, row] of explicitRows) {
     const compiled = { ...row, value: { ...row.value } };
@@ -77713,6 +77962,7 @@ var init_project_version_schema_commit = __esm({
     init_members();
     init_inheritance();
     init_generics();
+    init_core();
     init_world_content_sidecar_validation();
     init_project_document_value_overlay();
     init_project2();
@@ -81133,6 +81383,7 @@ function replayStoredConstructionV4(args) {
     // Instance calls are self-contained. Declaration calls inherit the class
     // header parameters that are in lexical scope at their source site.
     initializerOwnerClass: args.initializerOwnerClass ?? null,
+    storedConstructionReplay: true,
     ...args.compilationProject === void 0 ? {} : { compilationProject: args.compilationProject }
   });
   if (!isMemberValue(candidate) || !isInitValueContent(candidate)) {
@@ -81151,14 +81402,19 @@ function replayStoredConstructionV4(args) {
         // Constructor-only rows have no structural member owner. Use the same
         // explicit typed descriptor for evaluation that compiled the replay.
         member: compileMember,
-        row: candidate
+        row: candidate,
+        storedConstructionReplay: true
       });
       break;
     } catch (error) {
       if (!(error instanceof UncompiledInitializerRuntimeError) || error.memberId === null || compiledDependencies.has(error.memberId)) {
         throw error;
       }
-      compilePulledMemberInitializerBodyV4(document, error.memberId);
+      compilePulledMemberInitializerBodyV4(
+        document,
+        error.memberId,
+        args.compilationProject
+      );
       compiledDependencies.add(error.memberId);
     }
   }
@@ -81208,7 +81464,7 @@ function assertPulledConstructorsCompiled(document) {
     );
   }
 }
-function compilePulledMemberInitializerBodyV4(document, memberId) {
+function compilePulledMemberInitializerBodyV4(document, memberId, compilationProject) {
   const compileArgs = {
     project: document.project,
     projectFiles: document.projectFiles,
@@ -81230,7 +81486,8 @@ function compilePulledMemberInitializerBodyV4(document, memberId) {
   compileMemberInitializerBody({
     ...compileArgs,
     member,
-    thisClass
+    thisClass,
+    ...compilationProject === void 0 ? {} : { compilationProject }
   });
 }
 function readPulledProjectDocumentV4(records2) {
@@ -81304,10 +81561,13 @@ function buildValueEmitContext(records2, manifest) {
   const symbolsByValueId = staticSymbols(classes, members);
   let document;
   const readDocument = () => document ??= readPulledProjectDocumentV4(records2);
+  let compilationProject;
+  const readCompilationProject = () => compilationProject ??= createNeoScriptCompilationProject(readDocument());
   let materializedGraph;
   return {
     records: records2,
     readDocument,
+    readCompilationProject,
     readMaterializedGraph: () => {
       if (materializedGraph !== void 0) return materializedGraph;
       materializedGraph = new MaterializedValueGraphContext(
@@ -81455,8 +81715,10 @@ function animationConstructorProjectionTargetValueIds(context, classId, value) {
     return [];
   }
   const targetIds = [];
-  for (const projection of inheritedConstructorProjections2(
+  for (const projection of effectiveConstructorProjections(
     context.manifestClasses,
+    context.manifestConstructors,
+    context.manifestMembers,
     classId
   )) {
     const schemaKey = inheritedProjectionSchemaKey(
@@ -82434,9 +82696,10 @@ function lowerRowBackedDefault(context, member, backed, baseData3, binding) {
     const assignmentSlices = objectInitializerSlices(binding.initializer);
     for (const assignment of expression.initializer ?? []) {
       const childMember = classMemberByName(context, classId, assignment.name);
-      if (inheritedConstructorProjections2(context.classes, schemaClass2.id).some(
-        (projection) => projection.memberId === childMember.id
-      )) {
+      if (inheritedLegacyConstructorProjections(
+        context.classes,
+        schemaClass2.id
+      ).some((projection) => projection.memberId === childMember.id)) {
         throw new Error(
           `Default value ${binding.label}.${assignment.name} is constructor-projected and must be set through its named constructor argument.`
         );
@@ -82847,7 +83110,7 @@ function lowerSeedRow(context, member, sourceExpression, source, valueId, path,
         effectiveClass.id,
         assignment.name
       );
-      if (inheritedConstructorProjections2(
+      if (inheritedLegacyConstructorProjections(
         context.classes,
         effectiveClass.id
       ).some((projection) => projection.memberId === childMember.id)) {
@@ -83350,9 +83613,10 @@ function lowerClassValue(context, member, expression, base, source, outerEnviron
   }
   for (const assignment of expression.initializer ?? []) {
     const childMember = classMemberByName(context, classId, assignment.name);
-    if (inheritedConstructorProjections2(context.classes, schemaClass2.id).some(
-      (projection) => projection.memberId === childMember.id
-    )) {
+    if (inheritedLegacyConstructorProjections(
+      context.classes,
+      schemaClass2.id
+    ).some((projection) => projection.memberId === childMember.id)) {
       throw new Error(
         `Class value ${String(base.id)}.${assignment.name} is constructor-projected and must be set through its named constructor argument.`
       );
@@ -83532,7 +83796,7 @@ function classInheritanceChain(classes, classId) {
   }
   return chain;
 }
-function inheritedConstructorProjections2(classes, classId) {
+function inheritedLegacyConstructorProjections(classes, classId) {
   const resolved = [];
   const claimed = /* @__PURE__ */ new Set();
   for (const schemaClass2 of classInheritanceChain(classes, classId)) {
@@ -83544,6 +83808,67 @@ function inheritedConstructorProjections2(classes, classId) {
   }
   return resolved;
 }
+function effectiveConstructorProjections(classes, constructors, members, classId) {
+  const schemaClass2 = classes.get(classId);
+  const requiredId = schemaClass2?.requiredConstructorId;
+  if (schemaClass2 === void 0 || requiredId === void 0) {
+    return inheritedLegacyConstructorProjections(classes, classId);
+  }
+  const required2 = constructors.get(requiredId);
+  if (required2 === void 0) return [];
+  const projected = requiredConstructorProjectionMap(
+    classes,
+    constructors,
+    members,
+    classId,
+    /* @__PURE__ */ new Set()
+  );
+  if (required2.arguments.some((parameter3) => !projected.has(parameter3.name))) {
+    return [];
+  }
+  return required2.arguments.map((parameter3) => ({
+    parameterName: parameter3.name,
+    memberId: projected.get(parameter3.name)
+  }));
+}
+function requiredConstructorProjectionMap(classes, constructors, members, classId, visited) {
+  if (visited.has(classId)) return /* @__PURE__ */ new Map();
+  const schemaClass2 = classes.get(classId);
+  const requiredId = schemaClass2?.requiredConstructorId;
+  const required2 = requiredId === void 0 ? void 0 : constructors.get(requiredId);
+  if (schemaClass2 === void 0 || required2 === void 0) return /* @__PURE__ */ new Map();
+  const result = /* @__PURE__ */ new Map();
+  for (const memberId of Object.values(schemaClass2.schema)) {
+    const initializer = members.get(memberId)?.defaultValue;
+    if (initializer === null || initializer === void 0 || !("init" in initializer)) {
+      continue;
+    }
+    const parameterName = initializer.init.code.trim();
+    if (required2.arguments.some((parameter3) => parameter3.name === parameterName)) {
+      result.set(parameterName, memberId);
+    }
+  }
+  const baseClassId = schemaClass2.extendsClassId;
+  if (baseClassId === null) return result;
+  const base = requiredConstructorProjectionMap(
+    classes,
+    constructors,
+    members,
+    baseClassId,
+    /* @__PURE__ */ new Set([...visited, classId])
+  );
+  for (const forwarded of required2.baseArguments ?? []) {
+    const sourceName = forwarded.code.trim();
+    if (!required2.arguments.some((parameter3) => parameter3.name === sourceName)) {
+      continue;
+    }
+    const memberId = base.get(forwarded.name);
+    if (memberId !== void 0 && !result.has(sourceName)) {
+      result.set(sourceName, memberId);
+    }
+  }
+  return result;
+}
 function inheritedProjectionSchemaKey(classes, classId, memberId) {
   for (const schemaClass2 of classInheritanceChain(classes, classId)) {
     for (const [schemaKey, declared] of Object.entries(schemaClass2.schema)) {
@@ -83553,8 +83878,10 @@ function inheritedProjectionSchemaKey(classes, classId, memberId) {
   return null;
 }
 function resolveConstructorProjectionArguments(context, schemaClass2, expression, ownerValueId, environment, source) {
-  const projections = inheritedConstructorProjections2(
+  const projections = effectiveConstructorProjections(
     context.classes,
+    context.manifestConstructors,
+    context.members,
     schemaClass2.id
   );
   const signature = describeProjectedConstructor(schemaClass2.name, projections);
@@ -85208,13 +85535,37 @@ function classValue(context, member, value, visited, targetTyped, outerEnvironme
   if (!isObjectRecord2(value.value))
     return targetTyped ? "new()" : `new ${classValueTypeName(context, classId, member, storedEnvironment)}()`;
   const schema = isObjectRecord2(schemaClass2.schema) ? schemaClass2.schema : {};
-  const projection = constructorProjectionSource(
-    context,
-    classId,
-    value.value,
-    visited,
-    storedEnvironment
-  );
+  const hasStoredConstruction = isObjectRecord2(value.constructorArgs);
+  let projection;
+  try {
+    projection = hasStoredConstruction ? {
+      arguments: [],
+      memberIds: new Set(
+        effectiveConstructorProjections(
+          context.manifestClasses,
+          context.manifestConstructors,
+          context.manifestMembers,
+          classId
+        ).map((entry) => entry.memberId)
+      ),
+      targetValueIds: animationConstructorProjectionTargetValueIds(
+        context,
+        classId,
+        value
+      )
+    } : constructorProjectionSource(
+      context,
+      classId,
+      value.value,
+      visited,
+      storedEnvironment
+    );
+  } catch (error) {
+    throw new Error(
+      `Constructor projection for value "${String(value.id ?? "unknown")}" of class "${schemaClass2.name}" cannot be emitted: ${error instanceof Error ? error.message : String(error)}`,
+      { cause: error }
+    );
+  }
   const environment = inferAnimationChildOverrideEmitEnvironment(
     context,
     classId,
@@ -85222,15 +85573,23 @@ function classValue(context, member, value, visited, targetTyped, outerEnvironme
     storedEnvironment
   );
   const name = classValueTypeName(context, classId, member, environment);
-  const storedConstruction = storedConstructorCallSource(
-    context,
-    schemaClass2,
-    value,
-    name,
-    environment,
-    visited,
-    targetTyped
-  );
+  let storedConstruction;
+  try {
+    storedConstruction = storedConstructorCallSource(
+      context,
+      schemaClass2,
+      value,
+      name,
+      environment,
+      visited,
+      targetTyped
+    );
+  } catch (error) {
+    throw new Error(
+      `Stored construction for value "${String(value.id ?? "unknown")}" of class "${name}" cannot be emitted: ${error instanceof Error ? error.message : String(error)}`,
+      { cause: error }
+    );
+  }
   if (storedConstruction !== null && typeof value.id === "string") {
     context.materializedConstructors.set(value.id, storedConstruction);
   }
@@ -85248,7 +85607,7 @@ function classValue(context, member, value, visited, targetTyped, outerEnvironme
     context,
     value.id,
     replayConstruction,
-    member
+    concreteClassMemberForReplay(member, environment)
   );
   const replayRoot = replayRows === null || typeof value.id !== "string" ? void 0 : replayRows.get(value.id);
   const replayGraph = replayRows === null || typeof value.id !== "string" ? null : context.readMaterializedGraph().withRowOverrides(
@@ -85334,11 +85693,27 @@ function storedConstructionReplayRows(context, valueId, code, member) {
     document: context.readDocument(),
     valueId,
     code,
-    member
+    member,
+    compilationProject: context.readCompilationProject()
   });
   context.constructionReplays.set(valueId, replay);
   return replay;
 }
+function concreteClassMemberForReplay(member, environment) {
+  if (numberField(member, "kind") !== 7 /* Class */) return member;
+  const classArguments2 = isObjectRecord2(member.classArguments) ? member.classArguments : {};
+  let changed = false;
+  const concreteArguments = Object.fromEntries(
+    Object.entries(classArguments2).map(([genericParamId, binding]) => {
+      const forwardedParamId = isObjectRecord2(binding) && binding.kind === "generic" && typeof binding.genericParamId === "string" ? binding.genericParamId : null;
+      const bindingMemberId = environment.get(genericParamId) ?? (forwardedParamId === null ? void 0 : environment.get(forwardedParamId));
+      if (bindingMemberId === void 0) return [genericParamId, binding];
+      changed = true;
+      return [genericParamId, { kind: "member", memberId: bindingMemberId }];
+    })
+  );
+  return changed ? { ...member, classArguments: concreteArguments } : member;
+}
 function materializedValueSubgraphsEqual(context, currentGraph, replayGraph, currentId, replayId, member, environment) {
   const resolvedMember = resolveGenericValueMember(
     context,
@@ -85510,8 +85885,30 @@ function storedConstructorArgumentSource(context, type, value, environment, visi
         false
       );
     }
+    case "generic": {
+      const bindingId = environment.get(type.genericParamId);
+      const inferredClassId = inferredGenericClassId(bindingId);
+      const resolvedType = inferredClassId === null ? bindingId === void 0 ? null : schemaTypeForBindingMember(context, bindingId, environment) : {
+        kind: "class",
+        nullable: type.nullable,
+        classId: inferredClassId,
+        classArguments: {}
+      };
+      if (resolvedType === null) {
+        throw new Error(
+          `Stored Generic constructor argument cannot resolve parameter ${type.genericParamId}.`
+        );
+      }
+      return storedConstructorArgumentSource(
+        context,
+        { ...resolvedType, nullable: type.nullable || resolvedType.nullable },
+        value,
+        environment,
+        visited,
+        cloneAggregateArguments
+      );
+    }
     case "interface":
-    case "generic":
     case "list":
     case "dictionary":
       if (typeof value !== "string") {
@@ -85562,6 +85959,147 @@ function storedConstructorArgumentSource(context, type, value, environment, visi
       );
   }
 }
+function schemaTypeForBindingMember(context, memberId, environment, visited = /* @__PURE__ */ new Set()) {
+  if (visited.has(memberId)) {
+    throw new Error(
+      `Stored constructor argument generic binding contains a member cycle at ${memberId}.`
+    );
+  }
+  const member = context.manifestMembers.get(memberId);
+  if (member === void 0) {
+    throw new Error(
+      `Stored constructor argument generic binding names missing member ${memberId}.`
+    );
+  }
+  const nullable = !member.required;
+  const nextVisited = /* @__PURE__ */ new Set([...visited, memberId]);
+  switch (member.kind) {
+    case "null":
+    case "bool":
+    case "int":
+    case "string":
+    case "float":
+    case "decimal":
+    case "sprite":
+    case "audio":
+    case "vector2":
+    case "vector2Int":
+    case "vector3":
+    case "vector3Int":
+    case "color":
+      return { kind: member.kind, nullable };
+    case "class":
+      return {
+        kind: "class",
+        nullable,
+        classId: member.classId,
+        classArguments: Object.fromEntries(
+          Object.entries(member.classArguments).map(
+            ([parameterId, binding]) => [
+              parameterId,
+              binding.kind === "member" ? schemaTypeForBindingMember(
+                context,
+                binding.memberId,
+                environment,
+                nextVisited
+              ) : schemaTypeForBindingMember(
+                context,
+                requiredGenericBindingMemberId(
+                  environment,
+                  binding.genericParamId
+                ),
+                environment,
+                nextVisited
+              )
+            ]
+          )
+        )
+      };
+    case "enum":
+      return { kind: "enum", nullable, enumId: member.enumId };
+    case "list":
+      return {
+        kind: "list",
+        nullable,
+        entryType: schemaTypeForBindingMember(
+          context,
+          member.entryMemberId,
+          environment,
+          nextVisited
+        ),
+        listMemberId: member.id,
+        readOnly: member.isReadOnly
+      };
+    case "dictionary":
+      return {
+        kind: "dictionary",
+        nullable,
+        entryType: schemaTypeForBindingMember(
+          context,
+          member.entryMemberId,
+          environment,
+          nextVisited
+        ),
+        keyEnumId: member.key.kind === "enum" ? member.key.enumId : null,
+        readOnly: member.isReadOnly
+      };
+    case "lookup": {
+      if (member.declaredType !== null) {
+        return { ...member.declaredType, nullable };
+      }
+      const collection = context.manifestMembers.get(member.collectionMemberId);
+      if (collection?.kind !== "list" && collection?.kind !== "dictionary") {
+        throw new Error(
+          `Stored constructor argument Lookup binding ${member.id} has no collection entry type.`
+        );
+      }
+      return {
+        kind: "lookup",
+        nullable,
+        entryType: schemaTypeForBindingMember(
+          context,
+          collection.entryMemberId,
+          environment,
+          nextVisited
+        ),
+        collectionMemberId: member.collectionMemberId,
+        collectionValueId: member.collectionValueId
+      };
+    }
+    case "dialogueLookup":
+      return { kind: "dialogueLookup", nullable };
+    case "delegate":
+      return {
+        kind: "delegate",
+        nullable,
+        returnType: member.returnType,
+        argumentTypes: member.arguments.map((argument2) => argument2.type)
+      };
+    case "generic":
+      return schemaTypeForBindingMember(
+        context,
+        requiredGenericBindingMemberId(environment, member.genericParamId),
+        environment,
+        nextVisited
+      );
+    case "computed":
+    case "function":
+    case "scriptFunction":
+    case "functionRef":
+      throw new Error(
+        `Stored constructor argument cannot use ${member.kind} member ${member.id} as a generic type binding.`
+      );
+  }
+}
+function requiredGenericBindingMemberId(environment, genericParamId) {
+  const bindingId = environment.get(genericParamId);
+  if (bindingId === void 0 || inferredGenericClassId(bindingId) !== null) {
+    throw new Error(
+      `Stored constructor argument cannot resolve generic binding ${genericParamId} to a member.`
+    );
+  }
+  return bindingId;
+}
 function storedAggregateCloneSource(context, type, valueId, environment) {
   if (!context.values.has(valueId)) {
     throw new Error(
@@ -85861,8 +86399,10 @@ function manifestMemberTypeName(context, member) {
   return fixedSourceTypeNameForKind(member.kind) ?? member.kind;
 }
 function constructorProjectionSource(context, classId, body, visited, environment) {
-  const projections = inheritedConstructorProjections2(
+  const projections = effectiveConstructorProjections(
     context.manifestClasses,
+    context.manifestConstructors,
+    context.manifestMembers,
     classId
   );
   const argumentsValue = [];
@@ -86456,6 +86996,7 @@ var init_value_sources = __esm({
     init_member_value_id();
     init_members();
     init_compile_ns_property();
+    init_compile();
     init_constructor_argument_ownership();
     init_structured_leaf_source();
     init_member_kind_type_names();

package/package.json

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

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

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