@neocompose/cli 0.22.2 → 0.22.4

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## [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
+
+- 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,
@@ -10393,11 +10396,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
           );
         }
@@ -10592,7 +10602,7 @@ 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
@@ -26029,9 +26039,6 @@ function attachConstructorSignature(type, environment) {
   )) {
     return type;
   }
-  if (resolvedAllowedStorage(type.id, environment) === "immutable") {
-    return { ...type, constructorUnavailableReason: "immutableOnly" };
-  }
   const constructorSignature2 = buildNeoScriptConstructorSignature(
     type.id,
     type.members,
@@ -26049,6 +26056,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) {
@@ -29056,7 +29070,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 +36773,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 +38117,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 +38140,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 +38218,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: [
-          {
-            memberId: "system_48e66117-43fe-4429-97a8-964165f063ea",
-            parameterName: "selector"
-          },
+        requiredConstructorId: "system_2fefcc00-08ab-5a16-a76a-758beac24ef1",
+        constructors: [
           {
-            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 +38257,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 +38280,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 +38294,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 +38392,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: [
-          {
-            memberId: "system_1e877396-1802-474a-9e4d-1df478d4c888",
-            parameterName: "selector"
-          },
+        requiredConstructorId: "system_6baa12a7-be86-5ae0-82da-2fed308320a0",
+        constructors: [
           {
-            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 +38432,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 +38467,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 +38509,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 +48000,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 +48079,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 +48175,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 +51119,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,
@@ -50982,7 +51147,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,
@@ -51788,10 +51979,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
       };
     }
@@ -52142,6 +52343,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,
@@ -52206,9 +52408,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 } : {},
@@ -52432,7 +52635,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 +52672,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;
@@ -52504,7 +52720,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) {
@@ -52644,6 +52861,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 +52877,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 +52886,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 +53264,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 +53478,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 +53845,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);
@@ -54720,7 +55015,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;
@@ -57590,6 +57890,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 */:
@@ -58639,7 +58941,7 @@ function validateClassConstructorDescriptor(info, ctx, requireEveryRequiredField
       `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}'.`
     );
@@ -59079,7 +59381,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 +59640,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 +59755,180 @@ 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 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 vm.values) {
+    const initializer = Reflect.get(row, "init");
+    if (initializer !== void 0)
+      initializerByValueId.set(row.id, initializer);
+  }
+  for (const member of vm.members) {
+    const defaultValue = member.defaultValue;
+    if (isInitValueContent(defaultValue)) {
+      initializerScopeMemberIds.set(defaultValue.init, 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 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(vm.members.map((member) => [member.id, member]));
+  const containerMemberIdByEntryId = /* @__PURE__ */ new Map();
+  for (const member of vm.members) {
+    if (isMemberList(member) || isMemberDictionary(member)) {
+      containerMemberIdByEntryId.set(member.entryMemberId, member.id);
+    }
+  }
+  return {
+    initializerScopeMemberIds,
+    declaringClassIdsByMemberId,
+    memberById,
+    containerMemberIdByEntryId
+  };
+}
+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 +60115,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 +60144,8 @@ function constructDeclaredClassValueWithinFrame(descriptor, record3, info, scope
       initEvaluator: constructionInitEvaluator(
         ctx,
         createdValues,
-        argumentValues
+        preparedArgumentScopes,
+        classId
       ),
       constructorRoot: {
         providedSchemaKeys: new Set(
@@ -59721,6 +60206,7 @@ function constructDeclaredClassValueWithinFrame(descriptor, record3, info, scope
     runDeclaredConstructorChain({
       record: record3,
       argumentValues,
+      preparedArgumentScopes,
       thisValue: root.value,
       ctx,
       visitedConstructorIds: /* @__PURE__ */ new Set(),
@@ -60747,6 +61233,7 @@ var init_evaluateNSGetter = __esm({
     init_interfaces();
     init_neoscript();
     init_NSGetterRuntimeError();
+    init_value_row_owner_members();
     init_decimal();
     init_members();
     init_core();
@@ -60853,17 +61340,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;
@@ -60906,12 +61396,14 @@ 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,
     rootValue: buildInitializerRootValue(args.document),
     saveStaticBindings: args.saveStaticBindings,
     sessionStaticBindings: args.sessionStaticBindings,
+    ...args.storedConstructionReplay === true ? { storedConstructionReplay: true } : {},
     __constructedArgumentsByValue: /* @__PURE__ */ new WeakMap(),
     __createdStorageKeyDeclarations: args.storageKeyDeclarations ?? /* @__PURE__ */ new Map()
   };
@@ -60960,7 +61452,8 @@ function evaluateInitializerMaterialization(args) {
     member: args.member,
     document: args.document,
     createdValues,
-    storageKeyDeclarations
+    storageKeyDeclarations,
+    ...args.storedConstructionReplay === true ? { storedConstructionReplay: true } : {}
   });
   return { evaluated, createdValues, storageKeyDeclarations };
 }
@@ -60968,7 +61461,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,
@@ -61070,6 +61564,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 +62963,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 +68793,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 +69852,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 +70910,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 +74608,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 +74620,7 @@ function prepareServerOwnedSchemaCommit(args) {
     currentDocument: args.document,
     postDocument: authoredPostDocument,
     changes: authoredChanges,
+    additionalImpactedIds: args.additionalImpactedIds,
     forceRecompile: args.forceRecompile
   });
   const explicitlyChangedMemberIds = new Set(
@@ -77493,6 +78014,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 +78056,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 +78075,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 +79430,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.`
     );
@@ -80657,6 +81200,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)) {
@@ -80665,6 +81209,7 @@ function replayStoredConstructionV4(args) {
     );
   }
   if (args.evaluate === false) return /* @__PURE__ */ new Map();
+  assertPulledConstructorsCompiled(document);
   const compiledDependencies = /* @__PURE__ */ new Set();
   let materialized;
   for (; ; ) {
@@ -80674,7 +81219,8 @@ 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) {
@@ -80705,6 +81251,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 +81267,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 +81304,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 +81345,7 @@ var init_initializer_replay = __esm({
     init_project_document_read();
     init_server_preparation_preflight();
     init_projection();
+    init_constructors2();
     init_neoscript_evaluator();
   }
 });
@@ -81154,7 +81713,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.4",
   "description": "Neo Compose native project-source CLI with bidirectional sync.",
   "license": "MIT",
   "type": "module",

package/skills/neocompose-cli/SKILL.md

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