@neocompose/cli 0.22.4 → 0.22.5

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # 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

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) {
@@ -10588,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(
@@ -10608,7 +10609,24 @@ var init_strict_resolver = __esm({
             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
         );
@@ -10649,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(
@@ -38855,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) {
@@ -39137,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();
@@ -58936,7 +59089,14 @@ 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}'.`
     );
@@ -58961,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 = [];
@@ -59012,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);
@@ -59035,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(
@@ -59118,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,
@@ -59353,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;
@@ -60137,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,
@@ -61403,7 +61569,15 @@ function evaluateMemberInitializer(args) {
     rootValue: buildInitializerRootValue(args.document),
     saveStaticBindings: args.saveStaticBindings,
     sessionStaticBindings: args.sessionStaticBindings,
-    ...args.storedConstructionReplay === true ? { storedConstructionReplay: true } : {},
+    ...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()
   };
@@ -61426,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();
@@ -77210,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 } };
@@ -77780,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();
@@ -81227,7 +81410,11 @@ function replayStoredConstructionV4(args) {
       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);
     }
   }
@@ -81277,7 +81464,7 @@ function assertPulledConstructorsCompiled(document) {
     );
   }
 }
-function compilePulledMemberInitializerBodyV4(document, memberId) {
+function compilePulledMemberInitializerBodyV4(document, memberId, compilationProject) {
   const compileArgs = {
     project: document.project,
     projectFiles: document.projectFiles,
@@ -81299,7 +81486,8 @@ function compilePulledMemberInitializerBodyV4(document, memberId) {
   compileMemberInitializerBody({
     ...compileArgs,
     member,
-    thisClass
+    thisClass,
+    ...compilationProject === void 0 ? {} : { compilationProject }
   });
 }
 function readPulledProjectDocumentV4(records2) {
@@ -81373,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(
@@ -81524,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(
@@ -82503,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.`
         );
@@ -82916,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)) {
@@ -83419,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.`
       );
@@ -83601,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)) {
@@ -83613,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)) {
@@ -83622,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);
@@ -85277,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,
@@ -85291,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);
   }
@@ -85317,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(
@@ -85403,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,
@@ -85579,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") {
@@ -85631,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(
@@ -85930,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 = [];
@@ -86525,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.4",
+  "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.4 -->
+<!-- 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.4 -->
+<!-- reviewed-through-cli: 0.22.5 -->
 ```
 
 The quoted version above is checked too, so this instruction cannot go stale