@neocompose/cli 0.22.2 → 0.22.3

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## [0.22.3] - 2026-08-04
+
+### Fixed
+
+- Bundled Neo system classes now derive required and optional constructors from
+  their authored declarations as first-class `system_*` constructor records
+  instead of repurposing constructor projections.
+- Pull, source lowering, local initializer replay, and push preserve those
+  constructors and their inherited parameter scopes, including initializer-
+  backed child rows such as animation segment frames.
+
 ## [0.22.2] - 2026-08-04
 
 ### Changed

package/dist/neo.mjs

@@ -1369,6 +1369,9 @@ function isNeoScriptTypeAssignable(source, target, project) {
   if (source.kind === "typeParameter" && target.kind === "typeParameter") {
     return source.id === target.id;
   }
+  if (source.kind === "typeParameter" && source.constraint !== void 0) {
+    return isNeoScriptTypeAssignable(source.constraint, target, project);
+  }
   if (source.kind === "list" && target.kind === "list") {
     return isNeoScriptTypeAssignable(
       source.elementType,
@@ -29056,7 +29059,7 @@ function memberFromDocument(record3, members, owners, classNames, context) {
   );
   const modifier = memberModifier(overrideOf, isVirtual, isAbstract);
   const defaultValue = defaultValueFromDocument(
-    field("defaultValue", null),
+    overrideOf !== null && !Object.hasOwn(data, "defaultValue") ? null : field("defaultValue", null),
     record3
   );
   const docsText = optionalDocsText(data.docsText, record3, "docsText");
@@ -36759,7 +36762,9 @@ function isMemberGenericBase(value) {
     if (!isSystemMetadata(v.system)) return false;
     if (v.system.kind !== SystemProtectionKind.WorldAuthoring) return false;
   }
-  if (v.defaultValue !== void 0 && v.defaultValue !== null) return false;
+  if (v.defaultValue !== void 0 && v.defaultValue !== null && !isInitValueContent(v.defaultValue)) {
+    return false;
+  }
   if (v.required === true) return false;
   return true;
 }
@@ -38101,10 +38106,20 @@ var init_world_system_classes_generated = __esm({
         docsText: "One value at a frame index inside a segment. It holds until the next row\nyou author, or until the segment's Duration runs out.",
         extendsWorldKind: "animationFrameBase",
         isAbstract: false,
-        constructorProjections: [
+        requiredConstructorId: "system_498d073e-0018-5828-af2b-22b113c31380",
+        constructors: [
           {
-            memberId: "system_b71d1f73-da72-49de-ab9a-911cc9bffa43",
-            parameterName: "value"
+            constructorId: "system_498d073e-0018-5828-af2b-22b113c31380",
+            argumentTypes: [
+              {
+                name: "value",
+                type: 21,
+                required: true,
+                ownerClassId: "system_9c4f3bfb-f0d8-4231-a7e7-9115bab8d5ab",
+                genericParamId: "system_887b11d3-e56a-47ff-8d01-e2fcefb846a1"
+              }
+            ],
+            code: null
           }
         ],
         genericParams: [
@@ -38114,6 +38129,7 @@ var init_world_system_classes_generated = __esm({
           {
             memberId: "system_b71d1f73-da72-49de-ab9a-911cc9bffa43",
             memberKind: "generic",
+            defaultInitializerCode: "value",
             genericParamId: "system_887b11d3-e56a-47ff-8d01-e2fcefb846a1",
             required: false,
             schemaKey: "Value"
@@ -38191,14 +38207,32 @@ var init_world_system_classes_generated = __esm({
         name: "NeoAnimationChildOverride",
         docsText: "What one child looks like while a clip frame holds: which child, and the\nvalues to override on it.",
         isAbstract: false,
-        constructorProjections: [
+        requiredConstructorId: "system_2fefcc00-08ab-5a16-a76a-758beac24ef1",
+        constructors: [
           {
-            memberId: "system_48e66117-43fe-4429-97a8-964165f063ea",
-            parameterName: "selector"
-          },
-          {
-            memberId: "system_819b3743-0c3d-4896-b679-9aeeb73255f4",
-            parameterName: "overrides"
+            constructorId: "system_2fefcc00-08ab-5a16-a76a-758beac24ef1",
+            argumentTypes: [
+              {
+                name: "selector",
+                type: 25,
+                required: true,
+                returnTypeInfo: {
+                  type: 21,
+                  required: true,
+                  ownerClassId: "system_e2e88eba-5335-4a16-9dcf-2c0e1951e8bd",
+                  genericParamId: "system_de23448a-45be-4e3f-8965-072a545e08f0"
+                },
+                argumentTypes: []
+              },
+              {
+                name: "overrides",
+                type: 21,
+                required: true,
+                ownerClassId: "system_e2e88eba-5335-4a16-9dcf-2c0e1951e8bd",
+                genericParamId: "system_de23448a-45be-4e3f-8965-072a545e08f0"
+              }
+            ],
+            code: null
           }
         ],
         genericParams: [
@@ -38212,6 +38246,7 @@ var init_world_system_classes_generated = __esm({
           {
             memberId: "system_48e66117-43fe-4429-97a8-964165f063ea",
             memberKind: "delegate",
+            defaultInitializerCode: "selector",
             returnTypeInfo: {
               type: 21,
               required: true,
@@ -38234,6 +38269,7 @@ var init_world_system_classes_generated = __esm({
           {
             memberId: "system_819b3743-0c3d-4896-b679-9aeeb73255f4",
             memberKind: "generic",
+            defaultInitializerCode: "overrides",
             genericParamId: "system_de23448a-45be-4e3f-8965-072a545e08f0",
             partial: true,
             required: false,
@@ -38247,16 +38283,31 @@ var init_world_system_classes_generated = __esm({
         name: "NeoAnimationTrackBase",
         docsText: "A lane on a clip's timeline: which child it plays against, when it starts,\nwhich way it runs, and which slice of the content to use. Both kinds of\ntrack derive from this, so playing a child clip reversed or cropped is\nsomething you author on the lane rather than pass in when you play it.",
         isAbstract: true,
-        constructorProjections: [
+        requiredConstructorId: "system_8980d09b-0a6d-5461-9615-2f524515b1af",
+        constructors: [
           {
-            memberId: "system_1e877396-1802-474a-9e4d-1df478d4c888",
-            parameterName: "selector"
+            constructorId: "system_8980d09b-0a6d-5461-9615-2f524515b1af",
+            argumentTypes: [
+              {
+                name: "selector",
+                type: 25,
+                required: true,
+                returnTypeInfo: {
+                  type: 7,
+                  required: true,
+                  classId: "system_61b30a92-90dc-4bf8-8503-ee4f6414effc"
+                },
+                argumentTypes: []
+              }
+            ],
+            code: null
           }
         ],
         schemaFields: [
           {
             memberId: "system_1e877396-1802-474a-9e4d-1df478d4c888",
             memberKind: "delegate",
+            defaultInitializerCode: "selector",
             returnTypeInfo: {
               type: 7,
               required: true,
@@ -38330,20 +38381,33 @@ var init_world_system_classes_generated = __esm({
         docsText: "Plays another object's clip on this clip's timeline, looked up by name. The\nlane is as long as the clip it names.",
         extendsWorldKind: "animationTrack",
         isAbstract: false,
-        constructorProjections: [
+        requiredConstructorId: "system_6baa12a7-be86-5ae0-82da-2fed308320a0",
+        constructors: [
           {
-            memberId: "system_1e877396-1802-474a-9e4d-1df478d4c888",
-            parameterName: "selector"
-          },
-          {
-            memberId: "system_2c816624-0281-46d3-9ed5-d20bd43519f4",
-            parameterName: "clipKey"
+            constructorId: "system_6baa12a7-be86-5ae0-82da-2fed308320a0",
+            argumentTypes: [
+              {
+                name: "selector",
+                type: 25,
+                required: true,
+                returnTypeInfo: {
+                  type: 7,
+                  required: true,
+                  classId: "system_61b30a92-90dc-4bf8-8503-ee4f6414effc"
+                },
+                argumentTypes: []
+              },
+              { name: "clipKey", type: 3, required: true }
+            ],
+            code: null,
+            baseArguments: [{ name: "selector", code: "selector" }]
           }
         ],
         schemaFields: [
           {
             memberId: "system_2c816624-0281-46d3-9ed5-d20bd43519f4",
             memberKind: "string",
+            defaultInitializerCode: "clipKey",
             localizable: false,
             required: true,
             schemaKey: "ClipKey"
@@ -38357,10 +38421,26 @@ var init_world_system_classes_generated = __esm({
         docsText: "Plays a sequence of values onto one member of one child, on the owning\nclip's clock. Where a child track hands off to another clip, this lane is a\nleaf: it writes one value per frame to the member its subclass targets.\n\nDerive from it with the child type you author against, so that a Segment\ngetter can reach that child's own members.",
         extendsWorldKind: "animationTrack",
         isAbstract: true,
-        constructorProjections: [
+        requiredConstructorId: "system_1e7f8826-5392-5b4c-8cc3-6052d20e5280",
+        constructors: [
           {
-            memberId: "system_b29e7ab9-0b8e-4399-84c1-1203070b75dd",
-            parameterName: "selector"
+            constructorId: "system_1e7f8826-5392-5b4c-8cc3-6052d20e5280",
+            argumentTypes: [
+              {
+                name: "selector",
+                type: 25,
+                required: true,
+                returnTypeInfo: {
+                  type: 21,
+                  required: true,
+                  ownerClassId: "system_fd551dd8-6e6b-4044-9f32-7445ab344200",
+                  genericParamId: "system_d4fe9f71-d9d9-4baf-bc52-8de16933b655"
+                },
+                argumentTypes: []
+              }
+            ],
+            code: null,
+            baseArguments: [{ name: "selector", code: "selector" }]
           }
         ],
         genericParams: [
@@ -38376,6 +38456,7 @@ var init_world_system_classes_generated = __esm({
             memberId: "system_b29e7ab9-0b8e-4399-84c1-1203070b75dd",
             memberKind: "delegate",
             extendsMemberId: "system_1e877396-1802-474a-9e4d-1df478d4c888",
+            defaultInitializerCode: "selector",
             docsText: "The child this lane plays against, typed as the child class you derived with, so a Segment getter can read that child's own members.",
             returnTypeInfo: {
               type: 21,
@@ -38417,6 +38498,28 @@ var init_world_system_classes_generated = __esm({
         docsText: "Plays a sprite segment onto a sprite child's Sprite member \u2014 the lane that\nanimates a sprite over time. Derive from it to say where the segment comes\nfrom; Segment is left for you to fill in, so every lane that plays is one of\nyour own classes.",
         extendsWorldKind: "animationSegmentTrack",
         isAbstract: true,
+        requiredConstructorId: "system_9a3f52ca-872a-50a5-aad9-e9a040f40802",
+        constructors: [
+          {
+            constructorId: "system_9a3f52ca-872a-50a5-aad9-e9a040f40802",
+            argumentTypes: [
+              {
+                name: "selector",
+                type: 25,
+                required: true,
+                returnTypeInfo: {
+                  type: 21,
+                  required: true,
+                  ownerClassId: "system_24b70585-0798-49ad-b650-4c118bac1eb1",
+                  genericParamId: "system_4de90637-6a3b-4bba-95ef-2ff9dfb05268"
+                },
+                argumentTypes: []
+              }
+            ],
+            code: null,
+            baseArguments: [{ name: "selector", code: "selector" }]
+          }
+        ],
         extendsGenericBindings: {
           "system_d4fe9f71-d9d9-4baf-bc52-8de16933b655": {
             kind: "generic",
@@ -47886,20 +47989,60 @@ function buildDeclaredConstructorIndex(analysis) {
     if (declaration.constructors.length === 0) continue;
     byClassName.set(declaration.name, declaration.constructors);
   }
-  return { byClassName, requiredByClassName };
+  return {
+    byClassName,
+    requiredByClassName,
+    persistedByClassName: /* @__PURE__ */ new Map(),
+    persistedRequiredByClassName: /* @__PURE__ */ new Map()
+  };
+}
+function withPersistedConstructorSignatures(index, classes, constructors) {
+  const byId = new Map(constructors.map((entry) => [entry.id, entry]));
+  const persistedByClassName = /* @__PURE__ */ new Map();
+  const persistedRequiredByClassName = /* @__PURE__ */ new Map();
+  for (const schemaClass2 of classes) {
+    if (schemaClass2.requiredConstructorId !== void 0) {
+      const required2 = byId.get(schemaClass2.requiredConstructorId);
+      if (required2 !== void 0) {
+        persistedRequiredByClassName.set(
+          schemaClass2.name,
+          required2.arguments.map((argument2) => argument2.name)
+        );
+      }
+    }
+    const overloads = (schemaClass2.constructorIds ?? []).flatMap((id2) => {
+      const constructor2 = byId.get(id2);
+      return constructor2 === void 0 ? [] : [constructor2.arguments.map((argument2) => argument2.name)];
+    });
+    if (overloads.length > 0) {
+      persistedByClassName.set(schemaClass2.name, overloads);
+    }
+  }
+  return {
+    ...index,
+    persistedByClassName,
+    persistedRequiredByClassName
+  };
 }
 function declaresConstructors(index, className) {
   if (className === null) return false;
   if (index.requiredByClassName.has(className)) return true;
-  return (index.byClassName.get(className)?.length ?? 0) > 0;
+  if (index.persistedRequiredByClassName.has(className)) return true;
+  return (index.byClassName.get(className)?.length ?? 0) > 0 || (index.persistedByClassName.get(className)?.length ?? 0) > 0;
 }
 function declaresParameterlessConstructor(index, className) {
   if (className === null) return false;
   const required2 = index.requiredByClassName.get(className);
   if (required2 !== void 0 && required2.parameters.length === 0) return true;
+  const persistedRequired = index.persistedRequiredByClassName.get(className);
+  if (persistedRequired !== void 0 && persistedRequired.length === 0) {
+    return true;
+  }
   const declared = index.byClassName.get(className);
-  if (declared === void 0) return false;
-  return declared.some((entry) => entry.parameters.length === 0);
+  if (declared?.some((entry) => entry.parameters.length === 0) === true) {
+    return true;
+  }
+  return index.persistedByClassName.get(className)?.some((parameters) => parameters.length === 0) ?? false;
 }
 function initializerRequiresEvaluation(index, expression, targetClassName, runtimeIdentifiers = /* @__PURE__ */ new Set()) {
   if (expression.kind === "annotated") {
@@ -47925,8 +48068,10 @@ function initializerRequiresEvaluation(index, expression, targetClassName, runti
 function requiredConstructorParameterNames(index, className) {
   if (className === null) return /* @__PURE__ */ new Set();
   const required2 = index.requiredByClassName.get(className);
-  if (required2 === void 0) return /* @__PURE__ */ new Set();
-  return new Set(required2.parameters.map((parameter3) => parameter3.name));
+  if (required2 !== void 0) {
+    return new Set(required2.parameters.map((parameter3) => parameter3.name));
+  }
+  return new Set(index.persistedRequiredByClassName.get(className) ?? []);
 }
 function expressionReadsRuntimeIdentifier(expression, runtimeIdentifiers) {
   if (runtimeIdentifiers.size === 0) return false;
@@ -48019,7 +48164,9 @@ var init_declared_constructors2 = __esm({
     init_src();
     EMPTY_DECLARED_CONSTRUCTOR_INDEX = {
       byClassName: /* @__PURE__ */ new Map(),
-      requiredByClassName: /* @__PURE__ */ new Map()
+      requiredByClassName: /* @__PURE__ */ new Map(),
+      persistedByClassName: /* @__PURE__ */ new Map(),
+      persistedRequiredByClassName: /* @__PURE__ */ new Map()
     };
   }
 });
@@ -50961,7 +51108,14 @@ function classToLanguageType(schemaClass2, context) {
         type: {
           kind: "typeParameter",
           id: parameter3.id,
-          name: parameter3.name
+          name: parameter3.name,
+          ownerClassId: schemaClass2.id,
+          ...parameter3.constraint === void 0 || parameter3.constraint === null ? {} : {
+            constraint: namedType(
+              parameter3.constraint.kind === "class" ? parameter3.constraint.classId : parameter3.constraint.enumId,
+              true
+            )
+          }
         },
         location: virtualIdentifierLocation(
           context,
@@ -51788,10 +51942,20 @@ function toLanguageType(type, context, genericEnvironment) {
       const name = owner?.genericParams?.find(
         (parameter3) => parameter3.id === effectiveParamId
       )?.name ?? effectiveParamId;
+      const declaration = owner?.genericParams?.find(
+        (parameter3) => parameter3.id === effectiveParamId
+      );
       return {
         kind: "typeParameter",
         id: effectiveParamId,
         name,
+        ...owner === void 0 ? {} : { ownerClassId: owner.id },
+        ...declaration?.constraint === void 0 || declaration.constraint === null ? {} : {
+          constraint: namedType(
+            declaration.constraint.kind === "class" ? declaration.constraint.classId : declaration.constraint.enumId,
+            true
+          )
+        },
         nullable: !required2
       };
     }
@@ -52432,7 +52596,7 @@ function compileMemberInitializerBody(args) {
     );
   }
   const members = replaceMember(args.members, args.member);
-  const returnTypeInfo = resolveMemberDeclaredTypeInfo(args.member, members);
+  const returnTypeInfo = resolveMemberDeclaredTypeInfo(args.member, members) ?? initializerGenericTypeInfo(args.member, args.thisClass);
   if (returnTypeInfo === null) {
     throw new Error(
       `Member "${args.member.name}" has an initializer but no resolvable declared type.`
@@ -52469,6 +52633,19 @@ function compileMemberInitializerBody(args) {
   }
   Object.assign(defaultValue.init, { compiled });
 }
+function initializerGenericTypeInfo(member, ownerClass) {
+  if (!isMemberGenericBase(member) || ownerClass === null) return null;
+  const declaration = ownerClass.genericParams?.find(
+    (parameter3) => parameter3.id === member.genericParamId
+  );
+  if (declaration === void 0) return null;
+  return {
+    type: 21 /* Generic */,
+    required: member.required,
+    ownerClassId: ownerClass.id,
+    genericParamId: declaration.id
+  };
+}
 function compileValueRowInitializerBody(args) {
   const container = args.valueRow;
   if (!isInitValueContent(container)) return;
@@ -52644,6 +52821,11 @@ function compileConstructorBaseArguments(args, owner) {
           `Constructor "${args.constructor.id}" binds base argument "${baseArgument.name}", which base constructor "${baseConstructor.id}" does not declare.`
         );
       }
+      const returnTypeInfo = substituteConstructorBaseType(
+        parameter3,
+        owner,
+        args
+      );
       return compileUnit2(
         "getter",
         () => compileNSInitializer(baseArgument.code, {
@@ -52655,7 +52837,7 @@ function compileConstructorBaseArguments(args, owner) {
           interfaces: [...args.interfaces ?? []],
           constructors: args.constructors,
           ...args.compilationProject === void 0 ? {} : { compilationProject: args.compilationProject },
-          returnTypeInfo: parameter3,
+          returnTypeInfo,
           argumentTypes,
           initializerName: `${owner.name} base argument ${baseArgument.name}`
         })
@@ -52664,6 +52846,65 @@ function compileConstructorBaseArguments(args, owner) {
   );
   Object.assign(args.constructor, { compiledBaseArguments });
 }
+function substituteConstructorBaseType(typeInfo, owner, args) {
+  if (typeInfo.type === 21 /* Generic */) {
+    const binding = resolveGenericEnv(owner.id, args.classes).get(
+      typeInfo.genericParamId
+    );
+    if (binding === void 0) return typeInfo;
+    if (binding.kind === "unbound") {
+      return {
+        ...typeInfo,
+        ownerClassId: owner.id,
+        genericParamId: binding.paramId
+      };
+    }
+    const member = args.members.find(
+      (candidate) => candidate.id === binding.memberId
+    );
+    if (member === void 0) {
+      throw new Error(
+        `Constructor "${args.constructor.id}" resolves generic parameter "${typeInfo.genericParamId}" to missing member "${binding.memberId}".`
+      );
+    }
+    return resolveMemberDeclaredTypeInfo(member, args.members) ?? typeInfo;
+  }
+  if (typeInfo.type === 25 /* NSDelegate */) {
+    return {
+      ...typeInfo,
+      returnTypeInfo: substituteConstructorBaseType(
+        typeInfo.returnTypeInfo,
+        owner,
+        args
+      ),
+      argumentTypes: typeInfo.argumentTypes.map(
+        (argument2) => substituteConstructorBaseType(argument2, owner, args)
+      )
+    };
+  }
+  if (typeInfo.type === 6 /* List */ || typeInfo.type === 5 /* Dictionary */ || typeInfo.type === 9 /* Lookup */) {
+    return {
+      ...typeInfo,
+      entryTypeInfo: substituteConstructorBaseType(
+        typeInfo.entryTypeInfo,
+        owner,
+        args
+      )
+    };
+  }
+  if (typeInfo.type !== 7 /* Class */ || typeInfo.typeArguments === void 0) {
+    return typeInfo;
+  }
+  return {
+    ...typeInfo,
+    typeArguments: Object.fromEntries(
+      Object.entries(typeInfo.typeArguments).map(([parameterId, argument2]) => [
+        parameterId,
+        substituteConstructorBaseType(argument2, owner, args)
+      ])
+    )
+  };
+}
 function compileConstructorBaseInitializerFields(args, owner) {
   const fields = args.constructor.baseInitializerFields ?? [];
   if (fields.length === 0) {
@@ -52983,6 +53224,7 @@ var init_compile_ns_property = __esm({
     "use strict";
     init_members();
     init_inheritance();
+    init_generics();
     init_neoscript();
     init_core();
     init_lookup_declared_type();
@@ -53196,6 +53438,19 @@ var init_value_row_owner_members = __esm({
 });
 
 // ../src/database/constructor-argument-ownership.ts
+function constructorActionParameterId(constructor2, index) {
+  const action = constructor2.action;
+  if (action !== null && typeof action === "object") {
+    const parameters = action.parameters;
+    if (Array.isArray(parameters)) {
+      const parameter3 = parameters[index + 2];
+      if (parameter3 !== null && typeof parameter3 === "object" && typeof parameter3.id === "string") {
+        return parameter3.id;
+      }
+    }
+  }
+  return `__arg_${index}__`;
+}
 function createTypedValueNormalizer(rows, document, childrenByContainerId, parameterTypesForRow, memberById, memberTypeInfo) {
   const visiting = /* @__PURE__ */ new Set();
   const normalizeLiteral = (value) => {
@@ -53550,7 +53805,7 @@ var init_constructor_argument_ownership = __esm({
         }
         const env = rowGenericEnvironment(this.document, root);
         for (let index = 0; index < constructor2.argumentTypes.length; index += 1) {
-          const parameterId = constructor2.action.parameters[index + 2]?.id;
+          const parameterId = constructorActionParameterId(constructor2, index);
           const rawTypeInfo = constructor2.argumentTypes[index];
           if (parameterId === void 0 || rawTypeInfo === void 0) continue;
           const typeInfo = this.resolveTypeInfo(rawTypeInfo, env);
@@ -57590,6 +57845,8 @@ function runtimeTypeCheck(value, checkType, ctx, seenCollections = /* @__PURE__
       return isDecimalString(value);
     case 3 /* String */:
       return typeof value === "string";
+    case 25 /* NSDelegate */:
+      return isNSDelegateClosureValue(value) || isMemberDelegateTarget(value);
     case 11 /* Sprite */:
       return isRuntimeSpriteValue(value);
     case 12 /* Audio */:
@@ -59079,7 +59336,15 @@ function constructClassValueWithinFrame(descriptor, scope, ctx) {
       // A class with no declared constructors can still carry init-backed
       // member defaults (P43 §2, `string Foo = StaticFunc("bar")`), so the
       // schema-derived path evaluates them exactly as the declared one does.
-      initEvaluator: constructionInitEvaluator(ctx, createdValues),
+      initEvaluator: constructionInitEvaluator(
+        ctx,
+        createdValues,
+        {
+          valuesByClassId: /* @__PURE__ */ new Map(),
+          missingScopeReason: "no-constructor"
+        },
+        classId
+      ),
       constructorRoot: {
         providedSchemaKeys: new Set(
           supplied.filter((entry) => entry.value !== null).map((entry) => entry.validated.schemaKey)
@@ -59330,15 +59595,17 @@ function runDeclaredConstructorChain(args) {
   args.visitedConstructorIds.add(record3.id);
   const baseRecord = resolveBaseConstructorRecord(record3, ctx);
   if (baseRecord !== null) {
+    const preparedBaseArguments = args.preparedArgumentScopes.valuesByClassId.get(baseRecord.classId);
     runDeclaredConstructorChain({
       record: baseRecord,
-      argumentValues: evaluateBaseConstructorArguments(
+      argumentValues: preparedBaseArguments ?? evaluateBaseConstructorArguments(
         record3,
         baseRecord,
         args.argumentValues,
         args.thisValue,
         ctx
       ),
+      preparedArgumentScopes: args.preparedArgumentScopes,
       thisValue: args.thisValue,
       ctx,
       visitedConstructorIds: args.visitedConstructorIds,
@@ -59443,13 +59710,165 @@ function evaluateBaseInitializerFields(args) {
     return { validated, value };
   });
 }
-function constructionInitEvaluator(ctx, createdValues, argumentValues = []) {
-  return (member, init) => evaluateInitializerInContext(
-    init,
-    member,
-    ctx,
-    createdValues,
-    argumentValues
+function constructionInitEvaluator(ctx, createdValues, argumentScopes, constructedClassId) {
+  const indexes = constructorInitializerIndexes(ctx);
+  const inheritanceChain = resolveInheritanceChain(
+    constructedClassId,
+    ctx.vm.classes
+  );
+  const owningClassId = (memberId) => {
+    const visited = /* @__PURE__ */ new Set();
+    let currentId = memberId;
+    while (currentId !== void 0 && !visited.has(currentId)) {
+      visited.add(currentId);
+      const declaringClassIds = indexes.declaringClassIdsByMemberId.get(currentId);
+      const owner = inheritanceChain.find(
+        (schemaClass2) => declaringClassIds?.has(schemaClass2.id)
+      );
+      if (owner !== void 0) return owner.id;
+      currentId = indexes.containerMemberIdByEntryId.get(currentId) ?? indexes.memberById.get(currentId)?.extendsMemberId;
+    }
+    return null;
+  };
+  return (member, init) => {
+    if (init.compiled === void 0) {
+      return evaluateInitializerInContext(init, member, ctx, createdValues);
+    }
+    const memberId = Reflect.get(member, "id");
+    const scopeMemberId = indexes.initializerScopeMemberIds.get(init) ?? (typeof memberId === "string" ? memberId : "");
+    const ownerClassId = owningClassId(scopeMemberId);
+    const expectedArgumentCount = init.compiled?.parameters.slice(2).length;
+    if (ownerClassId === null) {
+      if (expectedArgumentCount !== void 0 && expectedArgumentCount > 0) {
+        throw new NSGetterRuntimeError(
+          `Member initializer '${member.name}' has ${expectedArgumentCount} constructor parameter(s), but its declaring class scope could not be resolved.`
+        );
+      }
+      return evaluateInitializerInContext(init, member, ctx, createdValues);
+    }
+    const scopedArguments = argumentScopes.valuesByClassId.get(ownerClassId);
+    if (scopedArguments === void 0) {
+      if (expectedArgumentCount === 0) {
+        return evaluateInitializerInContext(init, member, ctx, createdValues);
+      }
+      if (argumentScopes.missingScopeReason === "no-constructor") {
+        throw new NSGetterRuntimeError(
+          `Member initializer '${member.name}' on '${ownerClassId}' cannot read constructor parameters because schema-derived construction invoked no constructor.`
+        );
+      }
+      throw new NSGetterRuntimeError(
+        `Member initializer '${member.name}' on '${ownerClassId}' cannot read constructor parameters because its ': base(...)' arguments depend on initialized 'this'.`
+      );
+    }
+    if (expectedArgumentCount !== void 0 && expectedArgumentCount !== scopedArguments.length) {
+      throw new NSGetterRuntimeError(
+        `Member initializer '${member.name}' on '${ownerClassId}' expected ${expectedArgumentCount} constructor argument(s), got ${scopedArguments.length}.`
+      );
+    }
+    return evaluateInitializerInContext(
+      init,
+      member,
+      ctx,
+      createdValues,
+      scopedArguments
+    );
+  };
+}
+function constructorInitializerIndexes(ctx) {
+  if (ctx.__constructorInitializerIndexes !== void 0) {
+    return ctx.__constructorInitializerIndexes;
+  }
+  const initializerScopeMemberIds = /* @__PURE__ */ new WeakMap();
+  const initializerByValueId = /* @__PURE__ */ new Map();
+  for (const row of ctx.vm.values) {
+    const initializer = Reflect.get(row, "init");
+    if (initializer !== void 0)
+      initializerByValueId.set(row.id, initializer);
+  }
+  for (const member of ctx.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 declaringClassIdsByMemberId = /* @__PURE__ */ new Map();
+  for (const schemaClass2 of ctx.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 containerMemberIdByEntryId = /* @__PURE__ */ new Map();
+  for (const member of ctx.vm.members) {
+    if (isMemberList(member) || isMemberDictionary(member)) {
+      containerMemberIdByEntryId.set(member.entryMemberId, member.id);
+    }
+  }
+  const built = {
+    initializerScopeMemberIds,
+    declaringClassIdsByMemberId,
+    memberById,
+    containerMemberIdByEntryId
+  };
+  ctx.__constructorInitializerIndexes = built;
+  return built;
+}
+function prepareConstructorArgumentScopes(record3, argumentValues, ctx) {
+  const values = /* @__PURE__ */ new Map();
+  let current = record3;
+  let currentValues = argumentValues;
+  while (current !== null) {
+    values.set(current.classId, currentValues);
+    const base = resolveBaseConstructorRecord(current, ctx);
+    if (base === null) break;
+    if (baseArgumentGettersReferenceThis(current)) break;
+    currentValues = evaluateBaseConstructorArguments(
+      current,
+      base,
+      currentValues,
+      null,
+      ctx
+    );
+    current = base;
+  }
+  return {
+    valuesByClassId: values,
+    missingScopeReason: record3 === null ? "no-constructor" : "base-arguments-depend-on-this"
+  };
+}
+function baseArgumentGettersReferenceThis(record3) {
+  return (record3.compiledBaseArguments ?? []).some((getter) => {
+    const thisParameter = getter.parameters[0];
+    return thisParameter !== void 0 && runtimeValueReferencesVariable(getter.instructions, thisParameter.id);
+  });
+}
+function runtimeValueReferencesVariable(value, variableId, visited = /* @__PURE__ */ new WeakSet()) {
+  if (typeof value !== "object" || value === null) return false;
+  if (visited.has(value)) return false;
+  visited.add(value);
+  if (Reflect.get(value, "type") === "variable" /* variable */ && Reflect.get(value, "variableId") === variableId) {
+    return true;
+  }
+  const children = Object.values(Object.getOwnPropertyDescriptors(value)).filter(
+    (descriptor) => "value" in descriptor
+  ).map((descriptor) => descriptor.value);
+  return children.some(
+    (child) => runtimeValueReferencesVariable(child, variableId, visited)
   );
 }
 function evaluateInitializerInContext(init, member, ctx, createdValues, argumentValues = []) {
@@ -59636,6 +60055,11 @@ function constructDeclaredClassValueWithinFrame(descriptor, record3, info, scope
   const schemaClass2 = descriptor.schemaClass;
   const classId = schemaClass2.id;
   const argumentValues = record3 === null ? [] : evaluateDeclaredConstructorArguments(info, record3, scope, ctx);
+  const preparedArgumentScopes = prepareConstructorArgumentScopes(
+    record3,
+    argumentValues,
+    ctx
+  );
   const createdValues = [];
   const storageKeyDeclarations = /* @__PURE__ */ new Map();
   let root;
@@ -59660,7 +60084,8 @@ function constructDeclaredClassValueWithinFrame(descriptor, record3, info, scope
       initEvaluator: constructionInitEvaluator(
         ctx,
         createdValues,
-        argumentValues
+        preparedArgumentScopes,
+        classId
       ),
       constructorRoot: {
         providedSchemaKeys: new Set(
@@ -59721,6 +60146,7 @@ function constructDeclaredClassValueWithinFrame(descriptor, record3, info, scope
     runDeclaredConstructorChain({
       record: record3,
       argumentValues,
+      preparedArgumentScopes,
       thisValue: root.value,
       ctx,
       visitedConstructorIds: /* @__PURE__ */ new Set(),
@@ -60906,6 +61332,7 @@ function evaluateMemberInitializer(args) {
       constructors: args.document.constructors,
       interfaces: args.document.interfaces,
       localizedTexts: args.document.localizedTexts,
+      localizationConfig: args.document.localizationConfig,
       databaseVM: initializerEvaluatorLookups(args.document)
     },
     thisValue: null,
@@ -61070,6 +61497,14 @@ function isNeoClassConstructorBase(value) {
   }
   return v.compiledBaseInitializerFields === void 0 || v.compiledBaseInitializerFields === null;
 }
+function isUncompiledNeoClassConstructor(value) {
+  if (!isNeoClassConstructorBase(value)) return false;
+  const v = value;
+  if (typeof v.id !== "string" || v.id.length === 0) return false;
+  if (typeof v.projectId !== "string" || v.projectId.length === 0) return false;
+  if (!isEpochMillis(v.createdAt)) return false;
+  return isEpochMillis(v.updatedAt);
+}
 function hasValidConstructorAction(action, argumentTypes) {
   if (!isNSFunctionWithReturnType(action)) return false;
   if (action.typeInfo.type !== 0 /* Null */) return false;
@@ -62461,7 +62896,7 @@ function readProjectDocument(value, options = {}) {
     constructors: readOptionalArrayField(
       value,
       "constructors",
-      isNeoClassConstructor
+      options.constructors === "authored-or-compiled" ? (candidate) => isNeoClassConstructor(candidate) || isUncompiledNeoClassConstructor(candidate) : isNeoClassConstructor
     ),
     internalRecordRelations: readOptionalArrayField(
       value,
@@ -68291,6 +68726,7 @@ function collectNeoScriptRecompileTargets(args) {
   if (args.forceRecompile === true) return completeTargets(args.postDocument);
   const explicit = explicitTargetIds(args.changes);
   const { impactedIds, impactedTypeNames, constructedClassIds } = collectChangedContractIds(args);
+  for (const id2 of args.additionalImpactedIds ?? []) impactedIds.add(id2);
   includeDerivedConstructionContracts(
     constructedClassIds,
     args.postDocument.classes
@@ -69349,9 +69785,17 @@ function materializeInitializersLocallyV4(args) {
   );
   if (sourceRoots.size === 0) return { roots: [] };
   let document = readPulledProjectDocumentV4(records2);
-  const rootOwners = resolveOwnerMembersForValues(document, sourceRoots);
+  const rootKinds = /* @__PURE__ */ new Map();
+  const rootOwners = resolveOwnerMembersForValues(
+    document,
+    sourceRoots,
+    void 0,
+    void 0,
+    rootKinds
+  );
   const roots = [];
   for (const sourceValueId of sourceRoots) {
+    if (rootKinds.get(sourceValueId) === "declaration") continue;
     const rootOwner = rootOwners.get(sourceValueId);
     if (rootOwner === void 0) {
       throw new Error(
@@ -70399,18 +70843,26 @@ function replayAnimationDeclarationInitializersV4(records2, document) {
     const rootOwner = rootOwners.get(row.id);
     const rootOwnerId = Reflect.get(rootOwner ?? {}, "id");
     const initializerOwnerClass = typeof rootOwnerId !== "string" ? null : findSchemaPlacement(rootOwnerId, document.classes)?.ownerClass ?? null;
-    const replay = replayStoredConstructionV4({
-      records: pulled,
-      valueId: row.id,
-      code,
-      member: owner,
-      compileDocumentBodies: true,
-      initializerOwnerClass,
-      // A parameterized declaration is a template. Its arguments exist only
-      // at concrete construction sites, so validate the authored body here
-      // without fabricating values for the class header parameters.
-      evaluate: initializerOwnerClass?.requiredConstructorId === void 0 || initializerOwnerClass.requiredConstructorId === null
-    });
+    let replay;
+    try {
+      replay = replayStoredConstructionV4({
+        records: pulled,
+        valueId: row.id,
+        code,
+        member: owner,
+        compileDocumentBodies: true,
+        initializerOwnerClass,
+        // A parameterized declaration is a template. Its arguments exist only
+        // at concrete construction sites, so validate the authored body here
+        // without fabricating values for the class header parameters.
+        evaluate: initializerOwnerClass?.requiredConstructorId === void 0 || initializerOwnerClass.requiredConstructorId === null
+      });
+    } catch (error) {
+      throw new Error(
+        `Animation declaration replay failed for value "${row.id}": ${error instanceof Error ? error.message : String(error)}`,
+        { cause: error }
+      );
+    }
     for (const [id2, value] of replay) {
       if (!isMemberValue(value)) {
         throw new Error(
@@ -74089,7 +74541,8 @@ function prepareServerOwnedSchemaCommit(args) {
   const hasValueChange = authoredChanges.some(
     (change) => change.recordKind === "value"
   );
-  if (!hasSchemaChange && !hasMigrationChange && !hasDialogueSourceChange && !hasValueChange) {
+  const hasAdditionalContractImpact = (args.additionalImpactedIds?.size ?? 0) > 0;
+  if (!hasSchemaChange && !hasMigrationChange && !hasDialogueSourceChange && !hasValueChange && !hasAdditionalContractImpact) {
     return authoredChanges;
   }
   const authoredPostDocument = applyProjectVersionWriteChanges(
@@ -74100,6 +74553,7 @@ function prepareServerOwnedSchemaCommit(args) {
     currentDocument: args.document,
     postDocument: authoredPostDocument,
     changes: authoredChanges,
+    additionalImpactedIds: args.additionalImpactedIds,
     forceRecompile: args.forceRecompile
   });
   const explicitlyChangedMemberIds = new Set(
@@ -77493,6 +77947,19 @@ function isOpaqueNSTypeInfo(value, ancestors = /* @__PURE__ */ new Set()) {
   if (value.type === 22) {
     return typeof value.interfaceId === "string" && value.interfaceId.length > 0;
   }
+  if (value.type === 25) {
+    if (!Array.isArray(value.argumentTypes) || ancestors.has(value)) {
+      return false;
+    }
+    ancestors.add(value);
+    try {
+      return isOpaqueNSFunctionReturnTypeInfo(value.returnTypeInfo) && value.argumentTypes.every(
+        (argument2) => isOpaqueNSTypeInfo(argument2, ancestors)
+      );
+    } finally {
+      ancestors.delete(value);
+    }
+  }
   if (value.type === 5 || value.type === 6) {
     if (ancestors.has(value)) return false;
     ancestors.add(value);
@@ -77522,6 +77989,11 @@ function opaqueTypeInfoContainsUnknown(value) {
   if (value.type === 5 || value.type === 6 || value.type === 9) {
     return isRecord8(value.entryTypeInfo) && opaqueTypeInfoContainsUnknown(value.entryTypeInfo);
   }
+  if (value.type === 25) {
+    return isRecord8(value.returnTypeInfo) && opaqueTypeInfoContainsUnknown(value.returnTypeInfo) || Array.isArray(value.argumentTypes) && value.argumentTypes.some(
+      (argument2) => isRecord8(argument2) && opaqueTypeInfoContainsUnknown(argument2)
+    );
+  }
   if (value.type !== 7 || !isRecord8(value.typeArguments)) return false;
   return Object.values(value.typeArguments).some(
     (argument2) => isRecord8(argument2) && opaqueTypeInfoContainsUnknown(argument2)
@@ -77536,6 +78008,10 @@ function isOpaqueNSFunctionReturnTypeInfo(value) {
 function isOpaqueNSFunctionArgumentTypeInfo(value) {
   return isOpaqueNSTypeInfo(value) && isOpaqueCallableIdentifier(value.name) && !opaqueTypeInfoContainsUnknown(value);
 }
+function isOpaqueConstructorArgumentTypeInfo(value) {
+  if (!isRecord8(value)) return false;
+  return isOpaqueNSTypeInfo(value) && (value.name === "value" || isOpaqueCallableIdentifier(value.name)) && !opaqueTypeInfoContainsUnknown(value);
+}
 function memberSignature(member) {
   if (member.kind === "property") {
     return `property:${member.settable === true}:${stableTypeInfo(member.typeInfo)}`;
@@ -78887,7 +79363,7 @@ function assertOpaqueConstructorValid(declaredConstructor) {
     );
   }
   const argumentTypes = declaredConstructor.argumentTypes;
-  if (!argumentTypes.every(isOpaqueNSFunctionArgumentTypeInfo)) {
+  if (!argumentTypes.every(isOpaqueConstructorArgumentTypeInfo)) {
     throw new Error(
       `Constructor "${declaredConstructor.id}" argumentTypes are invalid.`
     );
@@ -80665,6 +81141,7 @@ function replayStoredConstructionV4(args) {
     );
   }
   if (args.evaluate === false) return /* @__PURE__ */ new Map();
+  assertPulledConstructorsCompiled(document);
   const compiledDependencies = /* @__PURE__ */ new Set();
   let materialized;
   for (; ; ) {
@@ -80705,6 +81182,7 @@ function compilePulledProjectDocumentBodiesV4(document) {
   for (const constructor2 of compileArgs.constructors) {
     compileConstructorRecord({ ...compileArgs, constructor: constructor2 });
   }
+  assertPulledConstructorsCompiled(document);
   const ownerClassByMemberId = new Map(
     compileArgs.classes.flatMap(
       (schemaClass2) => Object.values(schemaClass2.schema).map(
@@ -80720,6 +81198,16 @@ function compilePulledProjectDocumentBodiesV4(document) {
     });
   }
 }
+function assertPulledConstructorsCompiled(document) {
+  const uncompiled = (document.constructors ?? []).find(
+    (constructor2) => !isNeoClassConstructor(constructor2)
+  );
+  if (uncompiled !== void 0) {
+    throw new Error(
+      `Constructor "${uncompiled.id}" was read from authored source but was not compiled before evaluation.`
+    );
+  }
+}
 function compilePulledMemberInitializerBodyV4(document, memberId) {
   const compileArgs = {
     project: document.project,
@@ -80747,7 +81235,8 @@ function compilePulledMemberInitializerBodyV4(document, memberId) {
 }
 function readPulledProjectDocumentV4(records2) {
   return readProjectDocument(
-    pulledProjectDocumentRaw(replayWorkspace(records2))
+    pulledProjectDocumentRaw(replayWorkspace(records2)),
+    { constructors: "authored-or-compiled" }
   );
 }
 function replayWorkspace(records2) {
@@ -80787,6 +81276,7 @@ var init_initializer_replay = __esm({
     init_project_document_read();
     init_server_preparation_preflight();
     init_projection();
+    init_constructors2();
     init_neoscript_evaluator();
   }
 });
@@ -81154,7 +81644,12 @@ function buildValueLowerContext(state, manifest, options = {}) {
   const classesByName = new Map(
     manifest.classes.map((entry) => [entry.name, entry])
   );
-  const declaredConstructorIndex = options.analysis === void 0 ? EMPTY_DECLARED_CONSTRUCTOR_INDEX : buildDeclaredConstructorIndex(options.analysis);
+  const sourceConstructorIndex = options.analysis === void 0 ? EMPTY_DECLARED_CONSTRUCTOR_INDEX : buildDeclaredConstructorIndex(options.analysis);
+  const declaredConstructorIndex = withPersistedConstructorSignatures(
+    sourceConstructorIndex,
+    manifest.classes,
+    manifest.constructors
+  );
   return {
     state,
     members,

package/package.json

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

package/skills/neocompose-cli/SKILL.md

@@ -9,7 +9,7 @@ description: >-
   `@neocompose/cli` or `node cli/bin/neo.mjs` in the neo-compose repository.
 ---
 
-<!-- reviewed-through-cli: 0.22.2 -->
+<!-- reviewed-through-cli: 0.22.3 -->
 
 # 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.2 -->
+<!-- reviewed-through-cli: 0.22.3 -->
 ```
 
 The quoted version above is checked too, so this instruction cannot go stale