@neocompose/cli 0.77.0 → 0.77.1

package/dist/neo.mjs

@@ -122,36 +122,36 @@ var MemberKind;
 var init_member_kind_enum = __esm({
   "../packages/models/src/members/member-kind-enum.ts"() {
     "use strict";
-    MemberKind = /* @__PURE__ */ ((MemberKind12) => {
-      MemberKind12[MemberKind12["Null"] = 0] = "Null";
-      MemberKind12[MemberKind12["Bool"] = 1] = "Bool";
-      MemberKind12[MemberKind12["Int"] = 2] = "Int";
-      MemberKind12[MemberKind12["String"] = 3] = "String";
-      MemberKind12[MemberKind12["Float"] = 4] = "Float";
-      MemberKind12[MemberKind12["Dictionary"] = 5] = "Dictionary";
-      MemberKind12[MemberKind12["List"] = 6] = "List";
-      MemberKind12[MemberKind12["Class"] = 7] = "Class";
-      MemberKind12[MemberKind12["Enum"] = 8] = "Enum";
-      MemberKind12[MemberKind12["Lookup"] = 9] = "Lookup";
-      MemberKind12[MemberKind12["NSProperty"] = 10] = "NSProperty";
-      MemberKind12[MemberKind12["Sprite"] = 11] = "Sprite";
-      MemberKind12[MemberKind12["Audio"] = 12] = "Audio";
-      MemberKind12[MemberKind12["Function"] = 13] = "Function";
-      MemberKind12[MemberKind12["Vector2"] = 14] = "Vector2";
-      MemberKind12[MemberKind12["Vector2Int"] = 15] = "Vector2Int";
-      MemberKind12[MemberKind12["Vector3"] = 16] = "Vector3";
-      MemberKind12[MemberKind12["Vector3Int"] = 17] = "Vector3Int";
-      MemberKind12[MemberKind12["DialogueLookup"] = 18] = "DialogueLookup";
-      MemberKind12[MemberKind12["Color"] = 19] = "Color";
-      MemberKind12[MemberKind12["Decimal"] = 20] = "Decimal";
-      MemberKind12[MemberKind12["Generic"] = 21] = "Generic";
-      MemberKind12[MemberKind12["Interface"] = 22] = "Interface";
-      MemberKind12[MemberKind12["NSFunction"] = 23] = "NSFunction";
-      MemberKind12[MemberKind12["FunctionRef"] = 24] = "FunctionRef";
-      MemberKind12[MemberKind12["NSDelegate"] = 25] = "NSDelegate";
-      MemberKind12[MemberKind12["NSAction"] = 26] = "NSAction";
-      MemberKind12[MemberKind12["Variant"] = 27] = "Variant";
-      return MemberKind12;
+    MemberKind = /* @__PURE__ */ ((MemberKind11) => {
+      MemberKind11[MemberKind11["Null"] = 0] = "Null";
+      MemberKind11[MemberKind11["Bool"] = 1] = "Bool";
+      MemberKind11[MemberKind11["Int"] = 2] = "Int";
+      MemberKind11[MemberKind11["String"] = 3] = "String";
+      MemberKind11[MemberKind11["Float"] = 4] = "Float";
+      MemberKind11[MemberKind11["Dictionary"] = 5] = "Dictionary";
+      MemberKind11[MemberKind11["List"] = 6] = "List";
+      MemberKind11[MemberKind11["Class"] = 7] = "Class";
+      MemberKind11[MemberKind11["Enum"] = 8] = "Enum";
+      MemberKind11[MemberKind11["Lookup"] = 9] = "Lookup";
+      MemberKind11[MemberKind11["NSProperty"] = 10] = "NSProperty";
+      MemberKind11[MemberKind11["Sprite"] = 11] = "Sprite";
+      MemberKind11[MemberKind11["Audio"] = 12] = "Audio";
+      MemberKind11[MemberKind11["Function"] = 13] = "Function";
+      MemberKind11[MemberKind11["Vector2"] = 14] = "Vector2";
+      MemberKind11[MemberKind11["Vector2Int"] = 15] = "Vector2Int";
+      MemberKind11[MemberKind11["Vector3"] = 16] = "Vector3";
+      MemberKind11[MemberKind11["Vector3Int"] = 17] = "Vector3Int";
+      MemberKind11[MemberKind11["DialogueLookup"] = 18] = "DialogueLookup";
+      MemberKind11[MemberKind11["Color"] = 19] = "Color";
+      MemberKind11[MemberKind11["Decimal"] = 20] = "Decimal";
+      MemberKind11[MemberKind11["Generic"] = 21] = "Generic";
+      MemberKind11[MemberKind11["Interface"] = 22] = "Interface";
+      MemberKind11[MemberKind11["NSFunction"] = 23] = "NSFunction";
+      MemberKind11[MemberKind11["FunctionRef"] = 24] = "FunctionRef";
+      MemberKind11[MemberKind11["NSDelegate"] = 25] = "NSDelegate";
+      MemberKind11[MemberKind11["NSAction"] = 26] = "NSAction";
+      MemberKind11[MemberKind11["Variant"] = 27] = "Variant";
+      return MemberKind11;
     })(MemberKind || {});
   }
 });
@@ -3391,6 +3391,13 @@ var init_neoscript_guards = __esm({
 function parameterHasDefault(argument2) {
   return argument2.defaultValue !== void 0;
 }
+function unnamedArgumentTypes(argumentTypes) {
+  return argumentTypes.map((argument2) => {
+    const { name, ...typeInfo } = argument2;
+    void name;
+    return typeInfo;
+  });
+}
 function hasAnyParameterDefault(argumentTypes) {
   return argumentTypes.some(parameterHasDefault);
 }
@@ -3474,6 +3481,15 @@ function typeInfosInvariantlyEqual(left, right) {
     if (left.keyEnumId !== right.keyEnumId) return false;
     return typeInfosInvariantlyEqual(left.entryTypeInfo, right.entryTypeInfo);
   }
+  if (left.type === 25 /* NSDelegate */ && right.type === 25 /* NSDelegate */) {
+    if (!typeInfosInvariantlyEqual(left.returnTypeInfo, right.returnTypeInfo)) {
+      return false;
+    }
+    if (left.argumentTypes.length !== right.argumentTypes.length) return false;
+    return left.argumentTypes.every(
+      (argument2, index) => typeInfosInvariantlyEqual(argument2, right.argumentTypes[index])
+    );
+  }
   if (left.type === 26 /* NSAction */ && right.type === 26 /* NSAction */) {
     if (left.argumentTypes.length !== right.argumentTypes.length) return false;
     return left.argumentTypes.every(
@@ -9052,6 +9068,10 @@ function resolveInstanceEnv(effectiveClassId, classArguments2, classes) {
     if (existing !== void 0 && existing.kind !== "unbound") continue;
     env.set(paramId, { kind: "member", memberId: arg.memberId });
   }
+  closeForwardedGenericParams(env);
+  return env;
+}
+function closeForwardedGenericParams(env) {
   for (const [paramId, entry] of env) {
     if (entry.kind !== "unbound") continue;
     const seen = /* @__PURE__ */ new Set([paramId]);
@@ -9067,7 +9087,6 @@ function resolveInstanceEnv(effectiveClassId, classArguments2, classes) {
       targetParamId = target.paramId;
     }
   }
-  return env;
 }
 function firstUnboundParamId(env) {
   for (const entry of env.values()) {
@@ -9521,10 +9540,13 @@ function typeInfoFromArgumentSignature(signature) {
       ...dictionarySignature.keyEnumId === void 0 ? {} : { keyEnumId: dictionarySignature.keyEnumId }
     };
   }
+  if (signature.type === 25 /* NSDelegate */) {
+    return signature;
+  }
   const typeInfo = { type: signature.type, required: signature.required };
   if (!isNSTypeInfo(typeInfo)) {
     throw new Error(
-      `substituteMember: generic binding kind ${signature.type} cannot appear in a NeoScript callable type.`
+      `substituteMember: generic binding kind ${MemberKind[signature.type] ?? signature.type} cannot appear in a NeoScript callable type.`
     );
   }
   return typeInfo;
@@ -9614,6 +9636,20 @@ function typeArgumentSignatureOfMember(member, env, members, seen = /* @__PURE__
       entry: entrySignature(resolved.entryMemberId, env, members, seen)
     };
   }
+  if (isMemberDelegateBase(resolved)) {
+    return {
+      type: 25 /* NSDelegate */,
+      required: required2,
+      returnTypeInfo: substituteNestedTypeInfo(
+        resolved.returnTypeInfo,
+        env,
+        members
+      ),
+      argumentTypes: unnamedArgumentTypes(resolved.argumentTypes).map(
+        (argument2) => substituteNestedTypeInfo(argument2, env, members)
+      )
+    };
+  }
   if (isMemberStringBase(resolved)) {
     return {
       type: 3 /* String */,
@@ -9701,6 +9737,12 @@ function signaturesEqual(a, b) {
     if (ad.keyEnumId !== bd.keyEnumId) return false;
     return signaturesEqual(ad.entry, bd.entry);
   }
+  if (a.type === 25 /* NSDelegate */ && b.type === 25 /* NSDelegate */) {
+    return typeInfosInvariantlyEqual(
+      a,
+      b
+    );
+  }
   return true;
 }
 function constructedSlotAccepts(slotMember, valueClassId, contextEnv, classes, members) {
@@ -9812,6 +9854,8 @@ var init_generics = __esm({
     "use strict";
     init_member_kinds();
     init_neoscript_guards();
+    init_type_info_equality();
+    init_parameter_defaults();
     init_world_system_classes();
     init_structural_narrow();
     init_classes();
@@ -10189,6 +10233,14 @@ function suppliedValueSettlesConstruction(member, value, context, path) {
   }
   return valueSettlesConstruction(member, { value }, context, path);
 }
+function genericParameterName(parameterId, classes) {
+  for (const neoClass of classes) {
+    for (const parameter4 of neoClass.genericParams ?? []) {
+      if (parameter4.id === parameterId) return parameter4.name;
+    }
+  }
+  return void 0;
+}
 function resolveConstructionTypeArguments(typeArguments, document) {
   if (typeArguments === void 0) return void 0;
   const bindings = {};
@@ -10213,8 +10265,10 @@ function resolveConstructionTypeArguments(typeArguments, document) {
       }
     }
     if (binding === void 0) {
+      const parameter4 = genericParameterName(parameterId, document.classes) ?? parameterId;
+      const kind = typeof typeInfo.type === "number" ? MemberKind[typeInfo.type] : typeInfo.type;
       throw new Error(
-        `Construction type argument "${parameterId}" has no matching type descriptor in the document.`
+        `Construction type argument "${parameter4}" (${kind}) has no matching type descriptor in the document.`
       );
     }
     bindings[parameterId] = {
@@ -14604,6 +14658,162 @@ function collectReturnStatements(statements) {
   }
   return result;
 }
+function collectIdentifierReads(expression, names) {
+  if (names.size === 0) return [];
+  const reads = [];
+  const walk = (node, visible) => {
+    switch (node.kind) {
+      case "ident":
+        if (visible.has(node.name))
+          reads.push({ name: node.name, pos: node.pos });
+        return;
+      case "annotated":
+        walk(node.expression, visible);
+        return;
+      case "member":
+        walk(node.receiver, visible);
+        return;
+      case "index":
+        walk(node.receiver, visible);
+        walk(node.index, visible);
+        return;
+      case "call":
+        walk(node.callee, visible);
+        for (const argument2 of node.args) walk(argument2, visible);
+        return;
+      case "new":
+        for (const argument2 of node.args) walk(argument2, visible);
+        for (const field of node.initializer ?? []) walk(field.value, visible);
+        return;
+      case "litList":
+        for (const element of node.elements) walk(element, visible);
+        return;
+      case "litDict":
+        for (const entry of node.entries) {
+          walk(entry.key, visible);
+          walk(entry.value, visible);
+        }
+        return;
+      case "litInterp":
+        for (const part of node.parts) {
+          if (part.kind === "expr") walk(part.expr, visible);
+        }
+        return;
+      case "binary":
+      case "coalesce":
+        walk(node.left, visible);
+        walk(node.right, visible);
+        return;
+      case "conditional":
+        walk(node.condition, visible);
+        walk(node.whenTrue, visible);
+        walk(node.whenFalse, visible);
+        return;
+      case "unary":
+      case "force":
+      case "is":
+        walk(node.operand, visible);
+        return;
+      case "lambda": {
+        const inner = new Set(visible);
+        for (const parameter4 of node.params) inner.delete(parameter4.name);
+        for (const statement of node.body) walkStatement(statement, inner);
+        return;
+      }
+      case "litNull":
+      case "litBool":
+      case "litInt":
+      case "litFloat":
+      case "litString":
+      case "litTripleString":
+      case "contextualEnum":
+        return;
+    }
+  };
+  const walkStatement = (statement, visible) => {
+    switch (statement.kind) {
+      case "varDecl":
+        walk(statement.init, visible);
+        return;
+      case "if":
+        for (const branch of statement.branches) {
+          walk(branch.cond, visible);
+          for (const inner of branch.body) walkStatement(inner, visible);
+        }
+        for (const inner of statement.elseBody ?? [])
+          walkStatement(inner, visible);
+        return;
+      case "while":
+      case "doWhile":
+        walk(statement.condition, visible);
+        for (const inner of statement.body) walkStatement(inner, visible);
+        return;
+      case "for": {
+        walk(statement.initializer.init, visible);
+        const inner = new Set(visible);
+        inner.delete(statement.initializer.name);
+        walk(statement.condition, inner);
+        walkStatement(statement.iterator, inner);
+        for (const bodyStatement of statement.body) {
+          walkStatement(bodyStatement, inner);
+        }
+        return;
+      }
+      case "forEach": {
+        walk(statement.collection, visible);
+        const inner = new Set(visible);
+        inner.delete(statement.name);
+        if (statement.key) inner.delete(statement.key.name);
+        for (const bodyStatement of statement.body) {
+          walkStatement(bodyStatement, inner);
+        }
+        return;
+      }
+      case "switch":
+        walk(statement.selector, visible);
+        for (const section of statement.sections) {
+          for (const label of section.labels) {
+            if (label.kind === "case") walk(label.expression, visible);
+          }
+          for (const bodyStatement of section.body) {
+            walkStatement(bodyStatement, visible);
+          }
+        }
+        return;
+      case "try":
+        for (const bodyStatement of statement.body) {
+          walkStatement(bodyStatement, visible);
+        }
+        for (const clause of statement.catches) {
+          const catchScope = new Set(visible);
+          catchScope.delete(clause.name);
+          if (clause.filter) walk(clause.filter, catchScope);
+          for (const bodyStatement of clause.body) {
+            walkStatement(bodyStatement, catchScope);
+          }
+        }
+        return;
+      case "return":
+        if (statement.expr) walk(statement.expr, visible);
+        return;
+      case "throw":
+        if (statement.expr) walk(statement.expr, visible);
+        return;
+      case "assign":
+        walk(statement.target, visible);
+        if (statement.value) walk(statement.value, visible);
+        return;
+      case "exprStmt":
+        walk(statement.expr, visible);
+        return;
+      case "break":
+      case "continue":
+        return;
+    }
+  };
+  walk(expression, names);
+  return reads;
+}
 var init_strict_ast = __esm({
   "../packages/neoscript-language/src/strict-ast.ts"() {
     "use strict";
@@ -29321,6 +29531,25 @@ function substituteTypeParameters(member, receiver, declaring) {
   };
   return visit(member);
 }
+function containsTypeParameter(type) {
+  switch (type.kind) {
+    case "typeParameter":
+      return true;
+    case "named":
+      return type.typeArguments?.some(containsTypeParameter) ?? false;
+    case "list":
+    case "set":
+      return containsTypeParameter(type.elementType);
+    case "dictionary":
+      return containsTypeParameter(type.keyType) || containsTypeParameter(type.valueType);
+    case "delegate":
+      return containsTypeParameter(type.returnType) || type.parameterTypes.some(containsTypeParameter);
+    case "action":
+      return type.parameterTypes.some(containsTypeParameter);
+    default:
+      return false;
+  }
+}
 var init_type_substitution = __esm({
   "../packages/neoscript-language/src/type-substitution.ts"() {
     "use strict";
@@ -30422,6 +30651,25 @@ function variable(id2, type, pointer, project) {
 function isGeneratedPositionalCall(target, expression) {
   return neoScriptRequiredConstructor(target) === null && target.constructorSignature !== void 0 && expression.argumentNames === void 0 && callHasPositionalArguments(expression);
 }
+function closedConstructorParameters(parameters, targetType, schemaClass2) {
+  return parameters.map((parameter4) => {
+    const valueType = substituteTypeParameters(
+      parameter4.valueType,
+      targetType,
+      schemaClass2
+    );
+    return {
+      ...parameter4,
+      valueType,
+      parameterType: substituteTypeParameters(
+        parameter4.parameterType,
+        targetType,
+        schemaClass2
+      ),
+      required: parameter4.required && valueType.nullable !== true
+    };
+  });
+}
 function requiredMembersAfterArguments(schemaClass2, parameters, positionalCount) {
   const names = [];
   for (const parameter4 of parameters.slice(positionalCount)) {
@@ -31756,6 +32004,7 @@ function resolveNeoScriptType(type, context, project) {
           )
         } : {}
       };
+      assertTypeArgumentConstraints(named, resolved, type.pos, project);
       break;
     }
     case "list":
@@ -31788,6 +32037,31 @@ function resolveNeoScriptType(type, context, project) {
   }
   return { ...resolved, nullable: !type.required };
 }
+function wrappedTypeParameterMessage(target, project) {
+  for (const argument2 of target.typeArguments ?? []) {
+    if (argument2.kind === "typeParameter") continue;
+    if (!containsTypeParameter(argument2)) continue;
+    return `Cannot construct '${formatType(target, project)}': type argument '${formatType(argument2, project)}' wraps a type parameter. Pass the type parameter itself or a closed type.`;
+  }
+  return null;
+}
+function assertDirectTypeParameterArguments(target, pos, project) {
+  const message = wrappedTypeParameterMessage(target, project);
+  if (message !== null) throw new CompileError(message, pos);
+}
+function assertTypeArgumentConstraints(declaring, type, pos, project) {
+  declaring.typeParameters?.forEach((parameter4, index) => {
+    const argument2 = type.typeArguments?.[index];
+    const constraint = parameter4.type.kind === "typeParameter" ? parameter4.type.constraint : void 0;
+    if (argument2 === void 0 || constraint === void 0) return;
+    const expected = substituteTypeParameters(constraint, type, declaring);
+    if (isNeoScriptTypeAssignable(argument2, expected, project)) return;
+    throw new CompileError(
+      `Type argument '${formatType(argument2, project)}' does not satisfy '${parameter4.name} extends ${formatType(expected, project)}' on '${declaring.name}'.`,
+      pos
+    );
+  });
+}
 function intersectCollectionWritability(left, right) {
   if (left === right) return left;
   const writable = (value) => value === "local" /* Local */ || value === "save" /* Save */ || value === "session" /* Session */ || value === "runtime" /* Runtime */;
@@ -32217,6 +32491,18 @@ var init_strict_resolver = __esm({
         }
         return { fields, errors, deferredReferences: [...deferredReferences] };
       }
+      /**
+       * P60 §2.3. A persisted delegate method group, graded exactly as the same
+       * expression assigned to `expected` in a body.
+       */
+      resolvePersistedMethodGroup(expression, expected) {
+        const resolved = this.resolveExpression(
+          expression,
+          this.initialScope(),
+          expected
+        );
+        this.requireAssignable(resolved.type, expected, expression.pos, "value");
+      }
       persistedListenerCompletions(receiver, expected) {
         const scope = this.initialScope();
         let receiverType = this.context.thisClass;
@@ -37238,7 +37524,8 @@ var init_strict_resolver = __esm({
       resolveExecutableObjectInitializer(schemaClass2, expression, scope, expected) {
         const settling = this.generatedConstructorSettlingEntries(
           schemaClass2,
-          expression
+          expression,
+          expected
         );
         const constructed = settling.length > 0 ? this.resolveClassConstructor(
           schemaClass2.name,
@@ -37317,7 +37604,7 @@ var init_strict_resolver = __esm({
         };
       }
       /** Block entries naming a required parameter the positional arguments skip. */
-      generatedConstructorSettlingEntries(schemaClass2, expression) {
+      generatedConstructorSettlingEntries(schemaClass2, expression, expected) {
         const signature = schemaClass2.constructorSignature;
         if (signature === void 0) return [];
         const generated = isGeneratedPositionalCall(schemaClass2, expression) || (schemaClass2.declaredConstructors?.length ?? 0) === 0 && expression.argumentNames === void 0;
@@ -37325,7 +37612,11 @@ var init_strict_resolver = __esm({
         const required2 = new Set(
           requiredMembersAfterArguments(
             schemaClass2,
-            signature.parameters,
+            closedConstructorParameters(
+              signature.parameters,
+              this.constructorTargetType(schemaClass2, expression, expected),
+              schemaClass2
+            ),
             expression.args.length
           ).map((name) => name.toLowerCase())
         );
@@ -37362,9 +37653,8 @@ var init_strict_resolver = __esm({
         }
         const signature = replayingStoredConstruction ? schemaClass2.storedConstructionReplaySignature ?? schemaClass2.constructorSignature : schemaClass2.constructorSignature;
         if (!signature) {
-          const open = (schemaClass2.typeParameters?.length ?? 0) > 0;
           throw new CompileError(
-            open ? `Cannot construct open generic Class '${className}'; construct a closed named descendant.` : `Class '${className}' does not expose a generated public constructor.`,
+            `Class '${className}' does not expose a generated public constructor.`,
             pos
           );
         }
@@ -37373,19 +37663,11 @@ var init_strict_resolver = __esm({
           expression,
           expected
         );
-        const parameters = signature.parameters.map((parameter4) => ({
-          ...parameter4,
-          valueType: substituteTypeParameters(
-            parameter4.valueType,
-            targetType,
-            schemaClass2
-          ),
-          parameterType: substituteTypeParameters(
-            parameter4.parameterType,
-            targetType,
-            schemaClass2
-          )
-        }));
+        const parameters = closedConstructorParameters(
+          signature.parameters,
+          targetType,
+          schemaClass2
+        );
         const argumentsList2 = expression.args;
         if (expression.argumentNames !== void 0) {
           throw new CompileError(
@@ -37474,15 +37756,34 @@ var init_strict_resolver = __esm({
           );
         }
         if (typeArguments !== void 0) {
-          return {
+          const target = {
             kind: "named",
             typeId: schemaClass2.id,
             typeArguments
           };
+          assertTypeArgumentConstraints(
+            schemaClass2,
+            target,
+            expression.pos,
+            this.project
+          );
+          assertDirectTypeParameterArguments(target, expression.pos, this.project);
+          return target;
         }
         if (expected?.kind === "named" && expected.typeId === schemaClass2.id) {
+          assertDirectTypeParameterArguments(
+            expected,
+            expression.pos,
+            this.project
+          );
           return { ...expected, nullable: false };
         }
+        if ((schemaClass2.typeParameters?.length ?? 0) > 0) {
+          throw new CompileError(
+            `Cannot construct open generic Class '${schemaClass2.name}'; pass its type arguments.`,
+            expression.pos
+          );
+        }
         return {
           kind: "named",
           typeId: schemaClass2.id
@@ -44278,7 +44579,8 @@ function createEnvironment(documents, project) {
     documents,
     project,
     projectIndex: createProjectIndex(project),
-    listenerResolvers: /* @__PURE__ */ new Map(),
+    initializerResolvers: /* @__PURE__ */ new Map(),
+    staticMember: false,
     assignability: /* @__PURE__ */ new Map(),
     enums,
     types,
@@ -44463,162 +44765,6 @@ function identifierRange(anchor, read, fallback) {
   if (slice !== read.name) return fallback;
   return anchorSpan(anchor, read.pos, read.name.length);
 }
-function collectIdentifierReads(expression, names) {
-  if (names.size === 0) return [];
-  const reads = [];
-  const walk = (node, visible) => {
-    switch (node.kind) {
-      case "ident":
-        if (visible.has(node.name))
-          reads.push({ name: node.name, pos: node.pos });
-        return;
-      case "annotated":
-        walk(node.expression, visible);
-        return;
-      case "member":
-        walk(node.receiver, visible);
-        return;
-      case "index":
-        walk(node.receiver, visible);
-        walk(node.index, visible);
-        return;
-      case "call":
-        walk(node.callee, visible);
-        for (const argument2 of node.args) walk(argument2, visible);
-        return;
-      case "new":
-        for (const argument2 of node.args) walk(argument2, visible);
-        for (const field of node.initializer ?? []) walk(field.value, visible);
-        return;
-      case "litList":
-        for (const element of node.elements) walk(element, visible);
-        return;
-      case "litDict":
-        for (const entry of node.entries) {
-          walk(entry.key, visible);
-          walk(entry.value, visible);
-        }
-        return;
-      case "litInterp":
-        for (const part of node.parts) {
-          if (part.kind === "expr") walk(part.expr, visible);
-        }
-        return;
-      case "binary":
-      case "coalesce":
-        walk(node.left, visible);
-        walk(node.right, visible);
-        return;
-      case "conditional":
-        walk(node.condition, visible);
-        walk(node.whenTrue, visible);
-        walk(node.whenFalse, visible);
-        return;
-      case "unary":
-      case "force":
-      case "is":
-        walk(node.operand, visible);
-        return;
-      case "lambda": {
-        const inner = new Set(visible);
-        for (const parameter4 of node.params) inner.delete(parameter4.name);
-        for (const statement of node.body) walkStatement(statement, inner);
-        return;
-      }
-      case "litNull":
-      case "litBool":
-      case "litInt":
-      case "litFloat":
-      case "litString":
-      case "litTripleString":
-      case "contextualEnum":
-        return;
-    }
-  };
-  const walkStatement = (statement, visible) => {
-    switch (statement.kind) {
-      case "varDecl":
-        walk(statement.init, visible);
-        return;
-      case "if":
-        for (const branch of statement.branches) {
-          walk(branch.cond, visible);
-          for (const inner of branch.body) walkStatement(inner, visible);
-        }
-        for (const inner of statement.elseBody ?? [])
-          walkStatement(inner, visible);
-        return;
-      case "while":
-      case "doWhile":
-        walk(statement.condition, visible);
-        for (const inner of statement.body) walkStatement(inner, visible);
-        return;
-      case "for": {
-        walk(statement.initializer.init, visible);
-        const inner = new Set(visible);
-        inner.delete(statement.initializer.name);
-        walk(statement.condition, inner);
-        walkStatement(statement.iterator, inner);
-        for (const bodyStatement of statement.body) {
-          walkStatement(bodyStatement, inner);
-        }
-        return;
-      }
-      case "forEach": {
-        walk(statement.collection, visible);
-        const inner = new Set(visible);
-        inner.delete(statement.name);
-        if (statement.key) inner.delete(statement.key.name);
-        for (const bodyStatement of statement.body) {
-          walkStatement(bodyStatement, inner);
-        }
-        return;
-      }
-      case "switch":
-        walk(statement.selector, visible);
-        for (const section of statement.sections) {
-          for (const label of section.labels) {
-            if (label.kind === "case") walk(label.expression, visible);
-          }
-          for (const bodyStatement of section.body) {
-            walkStatement(bodyStatement, visible);
-          }
-        }
-        return;
-      case "try":
-        for (const bodyStatement of statement.body) {
-          walkStatement(bodyStatement, visible);
-        }
-        for (const clause of statement.catches) {
-          const catchScope = new Set(visible);
-          catchScope.delete(clause.name);
-          if (clause.filter) walk(clause.filter, catchScope);
-          for (const bodyStatement of clause.body) {
-            walkStatement(bodyStatement, catchScope);
-          }
-        }
-        return;
-      case "return":
-        if (statement.expr) walk(statement.expr, visible);
-        return;
-      case "throw":
-        if (statement.expr) walk(statement.expr, visible);
-        return;
-      case "assign":
-        walk(statement.target, visible);
-        if (statement.value) walk(statement.value, visible);
-        return;
-      case "exprStmt":
-        walk(statement.expr, visible);
-        return;
-      case "break":
-      case "continue":
-        return;
-    }
-  };
-  walk(expression, names);
-  return reads;
-}
 function validateProjectRootGlobal(uri, declaration, environment, diagnostics) {
   if (declaration.name !== "root" || declaration.annotations.length !== 0) {
     pushDiagnostic(
@@ -44742,7 +44888,7 @@ function validateMember(uri, member, ownerName, documentKind, ownerScope, enviro
       member.initializer.text,
       memberType2,
       scope,
-      environment,
+      member.modifiers.includes("static") ? { ...environment, staticMember: true } : environment,
       member.initializer.range,
       diagnostics,
       anchorOf(member.initializer),
@@ -45599,6 +45745,18 @@ function validateStatements(statements, returnType, scope, environment, uri, ran
   }
 }
 function validateExpression(expression, expected, scope, environment, uri, range2, diagnostics, anchor) {
+  if (expected?.name === "NeoDelegate" && validateDelegateMethodGroup(
+    expression,
+    expected,
+    scope,
+    environment,
+    uri,
+    range2,
+    diagnostics,
+    anchor
+  )) {
+    return;
+  }
   if (expected !== void 0 && isNeoVariantTypeName(expected.name) && !(expression.kind === "new" && expression.className === null)) {
     validateVariantValuedExpression(
       expression,
@@ -45888,6 +46046,22 @@ function validateExpression(expression, expected, scope, environment, uri, range
         return argument2 ? [[parameter4.name, argument2]] : [];
       })
     );
+    const wrapped = wrappedTypeParameterConstruction(
+      declaration,
+      siteTypeArguments,
+      scope,
+      environment,
+      expression.pos
+    );
+    if (wrapped !== null) {
+      pushDiagnostic(
+        diagnostics,
+        uri,
+        range2,
+        "wrapped-type-parameter-argument",
+        wrapped
+      );
+    }
     if (!variant2) {
       for (const diagnostic of validateNeoConstructionSite(
         environment.construction,
@@ -46509,8 +46683,14 @@ function describeType(type) {
   const argumentsList2 = type.arguments?.length ? `<${type.arguments.map(describeType).join(", ")}>` : "";
   return `${type.name}${argumentsList2}${type.nullable ? "?" : ""}`;
 }
+function isAstPrimitiveTypeName(name) {
+  return AST_PRIMITIVE_TYPE_NAMES.has(name);
+}
 function semanticAst(type, pos) {
   const common = { pos, required: type.nullable !== true };
+  if (isAstPrimitiveTypeName(type.name)) {
+    return { ...common, kind: "primitive", name: type.name };
+  }
   const args = type.arguments ?? [];
   if ((type.name === "List" || type.name === "Set") && args[0]) {
     return {
@@ -46535,23 +46715,11 @@ function semanticAst(type, pos) {
   };
 }
 function validateListenerAnnotation(annotation2, expression, expected, scope, environment, uri, range2, diagnostics, anchor) {
-  const declaring = environment.projectIndex.typeByName.get(
-    scope.get("this")?.name ?? ""
+  const { context, resolver } = initializerResolver(
+    environment,
+    scope.get("this")?.name ?? "",
+    false
   );
-  const context = {
-    project: environment.project,
-    kind: "initializerExpression",
-    ...declaring ? {
-      declaringType: { kind: "named", typeId: declaring.id },
-      thisClass: { kind: "named", typeId: declaring.id },
-      implicitMemberAccess: true
-    } : {}
-  };
-  let resolver = environment.listenerResolvers.get(declaring?.id ?? "");
-  if (!resolver) {
-    resolver = new StrictNeoScriptResolver(context, environment.projectIndex);
-    environment.listenerResolvers.set(declaring?.id ?? "", resolver);
-  }
   try {
     let owner;
     if (expression.kind === "new" && expression.className) {
@@ -46605,6 +46773,103 @@ function validateListenerAnnotation(annotation2, expression, expected, scope, en
     );
   }
 }
+function validateDelegateMethodGroup(expression, expected, scope, environment, uri, range2, diagnostics, anchor) {
+  const thisName = scope.get("this")?.name ?? "";
+  if (!namesSourceFunction(expression, thisName, scope, environment))
+    return false;
+  const { context, resolver } = initializerResolver(
+    environment,
+    thisName,
+    environment.staticMember
+  );
+  try {
+    const delegate = resolveNeoScriptType(
+      semanticAst(expected, expression.pos),
+      context,
+      environment.projectIndex
+    );
+    if (delegate.kind !== "delegate") return false;
+    resolver.resolvePersistedMethodGroup(expression, delegate);
+  } catch (error) {
+    if (!(error instanceof CompileError)) throw error;
+    pushDiagnostic(
+      diagnostics,
+      uri,
+      anchor ? anchorSpan(anchor, error, 1) : range2,
+      "invalid-delegate-method-group",
+      error.message.replace(/^\d+:\d+: /, "")
+    );
+  }
+  return true;
+}
+function namesSourceFunction(expression, thisName, scope, environment) {
+  let owner;
+  if (expression.kind === "ident") {
+    owner = environment.types.get(thisName);
+  } else if (expression.kind === "member" && expression.receiver.kind === "ident") {
+    const receiver = expression.receiver.name;
+    if (receiver === "this") owner = environment.types.get(thisName);
+    else if (!scope.has(receiver)) owner = environment.types.get(receiver);
+  } else {
+    return false;
+  }
+  if (owner === void 0) return false;
+  const target = sourceClassMemberByName(owner, expression.name, environment);
+  return target?.member.kind === "function";
+}
+function wrappedTypeParameterConstruction(declaration, typeArguments, scope, environment, pos) {
+  if (!typeArguments.some((argument2) => argument2.arguments?.length)) {
+    return null;
+  }
+  const { context } = initializerResolver(
+    environment,
+    scope.get("this")?.name ?? "",
+    false
+  );
+  let target;
+  try {
+    target = resolveNeoScriptType(
+      {
+        kind: "named",
+        name: declaration.name,
+        typeArguments: typeArguments.map(
+          (argument2) => semanticAst(argument2, pos)
+        ),
+        required: true,
+        pos
+      },
+      context,
+      environment.projectIndex
+    );
+  } catch (error) {
+    if (error instanceof CompileError) return null;
+    throw error;
+  }
+  return target.kind === "named" ? wrappedTypeParameterMessage(target, environment.projectIndex) : null;
+}
+function initializerResolver(environment, thisName, staticMember) {
+  const declaring = environment.projectIndex.typeByName.get(thisName);
+  const key = `${declaring?.id ?? ""}:${staticMember}`;
+  let entry = environment.initializerResolvers.get(key);
+  if (entry === void 0) {
+    const declaringType = declaring ? { kind: "named", typeId: declaring.id } : void 0;
+    const context = {
+      project: environment.project,
+      kind: "initializerExpression",
+      ...declaringType ? {
+        declaringType,
+        implicitMemberAccess: true,
+        ...staticMember ? { staticMember } : { thisClass: declaringType }
+      } : {}
+    };
+    entry = {
+      context,
+      resolver: new StrictNeoScriptResolver(context, environment.projectIndex)
+    };
+    environment.initializerResolvers.set(key, entry);
+  }
+  return entry;
+}
 function validateInlineAnnotation(annotation2, environment, uri, range2, diagnostics) {
   if (annotation2.name !== "id") {
     pushDiagnostic(
@@ -47281,7 +47546,7 @@ function classDerivesFromName(name, ancestorName, environment, seen = /* @__PURE
     return classDerivesFromName(base.name, ancestorName, environment, seen);
   });
 }
-var NEO_VARIANT_FOLDER_SETTING, NEO_ANIMATION_CHILD_OVERRIDE_TYPE_NAME, primitiveType, LIST_COLUMN_INHERITANCE_KEY, DECLARATION_BODY_GLOBAL_TYPES, SEMANTIC_PRIMITIVE_TYPE_NAMES;
+var NEO_VARIANT_FOLDER_SETTING, NEO_ANIMATION_CHILD_OVERRIDE_TYPE_NAME, primitiveType, LIST_COLUMN_INHERITANCE_KEY, DECLARATION_BODY_GLOBAL_TYPES, SEMANTIC_PRIMITIVE_TYPE_NAMES, AST_PRIMITIVE_TYPE_NAMES;
 var init_project_source_semantics = __esm({
   "../packages/neoscript-language/src/project-source-semantics.ts"() {
     "use strict";
@@ -47294,6 +47559,7 @@ var init_project_source_semantics = __esm({
     init_listener_metadata_statement();
     init_language_spec();
     init_project_schema_contract_generated();
+    init_strict_ast();
     init_strict_compile_error();
     init_executable_parser();
     init_project_source_construction_diagnostics();
@@ -47319,6 +47585,7 @@ var init_project_source_semantics = __esm({
       "decimal",
       "string"
     ]);
+    AST_PRIMITIVE_TYPE_NAMES = /* @__PURE__ */ new Set(["int", "float", "decimal", "bool", "string", "null", "void"]);
   }
 });
 
@@ -48406,6 +48673,7 @@ function buildProjectGraph(documents) {
         ...typeParameters.length ? { typeParameters } : {},
         ...classDeclaration?.modifiers.includes("abstract") ? { abstract: true } : {},
         ...classDeclaration?.modifiers.includes("sealed") ? { sealed: true } : {},
+        ...classDeclaration && allowsUserStorage(info, declarationsByName) ? { userClass: true } : {},
         location: location(info.uri, info.declaration.range),
         selectionLocation: location(info.uri, info.declaration.nameRange)
       };
@@ -48911,7 +49179,7 @@ function collectReferencedBuiltinNames(documents, declared) {
   }
   return names;
 }
-function memberWritability(annotations) {
+function allowedStorage(annotations) {
   const storage = annotations.find(
     (annotation2) => annotation2.name === "storage"
   );
@@ -48921,7 +49189,28 @@ function memberWritability(annotations) {
   const positionalAllowed = storage?.arguments.find(
     (argument2) => argument2.name === void 0
   );
-  const allowed = (namedAllowed ?? positionalAllowed)?.text;
+  return (namedAllowed ?? positionalAllowed)?.text;
+}
+function allowsUserStorage(info, declarationsByName) {
+  const visited = /* @__PURE__ */ new Set();
+  let current = info;
+  while (current !== void 0 && !visited.has(current.id)) {
+    visited.add(current.id);
+    const allowed = allowedStorage(current.declaration.annotations);
+    if (allowed !== void 0) return /\.User\b/.test(allowed);
+    let baseClass;
+    for (const base of current.declaration.baseTypes) {
+      const candidate = declarationsByName.get(base.name);
+      if (candidate?.declaration.kind !== "class") continue;
+      baseClass = candidate;
+      break;
+    }
+    current = baseClass;
+  }
+  return false;
+}
+function memberWritability(annotations) {
+  const allowed = allowedStorage(annotations);
   if (/\.Immutable\b/.test(allowed ?? "")) return "immutable";
   if (/\.Save\b/.test(allowed ?? "")) return "save";
   if (/\.Session\b/.test(allowed ?? "")) return "session";
@@ -49638,7 +49927,18 @@ function validateGenericConstraintCycles(uri, declaration, diagnostics) {
   }
 }
 function validateTypeApplication(uri, type, genericParameters, environment, diagnostics) {
-  for (const argument2 of type.typeArguments) {
+  type.typeArguments.forEach((argument2, index) => {
+    const parameterSlot = type.name === "NeoAction" || type.name === "NeoDelegate" && index > 0;
+    if (argument2.name === "NeoAction" && !parameterSlot) {
+      diagnose(
+        diagnostics,
+        uri,
+        argument2.range,
+        "invalid-type-argument",
+        `Type '${type.name}' cannot take 'NeoAction' as a type argument; an action is invoked as a statement, never used as a value.`
+      );
+      return;
+    }
     validateTypeApplication(
       uri,
       argument2,
@@ -49646,7 +49946,7 @@ function validateTypeApplication(uri, type, genericParameters, environment, diag
       environment,
       diagnostics
     );
-  }
+  });
   if (genericParameters.has(type.name)) {
     if (type.typeArguments.length > 0) {
       diagnose(
@@ -53123,7 +53423,7 @@ var init_registry = __esm({
   "../packages/manifest/schema-contract/registry.mjs"() {
     "use strict";
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
-      cliVersion: "0.77.0",
+      cliVersion: "0.77.1",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -66305,16 +66605,17 @@ var init_lookup_declared_type = __esm({
 });
 
 // ../packages/neoscript-runtime/src/values/member-declared-type-info.ts
-function resolveMemberDeclaredTypeInfo(member, members, ownerClass = null) {
+function resolveMemberDeclaredTypeInfo(member, members, ownerClass = null, env) {
   return resolveMemberDeclaredTypeInfoInternal(
     member,
     members,
     /* @__PURE__ */ new Set(),
-    ownerClass
+    ownerClass,
+    env
   );
 }
-function resolveMemberDeclaredTypeInfoInternal(member, members, seen, ownerClass) {
-  const resolved = resolveMember(member, members);
+function resolveMemberDeclaredTypeInfoInternal(member, members, seen, ownerClass, env) {
+  const resolved = env === void 0 ? resolveMember(member, members) : substituteMember(member, env, members);
   const memberId = getField(resolved, "id");
   if (typeof memberId === "string" && seen.has(memberId)) return null;
   const nextSeen = typeof memberId === "string" ? /* @__PURE__ */ new Set([...seen, memberId]) : new Set(seen);
@@ -66323,7 +66624,14 @@ function resolveMemberDeclaredTypeInfoInternal(member, members, seen, ownerClass
     const typeArguments = Object.fromEntries(
       Object.entries(resolved.classArguments ?? {}).flatMap(
         ([genericParamId, binding]) => {
-          if (!isMemberGenericBinding(binding)) return [];
+          if (!isMemberGenericBinding(binding)) {
+            const forwarded = genericParamTypeInfo(
+              ownerClass,
+              binding.genericParamId,
+              true
+            );
+            return forwarded === null ? [] : [[genericParamId, forwarded]];
+          }
           const argumentMember = members.find(
             (candidate) => candidate.id === binding.memberId
           );
@@ -66332,7 +66640,8 @@ function resolveMemberDeclaredTypeInfoInternal(member, members, seen, ownerClass
             argumentMember,
             members,
             nextSeen,
-            ownerClass
+            ownerClass,
+            env
           );
           return argumentType === null ? [] : [[genericParamId, argumentType]];
         }
@@ -66372,22 +66681,14 @@ function resolveMemberDeclaredTypeInfoInternal(member, members, seen, ownerClass
       type: 25 /* NSDelegate */,
       required: isRequiredMember(resolved),
       returnTypeInfo: resolved.returnTypeInfo,
-      argumentTypes: resolved.argumentTypes.map((argument2) => {
-        const { name, ...typeInfo } = argument2;
-        void name;
-        return typeInfo;
-      })
+      argumentTypes: unnamedArgumentTypes(resolved.argumentTypes)
     };
   }
   if (isMemberActionBase(resolved)) {
     return {
       type: 26 /* NSAction */,
       required: false,
-      argumentTypes: resolved.argumentTypes.map((argument2) => {
-        const { name, ...typeInfo } = argument2;
-        void name;
-        return typeInfo;
-      })
+      argumentTypes: unnamedArgumentTypes(resolved.argumentTypes)
     };
   }
   if (isMemberListBase(resolved) || isMemberDictionaryBase(resolved)) {
@@ -66399,7 +66700,8 @@ function resolveMemberDeclaredTypeInfoInternal(member, members, seen, ownerClass
       entry,
       members,
       nextSeen,
-      ownerClass
+      ownerClass,
+      env
     );
     if (entryTypeInfo === null) return null;
     return {
@@ -66419,37 +66721,47 @@ function resolveMemberDeclaredTypeInfoInternal(member, members, seen, ownerClass
         collection,
         members,
         nextSeen,
-        ownerClass
+        ownerClass,
+        env
       );
     });
   }
   if (resolved.kind === 9 /* Lookup */) return null;
   if (!memberKindSupportsStorage(resolved.kind)) return null;
   if (isMemberGenericBase(resolved)) {
-    if (ownerClass === null) return null;
-    const declaration = ownerClass.genericParams?.find(
-      (parameter4) => parameter4.id === resolved.genericParamId
+    return genericParamTypeInfo(
+      ownerClass,
+      resolved.genericParamId,
+      isRequiredMember(resolved)
     );
-    if (declaration === void 0) return null;
-    return {
-      type: 21 /* Generic */,
-      required: isRequiredMember(resolved),
-      ownerClassId: ownerClass.id,
-      genericParamId: declaration.id
-    };
   }
   return {
     type: resolved.kind,
     required: isRequiredMember(resolved)
   };
 }
+function genericParamTypeInfo(ownerClass, genericParamId, required2) {
+  if (ownerClass === null) return null;
+  const declaration = ownerClass.genericParams?.find(
+    (parameter4) => parameter4.id === genericParamId
+  );
+  if (declaration === void 0) return null;
+  return {
+    type: 21 /* Generic */,
+    required: required2,
+    ownerClassId: ownerClass.id,
+    genericParamId: declaration.id
+  };
+}
 var init_member_declared_type_info = __esm({
   "../packages/neoscript-runtime/src/values/member-declared-type-info.ts"() {
     "use strict";
     init_members();
     init_lookup_declared_type();
     init_classes();
+    init_generics();
     init_inheritance();
+    init_parameter_defaults();
     init_core();
   }
 });
@@ -66622,9 +66934,6 @@ function attachConstructorSignature(type, environment) {
     type.id,
     environment
   );
-  for (const binding of genericEnvironment.values()) {
-    if (binding.kind === "unbound") return type;
-  }
   return {
     ...type,
     ...buildNeoScriptConstructionSignatures(
@@ -66637,7 +66946,7 @@ function attachConstructorSignature(type, environment) {
           environment
         );
         return member ? {
-          required: boolean2(member.required, `member ${memberId}.required`),
+          required: member.kind === "generic" || boolean2(member.required, `member ${memberId}.required`),
           defaultValue: member.defaultValue,
           immutable: declaredStorage(
             environment.members.get(memberId),
@@ -68703,9 +69012,6 @@ function classToLanguageType(schemaClass2, context) {
 }
 function constructorSignature(schemaClass2, members, context, genericEnvironment) {
   if (isAbstractClass(schemaClass2)) return {};
-  if (!isClosedClass(schemaClass2.id, context.vm.classes)) {
-    return {};
-  }
   return buildNeoScriptConstructionSignatures(
     schemaClass2.id,
     members,
@@ -68713,14 +69019,16 @@ function constructorSignature(schemaClass2, members, context, genericEnvironment
       const record7 = analyzerMemberById(context, memberId);
       if (!record7) return null;
       try {
-        const resolved = substituteMember(
+        const declared = resolveAnalyzerMember(context, record7);
+        const open = isMemberGenericBase(declared) && genericEnvironment.get(declared.genericParamId)?.kind === "unbound";
+        const resolved = open ? declared : substituteMember(
           record7,
           genericEnvironment,
           context.vm.members,
-          resolveAnalyzerMember(context, record7)
+          declared
         );
         return {
-          required: isRequiredMember(resolved),
+          required: open || isRequiredMember(resolved),
           defaultValue: "defaultValue" in resolved ? resolved.defaultValue : void 0,
           immutable: declaredMemberStorage(record7.id, context.vm.members) === 1 /* Immutable */
         };
@@ -69961,25 +70269,33 @@ function compileNSInitializer(code, ctx) {
     );
   }
   try {
-    const { lexicalThisClass, ...compilerContext } = ctx;
+    const { lexicalThisClass, declaringClass, ...compilerContext } = ctx;
+    const context = createContext(
+      {
+        ...compilerContext,
+        thisClass: lexicalThisClass ?? null,
+        implicitMemberAccess: lexicalThisClass !== null,
+        staticMember: false
+      },
+      {
+        scriptKind: "initializer",
+        returnTypeInfo: ctx.returnTypeInfo,
+        ...ctx.argumentTypes === void 0 ? {} : { functionArguments: ctx.argumentTypes },
+        ...ctx.initializerName === void 0 ? {} : { functionName: ctx.initializerName },
+        dialogueContext: null
+      }
+    );
     return compileStrict(
       `return
 ${code};`,
-      createContext(
-        {
-          ...compilerContext,
-          thisClass: lexicalThisClass ?? null,
-          implicitMemberAccess: lexicalThisClass !== null,
-          staticMember: false
-        },
-        {
-          scriptKind: "initializer",
-          returnTypeInfo: ctx.returnTypeInfo,
-          ...ctx.argumentTypes === void 0 ? {} : { functionArguments: ctx.argumentTypes },
-          ...ctx.initializerName === void 0 ? {} : { functionName: ctx.initializerName },
-          dialogueContext: null
+      declaringClass ? {
+        ...context,
+        declaringType: {
+          kind: "named",
+          typeId: declaringClass.id,
+          nullable: false
         }
-      )
+      } : context
     );
   } catch (error) {
     throw withInitializerSourcePosition(error);
@@ -70427,6 +70743,7 @@ function compileMemberInitializerBody(args) {
       `Member "${args.member.name}" has an initializer but no resolvable declared type.`
     );
   }
+  const instanceClass = isStaticMember(args.member) ? null : args.thisClass;
   let compiled;
   try {
     compiled = compileUnit2(
@@ -70438,8 +70755,10 @@ function compileMemberInitializerBody(args) {
         variantFolders: args.variantFolders ?? [],
         returnTypeInfo,
         initializerName: args.member.name,
+        lexicalThisClass: parseExpression(defaultValue.init.code).kind === "lambda" ? instanceClass : null,
+        declaringClass: instanceClass,
         argumentTypes: initializerArgumentTypes(
-          args.thisClass,
+          instanceClass,
           args.constructors ?? []
         )
       })
@@ -70484,6 +70803,7 @@ function compileValueRowInitializerBody(args) {
         returnTypeInfo,
         initializerName: args.member.name,
         lexicalThisClass: args.lexicalThisClass ?? null,
+        declaringClass: args.initializerOwnerClass,
         argumentTypes: initializerArgumentTypes(
           args.initializerOwnerClass,
           args.constructors ?? []
@@ -70529,18 +70849,23 @@ function compileAuthoredMemberBodies(args) {
   compileMemberDelegateDefault(args);
 }
 function compileMemberDelegateDefault(args) {
-  if (!isMemberDelegateBase(args.member)) return;
-  const defaultValue = args.member.defaultValue;
-  if (defaultValue === void 0 || !isLiteralValueContent(defaultValue) || !isNSDelegateClosureValueDraft(defaultValue.value)) {
+  if (args.member.kind !== 25 /* NSDelegate */) return;
+  const defaultValue = getField(args.member, "defaultValue");
+  if (!isLiteralValueContent(defaultValue) || !isNSDelegateClosureValueDraft(defaultValue.value)) {
     return;
   }
+  const signature = resolveNSDelegateSignature(args.member, args.members);
+  if (signature === null) {
+    throw new Error(
+      `NeoDelegate "${args.member.name}" has no signature in its override chain.`
+    );
+  }
   const code = defaultValue.value.code;
   try {
     defaultValue.value = compileDelegateClosureValue(code, {
       ...args,
       staticMember: isStaticMember(args.member),
-      returnTypeInfo: args.member.returnTypeInfo,
-      argumentTypes: args.member.argumentTypes,
+      ...signature,
       name: args.member.name
     });
   } catch (error) {
@@ -70636,6 +70961,7 @@ function compileConstructorBaseInitializerFields(args, owner) {
     args.classes,
     args.members
   );
+  const ownerEnv = resolveGenericEnv(owner.id, args.classes);
   const compiledBaseInitializerFields = fields.map((field) => {
     const entry = baseSchema.find(
       (candidate) => candidate.schemaKey === field.name
@@ -70658,12 +70984,24 @@ function compileConstructorBaseInitializerFields(args, owner) {
         `Constructor "${args.constructor.id}" settles Immutable base member "${field.name}"; runtime construction cannot supply Immutable fields.`
       );
     }
-    const returnTypeInfo = resolveMemberDeclaredTypeInfo(member, args.members);
-    if (returnTypeInfo === null) {
+    const declaredTypeInfo = resolveMemberDeclaredTypeInfo(
+      member,
+      args.members,
+      args.classes.find(
+        (schemaClass2) => schemaClass2.id === entry.ownerClassId
+      ) ?? null
+    );
+    if (declaredTypeInfo === null) {
       throw new Error(
         `Constructor "${args.constructor.id}" settles base member "${field.name}", which has no resolvable declared type.`
       );
     }
+    const returnTypeInfo = substituteInheritedCallableTypeInfo(
+      declaredTypeInfo,
+      ownerEnv,
+      args.classes,
+      args.members
+    );
     return compileUnit2(
       "getter",
       () => compileNSInitializer(field.code, {
@@ -70777,14 +71115,10 @@ function resolveNSFunctionSignature(memberId, members) {
     memberId,
     members,
     (member) => {
-      const returnTypeInfo = getField(member, "returnTypeInfo");
-      const argumentTypes = getField(member, "argumentTypes");
-      if (!isNSFunctionReturnTypeInfo(returnTypeInfo)) return void 0;
-      if (!Array.isArray(argumentTypes)) return void 0;
-      if (!argumentTypes.every(isNSFunctionArgumentTypeInfo)) return void 0;
+      const signature = declaredCallableSignature(member);
+      if (signature === void 0) return void 0;
       return {
-        returnTypeInfo,
-        argumentTypes,
+        ...signature,
         // Compiler IR still uses a boolean because this is a transient
         // callable signature, while persisted members use optional dispatch.
         deferred: isAsynchronousFunctionMember(member)
@@ -70794,6 +71128,27 @@ function resolveNSFunctionSignature(memberId, members) {
   );
   return found ?? null;
 }
+function resolveNSDelegateSignature(member, members) {
+  const declared = declaredCallableSignature(member);
+  if (declared !== void 0) return declared;
+  const extendsMemberId = getOptionalString(member, "extendsMemberId");
+  if (extendsMemberId === void 0) return null;
+  const found = walkExtendsMemberChain(
+    extendsMemberId,
+    members,
+    declaredCallableSignature,
+    { requireKind: 25 /* NSDelegate */ }
+  );
+  return found ?? null;
+}
+function declaredCallableSignature(member) {
+  const returnTypeInfo = getField(member, "returnTypeInfo");
+  const argumentTypes = getField(member, "argumentTypes");
+  if (!isNSFunctionReturnTypeInfo(returnTypeInfo)) return void 0;
+  if (!Array.isArray(argumentTypes)) return void 0;
+  if (!argumentTypes.every(isNSFunctionArgumentTypeInfo)) return void 0;
+  return { returnTypeInfo, argumentTypes };
+}
 function resolveNSPropertyReturnTypeInfo(memberId, members) {
   const found = walkExtendsMemberChain(
     memberId,
@@ -70863,6 +71218,7 @@ var init_compile_ns_property = __esm({
     init_compile_delegate_closure();
     init_compiler_adapter();
     init_compiler_adapter();
+    init_executable_parser();
     NeoScriptBodyCompileError = class extends Error {
       memberId;
       memberName;
@@ -71726,15 +72082,12 @@ function initializerOwnerContext(document, valueId, rootOwners, valuesById, reco
     currentId = sourceValueId;
     lexicalRoot = rootOwners.get(sourceValueId) ?? lexicalRoot;
   }
-  if (lexicalRoot === void 0) {
+  if (lexicalRoot === void 0 || isStaticMember(lexicalRoot)) {
     return { ownerClass: null, lexicalThisClass: null };
   }
   const lexicalRootId = getField(lexicalRoot, "id");
   const ownerClass = typeof lexicalRootId === "string" ? findSchemaPlacement(lexicalRootId, document.classes)?.ownerClass ?? null : null;
-  return {
-    ownerClass,
-    lexicalThisClass: isStaticMember(lexicalRoot) === true ? null : ownerClass
-  };
+  return { ownerClass, lexicalThisClass: ownerClass };
 }
 function isRecordValue(value) {
   if (value === null) return false;
@@ -78604,6 +78957,7 @@ function runtimeGenericEnvForValueRow(row, ctx, visited = /* @__PURE__ */ new Se
   );
   overlayConcreteGenericEntries(env, parentEnv);
   overlayConcreteGenericEntries(env, envFromStamp(row.genericBindings));
+  closeForwardedGenericParams(env);
   return env;
 }
 function runtimeParentGenericEnv(row, ctx, visited, readRow) {
@@ -78844,6 +79198,18 @@ function runtimeTypeInfoForMember(rawMember, env, ctx, seen) {
       ctx
     );
   }
+  if (isMemberDelegateBase(member)) {
+    return substituteRuntimeTypeInfo(
+      {
+        type: 25 /* NSDelegate */,
+        required: required2,
+        returnTypeInfo: member.returnTypeInfo,
+        argumentTypes: unnamedArgumentTypes(member.argumentTypes)
+      },
+      env,
+      ctx
+    );
+  }
   if (member.kind === 13 /* Function */ || member.kind === 23 /* NSFunction */ || member.kind === 22 /* Interface */) {
     throw new NSGetterRuntimeError(
       `Member '${member.name}' cannot be used as a concrete generic value type.`
@@ -79349,8 +79715,17 @@ function dispatchSchemaMember(receiver, schemaKey, ctx) {
       return { kind: "ok", value: null };
     case "declaration": {
       const value = readDeclarationDefault(member, ctx);
-      if (value.matched) return { kind: "ok", value: value.value };
-      return { kind: "no-info", matchedMember: true };
+      if (!value.matched) return { kind: "no-info", matchedMember: true };
+      if (!isNSDelegateClosureValue(value.value))
+        return { kind: "ok", value: value.value };
+      return {
+        kind: "ok",
+        value: {
+          ...value.value,
+          [DELEGATE_LEXICAL_THIS]: receiver,
+          [DELEGATE_LEXICAL_ROOT]: ctx.rootValue
+        }
+      };
     }
     case "missing":
       return { kind: "no-info", matchedMember: true };
@@ -81488,8 +81863,9 @@ function validateClassConstructorDescriptor(info, ctx, requireEveryRequiredField
   }
   const genericSlot = ctx.__constructionGenericSlots?.toReversed().find((slot) => slot.classId === classId) ?? ctx.__storedConstructionReplaySlot;
   const slotArguments = genericSlot?.classId === classId ? genericSlot.classArguments : void 0;
+  const typeArguments = slotArguments === void 0 ? receiverClosedTypeArguments(info.schemaClassInfo.typeArguments, ctx) : void 0;
   const descriptorCache = evaluatorValueGeneration(ctx).constructorDescriptors;
-  const descriptorCacheKey = `${requireEveryRequiredField}:${ctx.storedConstructionReplay === true}:${JSON.stringify(slotArguments ?? info.schemaClassInfo.typeArguments ?? null)}`;
+  const descriptorCacheKey = `${requireEveryRequiredField}:${ctx.storedConstructionReplay === true}:${JSON.stringify(slotArguments ?? typeArguments ?? null)}`;
   const cachedDescriptor = descriptorCache.get(info)?.get(descriptorCacheKey);
   if (cachedDescriptor !== void 0) return cachedDescriptor;
   const constructionDocument = {
@@ -81500,10 +81876,7 @@ function validateClassConstructorDescriptor(info, ctx, requireEveryRequiredField
     valueById: ctx.vm.databaseVM?.defaultValueById ?? ctx.vm.databaseVM?.valueById,
     memberById: evaluatorDefaultValueDocument(ctx).memberById
   };
-  const classArguments2 = slotArguments ?? resolveConstructionTypeArguments(
-    info.schemaClassInfo.typeArguments,
-    constructionDocument
-  );
+  const classArguments2 = slotArguments ?? resolveConstructionTypeArguments(typeArguments, constructionDocument);
   const cacheDescriptor = (descriptor) => {
     const complete2 = {
       ...descriptor,
@@ -81615,6 +81988,33 @@ function validateClassConstructorDescriptor(info, ctx, requireEveryRequiredField
   }
   return cacheDescriptor({ schemaClass: schemaClass2, fields, instanceEnv, classArguments: classArguments2 });
 }
+function receiverClosedTypeArguments(typeArguments, ctx) {
+  if (typeArguments === void 0) return void 0;
+  let env = null;
+  let closed = null;
+  for (const [parameterId, typeInfo] of Object.entries(typeArguments)) {
+    if (!typeInfoContainsGeneric(typeInfo)) continue;
+    if (env === null) {
+      const row = ctx.thisValueRowId ? readNeoScriptRuntimeRow(ctx, ctx.thisValueRowId) : trackedRowForValueReference(ctx.thisValue, ctx);
+      if (row) {
+        env = runtimeGenericEnvForValueRow(row, ctx, /* @__PURE__ */ new Set());
+      } else if (ctx.__initializerGenericEnv !== void 0) {
+        env = ctx.__initializerGenericEnv;
+      } else {
+        throw new NSGetterRuntimeError(
+          "Cannot close a generic construction's type arguments without its Class receiver."
+        );
+      }
+    }
+    closed ??= { ...typeArguments };
+    closed[parameterId] = substituteRuntimeTypeInfo(
+      typeInfo,
+      env,
+      ctx
+    );
+  }
+  return closed ?? typeArguments;
+}
 function validateConstructorFieldSlot(args) {
   const { schemaKey, ctx } = args;
   const rawMember = evalMemberById(ctx.vm, args.memberId);
@@ -81841,8 +82241,7 @@ function applyConstructorFields(args) {
     const existingId = rootRecord[schemaKey];
     const existing = typeof existingId === "string" ? createdById.get(existingId) : void 0;
     if (existing !== void 0 && isLiteralValueContent(existing) && !isMemberClassBase(member) && !isMemberListBase(member) && !isMemberDictionaryBase(member)) {
-      existing.value = value;
-      existing.updatedAt = Date.now();
+      overwriteConstructedLiteral(existing, value, ctx);
       continue;
     }
     const materialized = materializeConstructorArgumentValue({
@@ -81857,6 +82256,14 @@ function applyConstructorFields(args) {
     rootRecord[schemaKey] = materialized.id;
   }
 }
+function overwriteConstructedLiteral(row, value, ctx) {
+  const references = ctx.__indexes?.rowByValueReference;
+  if (typeof row.value === "object" && row.value !== null)
+    references?.delete(row.value);
+  if (typeof value === "object" && value !== null) references?.set(value, row);
+  row.value = value;
+  row.updatedAt = Date.now();
+}
 function applyExplicitNullConstructorField(args) {
   const { schemaKey, member } = args.validated;
   if (isRequiredMember(member)) {
@@ -81867,8 +82274,7 @@ function applyExplicitNullConstructorField(args) {
   const existingId = args.rootRecord[schemaKey];
   const existing = typeof existingId === "string" ? args.createdById.get(existingId) : void 0;
   if (existing !== void 0 && isLiteralValueContent(existing) && !isMemberClassBase(member) && !isMemberListBase(member) && !isMemberDictionaryBase(member)) {
-    existing.value = null;
-    existing.updatedAt = Date.now();
+    overwriteConstructedLiteral(existing, null, args.ctx);
     return;
   }
   const cleared = registerConstructorArgumentRow(
@@ -82774,9 +83180,11 @@ function evaluateInitializerInContext(init, member, ctx, createdValues, argument
     compileMemberId
   });
   const closeFrame = pushConstructionFrame(ctx, `${member.name} initializer`);
+  const initializerCtx = ctx.thisValue === null ? ctx : bindThisValue(ctx, null);
+  const previousGenericEnv = initializerCtx.__initializerGenericEnv;
+  initializerCtx.__initializerGenericEnv = genericEnv;
   let result;
   try {
-    const initializerCtx = ctx.thisValue === null ? ctx : bindThisValue(ctx, null);
     result = evaluateNSGetterWithEffects(
       compiled,
       initializerCtx,
@@ -82792,6 +83200,7 @@ function evaluateInitializerInContext(init, member, ctx, createdValues, argument
       error.sourceOwnerId ??= ownerId;
     throw error;
   } finally {
+    initializerCtx.__initializerGenericEnv = previousGenericEnv;
     closeFrame();
   }
   const created = result.createdSessionValues ?? [];
@@ -82991,6 +83400,21 @@ function retargetConstructorGroupDependencies(provisionalRootId, replacementRoot
     replacementDependencies.add(dependencyRootId);
   }
 }
+function settledConstructorParameterMember(classId, parameterName, constructorId, ctx) {
+  const cache = evaluatorResolutionCache(ctx);
+  cache.constructorSettlement ??= createConstructorSettlementResolver({
+    classes: ctx.vm.classes,
+    constructors: ctx.vm.constructors,
+    members: ctx.vm.members
+  });
+  const settled = cache.constructorSettlement(
+    classId,
+    parameterName,
+    constructorId
+  );
+  if (settled === null) return void 0;
+  return evalMemberById(ctx.vm, settled.memberId) ?? void 0;
+}
 function encodeRequiredConstructorArgument(args) {
   const trackedId = findKnownRowIdByValueReference(args.value, args.ctx);
   const replayedAggregateId = trackedId === null && args.ctx.storedConstructionReplay === true && typeof args.value === "string" && evalValueById(
@@ -83036,6 +83460,14 @@ function encodeRequiredConstructorArgument(args) {
   const aggregateId = trackedId ?? replayedAggregateId;
   if (aggregateId !== null) return adoptTracked(aggregateId, "root");
   const collectionType = args.typeInfo;
+  const settled = args.member;
+  const registerCollectionRow = (value) => {
+    const row2 = registerRow(value);
+    const genericBindings = settled === void 0 ? void 0 : rowGenericBindings({ ...args, member: settled });
+    if (genericBindings !== void 0) row2.genericBindings = genericBindings;
+    return row2;
+  };
+  const entryMember = settled !== void 0 && (isMemberListBase(settled) || isMemberDictionaryBase(settled)) ? evalMemberById(args.ctx.vm, settled.entryMemberId) ?? void 0 : void 0;
   const registerRow = (value, containerId) => {
     args.ctx.beforeValueAllocation?.();
     const row2 = buildNewValue(args.ctx.vm.project.id, { value });
@@ -83067,7 +83499,8 @@ function encodeRequiredConstructorArgument(args) {
         ...args,
         value,
         typeInfo: entryType,
-        parameterId: `${args.parameterId}:${suffix}`
+        parameterId: `${args.parameterId}:${suffix}`,
+        member: entryMember
       });
       if (typeof nested !== "string") {
         throw new NSGetterRuntimeError(
@@ -83084,7 +83517,7 @@ function encodeRequiredConstructorArgument(args) {
         `Constructor argument '${args.parameterId}' must be a List.`
       );
     }
-    const row2 = registerRow([]);
+    const row2 = registerCollectionRow([]);
     row2.value = args.value.map(
       (entry, index) => encodeEntry(entry, collectionType.entryTypeInfo, `index:${index}`)
     );
@@ -83095,7 +83528,7 @@ function encodeRequiredConstructorArgument(args) {
       `Constructor argument '${args.parameterId}' must be a Dictionary.`
     );
   }
-  const row = registerRow({});
+  const row = registerCollectionRow({});
   row.value = Object.fromEntries(
     Object.entries(args.value).map(([key, entry]) => [
       key,
@@ -83928,6 +84361,14 @@ function constructDeclaredClassValueWithinFrame(descriptor, record7, info, scope
         ownerRootId: root.id,
         createdValues,
         storageKeyDeclarations,
+        // Only collection rows carry a stamp from the settled member.
+        member: resolvedArgumentType.type === 6 /* List */ || resolvedArgumentType.type === 5 /* Dictionary */ ? settledConstructorParameterMember(
+          classId,
+          argumentType.name,
+          record7.id,
+          ctx
+        ) : void 0,
+        genericEnv: descriptor.instanceEnv,
         ctx
       });
     }
@@ -85272,6 +85713,7 @@ var init_evaluateNSGetter = __esm({
     init_core();
     init_listener_write_index();
     init_type_info_equality();
+    init_constructor_parameter_settlement();
     init_typed_aggregate_row_references();
     init_member_change_listeners();
     init_project_root_members();
@@ -88646,10 +89088,20 @@ function sparsifyConstructedInstance(args) {
       protectedValueIds.add(row.id);
     }
   }
+  const protectArgument = (valueId, type) => {
+    protectedValueIds.add(valueId);
+    if (type.type !== 6 /* List */ && type.type !== 5 /* Dictionary */)
+      return;
+    const entries = materializedGraph.valuesById.get(valueId)?.value;
+    if (typeof entries !== "object" || entries === null) return;
+    for (const entryId of Object.values(entries))
+      if (typeof entryId === "string")
+        protectArgument(entryId, type.entryTypeInfo);
+  };
   for (const edge of materializedGraph.constructorEdges(
     args.constructed.root
   )) {
-    protectedValueIds.add(edge.targetValueId);
+    protectArgument(edge.targetValueId, edge.typeInfo);
   }
   for (const schemaKey of args.pinnedRootSchemaKeys ?? []) {
     const location3 = graph.locationsByPath.get(
@@ -90438,22 +90890,25 @@ function virtualReadRecorder(reads) {
     recordGlobalRead: reads.recordUnattributableValueRead
   };
 }
-function evaluateMemberInitializer(args) {
-  const databaseVM = initializerEvaluatorLookups(
-    args.document,
-    args.readTracking
-  );
+function compileMemberInitializer(args, databaseVM = initializerEvaluatorLookups(args.document)) {
   const initializerIndexes = databaseVM.constructorInitializerIndexes;
   const compileMemberId = initializerIndexes?.initializerScopeMemberIds.get(args.init) ?? (args.sourceValueId === null || args.sourceValueId === void 0 ? void 0 : initializerIndexes?.initializerScopeMemberIdsByValueId.get(
     args.sourceValueId
   ));
-  const compiled = ensureInitializerCompiled({
+  return ensureInitializerCompiled({
     init: args.init,
     member: args.member,
     initializerCompiler: args.document.initializerCompiler,
     sourceValueId: args.sourceValueId ?? null,
     compileMemberId
   });
+}
+function evaluateMemberInitializer(args) {
+  const databaseVM = initializerEvaluatorLookups(
+    args.document,
+    args.readTracking
+  );
+  const compiled = compileMemberInitializer(args, databaseVM);
   const ctx = {
     ...args.document.evaluationLimits,
     debugSink: args.document.debugSink,
@@ -90821,7 +91276,7 @@ function materializeMemberDefaultValue(args) {
       rootOwners,
       valuesById,
       (id2) => args.readTracking?.valueIds.add(id2)
-    ).ownerClass : typeof Reflect.get(member, "id") === "string" ? findSchemaPlacement(
+    ).ownerClass : typeof Reflect.get(member, "id") === "string" && !isStaticMember(member) ? findSchemaPlacement(
       String(Reflect.get(member, "id")),
       args.document.classes
     )?.ownerClass ?? null : null;
@@ -93274,6 +93729,9 @@ function initializerRequiresEvaluation(index, expression, targetClassName, runti
   if (expression.kind === "call") return !isLiteralCall(expression);
   if (isEvaluatedOnlyExpression(expression)) return true;
   if (expression.kind !== "new") return false;
+  if ((expression.typeArguments?.length ?? 0) > 0 && expression.className !== "Partial" && expression.className !== targetClassName) {
+    return true;
+  }
   const className = expression.className ?? targetClassName;
   if (!declaresConstructors(index, className)) return false;
   if (expression.hasArgumentList === true && expression.args.length > 0) {
@@ -93281,6 +93739,17 @@ function initializerRequiresEvaluation(index, expression, targetClassName, runti
   }
   return declaresParameterlessConstructor(index, className);
 }
+function constructsValue(expression) {
+  if (expression.kind === "annotated") {
+    return constructsValue(expression.expression);
+  }
+  if (expression.kind === "new") {
+    return expression.args.length > 0 || (expression.initializer?.length ?? 0) > 0;
+  }
+  if (expression.kind === "litList") return expression.elements.length > 0;
+  if (expression.kind === "litDict") return expression.entries.length > 0;
+  return false;
+}
 function requiredConstructorParameterNames(index, className) {
   if (className === null) return /* @__PURE__ */ new Set();
   const required2 = index.requiredByClassName.get(className);
@@ -93304,9 +93773,8 @@ function expressionReadsRuntimeIdentifier(expression, runtimeIdentifiers) {
         runtimeIdentifiers
       );
     case "new":
-      return expression.args.some(
-        (argument2) => expressionReadsRuntimeIdentifier(argument2, runtimeIdentifiers)
-      );
+    case "lambda":
+      return collectIdentifierReads(expression, runtimeIdentifiers).length > 0;
     case "call":
       return expressionReadsRuntimeIdentifier(
         expression.callee,
@@ -93349,8 +93817,6 @@ function expressionReadsRuntimeIdentifier(expression, runtimeIdentifiers) {
       return expression.parts.some(
         (part) => part.kind === "expr" && expressionReadsRuntimeIdentifier(part.expr, runtimeIdentifiers)
       );
-    case "lambda":
-      return false;
     case "litList":
     case "litDict":
     case "litNull":
@@ -93419,6 +93885,7 @@ var init_declared_constructors2 = __esm({
   "src/project-source/declared-constructors.ts"() {
     "use strict";
     init_declared_constructors();
+    init_strict_ast();
     EMPTY_DECLARED_CONSTRUCTOR_INDEX = {
       byClassName: /* @__PURE__ */ new Map(),
       requiredByClassName: /* @__PURE__ */ new Map(),
@@ -95985,7 +96452,7 @@ function lowerDefault(context, initializer, type, ownerClass, base, memberId, st
     return base.defaultValue;
   const indexPaths = reference2 ? indexPathDefault(expression) : null;
   if (indexPaths !== null) return { value: indexPaths, classId: null };
-  if (unorderedList && expression.kind === "litList" && expression.elements.length > 0 || positionRequiresEvaluation(context, expression, type, ownerClass)) {
+  if (unorderedList && expression.kind === "litList" && expression.elements.length > 0 || constructsValue(expression) && slotForwardsTypeParameter(context, type, ownerClass) || positionRequiresEvaluation(context, expression, type, ownerClass)) {
     return {
       init: {
         code: context.settleInitializerReferences(
@@ -96192,6 +96659,10 @@ function lowerExpressionValue(context, expression, declaredExpected, ownerClass,
   if (expected.name === "NeoAction") {
     return lowerActionDefault(context, expression, ownerClass, path);
   }
+  if (expected.name === "NeoDelegate") {
+    const memberId = methodGroupMemberId(context, expression, ownerClass);
+    if (memberId !== null) return { memberId, valueId: null };
+  }
   if (expected.name === NEO_VARIANT_TYPE_NAME || expected.name === NEO_LOOKUP_VARIANT_TYPE_NAME) {
     return lowerVariantDefault(context, expression, expected, path);
   }
@@ -96457,12 +96928,23 @@ function lowerExpressionValue(context, expression, declaredExpected, ownerClass,
       );
   }
 }
+function slotForwardsTypeParameter(context, type, ownerClass) {
+  if (type.name === "List" || type.name === "Dictionary") {
+    const entry = type.arguments.at(-1);
+    return entry !== void 0 && slotForwardsTypeParameter(context, entry, ownerClass);
+  }
+  if (!context.classIdsByName.has(type.name)) return false;
+  const parameters = context.genericParametersByClass.get(
+    materializedId(ownerClass, "class", ownerClass.name)
+  );
+  if (parameters === void 0) return false;
+  for (const argument2 of type.arguments) {
+    if (parameters.has(argument2.name)) return true;
+  }
+  return false;
+}
 function positionRequiresEvaluation(context, expression, expected, ownerClass) {
-  if (isStoredDelegateLiteral(expected, expression)) return false;
-  if (isStoredActionLiteral(expected, expression)) return false;
-  if (isSourceMemberValueRead(context, expression, ownerClass)) return true;
-  if (context.localValues.readsInstance(expression)) return true;
-  return initializerRequiresEvaluation(
+  const requiresEvaluation = () => initializerRequiresEvaluation(
     context.declaredConstructors,
     expression,
     expected.name,
@@ -96471,6 +96953,12 @@ function positionRequiresEvaluation(context, expression, expected, ownerClass) {
       ownerClass.name
     )
   );
+  if (isStoredDelegateLiteral(expected, expression))
+    return requiresEvaluation();
+  if (isStoredActionLiteral(expected, expression)) return false;
+  if (isSourceMemberValueRead(context, expression, ownerClass)) return true;
+  if (context.localValues.readsInstance(expression)) return true;
+  return requiresEvaluation();
 }
 function isSourceMemberValueRead(context, expression, ownerClass) {
   let current = expression;
@@ -96479,29 +96967,68 @@ function isSourceMemberValueRead(context, expression, ownerClass) {
   if (path === null) return false;
   if (path.startsWith("root.")) return true;
   const parts = path.split(".");
-  let classId;
-  let memberName;
-  let requiresStatic = false;
-  if (parts.length === 1 || parts.length === 2 && parts[0] === "this") {
-    classId = materializedId(ownerClass, "class", ownerClass.name);
-    memberName = parts.at(-1);
-  } else if (parts.length === 2) {
-    classId = context.classIdsByName.get(parts[0]);
-    memberName = parts[1];
-    requiresStatic = true;
-  } else {
-    const receiverPath = parts.slice(0, -1).join(".");
-    classId = context.rootValueTargetsByPath.get(receiverPath)?.classId;
-    memberName = parts.at(-1);
-  }
-  if (classId === void 0 || memberName === void 0) return false;
-  const memberId = effectiveMemberIdByName(context, classId, memberName);
+  const target = parts.length > 2 ? {
+    classId: context.rootValueTargetsByPath.get(
+      parts.slice(0, -1).join(".")
+    )?.classId,
+    memberName: parts.at(-1),
+    requiresStatic: false
+  } : classMemberPathTarget(context, parts, ownerClass);
+  if (target.classId === void 0 || target.memberName === void 0)
+    return false;
+  const memberId = effectiveMemberIdByName(
+    context,
+    target.classId,
+    target.memberName
+  );
   if (memberId === null) return false;
+  if (isFunctionMember(context, memberId)) return false;
+  return !target.requiresStatic || isStaticMember2(context, memberId);
+}
+function methodGroupMemberId(context, expression, ownerClass) {
+  const parts = expressionMemberPath(expression)?.split(".");
+  if (parts === void 0 || parts.length > 2) return null;
+  const target = classMemberPathTarget(context, parts, ownerClass);
+  if (target.classId === void 0 || target.memberName === void 0)
+    return null;
+  const memberId = effectiveMemberIdByName(
+    context,
+    target.classId,
+    target.memberName
+  );
+  if (memberId === null || !isFunctionMember(context, memberId)) return null;
+  if (target.requiresStatic && !isStaticMember2(context, memberId)) {
+    throw new Error(
+      `Delegate ${parts.join(".")} names an instance function; a default binds only Member or this.Member to its own instance.`
+    );
+  }
+  return memberId;
+}
+function classMemberPathTarget(context, parts, ownerClass) {
+  if (parts.length === 1 || parts[0] === "this") {
+    return {
+      classId: materializedId(ownerClass, "class", ownerClass.name),
+      memberName: parts.at(-1),
+      requiresStatic: false
+    };
+  }
+  return {
+    classId: context.classIdsByName.get(parts[0]),
+    memberName: parts[1],
+    requiresStatic: true
+  };
+}
+function isFunctionMember(context, memberId) {
+  const source = context.sourceMembersById.get(memberId)?.member;
+  if (source !== void 0) return source.kind === "function";
+  const schema = context.loweredMembers.get(memberId) ?? context.baseMembers.get(memberId);
+  return schema?.kind === "function" || schema?.kind === "scriptFunction";
+}
+function isStaticMember2(context, memberId) {
   const source = context.sourceMembersById.get(memberId)?.member;
-  if (source?.kind === "function") return false;
+  if (source !== void 0) return source.modifiers.includes("static");
   const schema = context.loweredMembers.get(memberId) ?? context.baseMembers.get(memberId);
-  const isStatic = source?.modifiers.includes("static") ?? schema?.modifier === "static";
-  return !requiresStatic || isStatic;
+  return schema?.modifier === "static";
 }
 function isStoredDelegateLiteral(type, expression) {
   if (type.name !== "NeoDelegate") return false;
@@ -96690,7 +97217,7 @@ function manifestTypeForMember(context, member) {
           return bindingMember === void 0 ? { name: "object", nullable: false, arguments: [] } : manifestTypeForMember(context, bindingMember);
         }
         return {
-          name: binding?.kind === "generic" ? genericParameterName(context, binding.genericParamId) : "object",
+          name: binding?.kind === "generic" ? genericParameterName2(context, binding.genericParamId) : "object",
           nullable: false,
           arguments: []
         };
@@ -96704,7 +97231,7 @@ function manifestTypeForMember(context, member) {
   }
   if (member.kind === "generic") {
     const genericType = {
-      name: genericParameterName(context, member.genericParamId),
+      name: genericParameterName2(context, member.genericParamId),
       nullable: nullable2,
       arguments: []
     };
@@ -96789,7 +97316,7 @@ function manifestTypeForSchemaType(context, type) {
       };
     case "generic":
       return {
-        name: genericParameterName(context, type.genericParamId),
+        name: genericParameterName2(context, type.genericParamId),
         nullable: nullable2,
         arguments: []
       };
@@ -96845,7 +97372,7 @@ function manifestTypeForSchemaType(context, type) {
       };
   }
 }
-function genericParameterName(context, genericParamId) {
+function genericParameterName2(context, genericParamId) {
   for (const parameters of context.genericParametersByClass.values()) {
     for (const [name, id2] of parameters) {
       if (id2 === genericParamId) return name;
@@ -97715,16 +98242,71 @@ var init_variant_selection_source = __esm({
   }
 });
 
+// src/project-source/delegate-value-source.ts
+function delegateValueSource(body, target) {
+  if (!isObjectRecord2(body)) {
+    throw new Error("NSDelegate value is not a closure or bound target.");
+  }
+  if (typeof body.code === "string") return body.code;
+  if (typeof body.memberId !== "string") {
+    throw new Error("NSDelegate bound target is missing memberId.");
+  }
+  if (body.valueId !== null && body.valueId !== void 0) {
+    throw new Error(
+      "NSDelegate instance-bound target cannot be represented by current project source."
+    );
+  }
+  const { name, staticClassName } = target(body.memberId);
+  return staticClassName === null ? name : `${staticClassName}.${name}`;
+}
+var init_delegate_value_source = __esm({
+  "src/project-source/delegate-value-source.ts"() {
+    "use strict";
+    init_value_comparison();
+  }
+});
+
+// src/project-source/member-records.ts
+function memberRecordOwnerClassId(member) {
+  const owner = isObjectRecord2(member.owner) ? member.owner : null;
+  if (owner === null) return null;
+  if (owner.kind !== "classMember" && owner.kind !== "sharedClassMember") {
+    return null;
+  }
+  if (typeof owner.classId === "string") return owner.classId;
+  const first = Array.isArray(owner.members) ? owner.members[0] : void 0;
+  if (!isObjectRecord2(first)) return null;
+  return typeof first.classId === "string" ? first.classId : null;
+}
+function memberOwnerClassIdIndex(classes) {
+  const result = /* @__PURE__ */ new Map();
+  for (const [classId, schemaClass2] of classes) {
+    if (!isObjectRecord2(schemaClass2.schema)) continue;
+    for (const memberId of Object.values(schemaClass2.schema)) {
+      if (typeof memberId === "string") result.set(memberId, classId);
+    }
+  }
+  return result;
+}
+var init_member_records = __esm({
+  "src/project-source/member-records.ts"() {
+    "use strict";
+    init_value_comparison();
+  }
+});
+
 // src/project-source/emitter.ts
 function emitProjectSourcesV4(manifest, options = {}) {
+  const classes = new Map(manifest.classes.map((entry) => [entry.id, entry]));
   const context = {
     manifest,
     classBindings: /* @__PURE__ */ new Map(),
-    classes: new Map(manifest.classes.map((entry) => [entry.id, entry])),
+    classes,
     interfaces: new Map(manifest.interfaces.map((entry) => [entry.id, entry])),
     enums: new Map(manifest.enums.map((entry) => [entry.id, entry])),
     dictionaryKeyOptions: /* @__PURE__ */ new Map(),
     members: new Map(manifest.members.map((entry) => [entry.id, entry])),
+    ownerClassIds: memberOwnerClassIdIndex(classes),
     constructorsById: new Map(
       manifest.constructors.map((entry) => [entry.id, entry])
     ),
@@ -98901,6 +99483,25 @@ function renderDefaultValue(context, member, wrapper, enclosingClassId) {
   if (member.kind === "action") {
     return renderActionListeners(context, member, value);
   }
+  if (member.kind === "delegate") {
+    return delegateValueSource(value, (memberId) => {
+      const target = required(context.members, memberId, "delegate target");
+      if (target.kind !== "function" && target.kind !== "scriptFunction" && target.kind !== "delegate") {
+        throw new Error(`NSDelegate target ${memberId} is not callable.`);
+      }
+      if (target.modifier !== "static") {
+        return { name: target.name, staticClassName: null };
+      }
+      const classId = context.ownerClassIds.get(memberId);
+      if (classId === void 0) {
+        throw new Error(`Static NSDelegate target ${memberId} has no Class.`);
+      }
+      return {
+        name: target.name,
+        staticClassName: required(context.classes, classId, "class").name
+      };
+    });
+  }
   if (member.kind === "variant") {
     return renderVariantSelectionV4(context, member.name, value);
   }
@@ -99532,6 +100133,8 @@ var init_emitter = __esm({
     init_members();
     init_structured_leaf_source();
     init_variant_selection_source();
+    init_delegate_value_source();
+    init_member_records();
     SPECIALIZED_RELATION_PROPERTIES = /* @__PURE__ */ new Map([
       ["world.grid.tile-import", { property: "tileImports", collection: true }],
       ["world.grid.object-import", { property: "objectImports", collection: true }],
@@ -110090,10 +110693,10 @@ function compiledConstructionTypeMembers(members, bodies, projectId) {
       } else if (type.type === 25 /* NSDelegate */) {
         return {
           returnTypeInfo: type.returnTypeInfo,
-          argumentTypes: type.argumentTypes
+          argumentTypes: namedArguments2(type.argumentTypes)
         };
       } else if (type.type === 26 /* NSAction */) {
-        return { argumentTypes: type.argumentTypes };
+        return { argumentTypes: namedArguments2(type.argumentTypes) };
       } else if (type.type === 22 /* Interface */ || type.type === 9 /* Lookup */ || type.type === 18 /* DialogueLookup */) {
         return null;
       } else {
@@ -110124,6 +110727,12 @@ function compiledConstructionTypeMembers(members, bodies, projectId) {
   for (const body of bodies) visit(body);
   return created;
 }
+function namedArguments2(argumentTypes) {
+  return argumentTypes.map((type, index) => ({
+    ...type,
+    name: `p${index + 1}`
+  }));
+}
 function withCompiledConstructionTypes(document, body) {
   const members = document.members;
   const projectId = getField(document.project, "id");
@@ -114804,6 +115413,7 @@ function materializeAuthoredValueSeeds(args) {
     args.authoredValueSeeds
   );
   const consumedSeedMemberIds = /* @__PURE__ */ new Set();
+  const sharedBindings = [];
   for (let index = 0; index < args.prepared.length; index += 1) {
     const change = args.prepared[index];
     if (change?.recordKind !== "member" || change.operation === "delete" || change.nextData === void 0) {
@@ -114847,11 +115457,8 @@ function materializeAuthoredValueSeeds(args) {
     }
     if (change.operation === "update" && seed === void 0) continue;
     if (change.operation === "create" && seed === void 0 && typeof member.valueId === "string") {
-      if (!documentIndex.valuesById.has(member.valueId)) {
-        throw new Error(
-          `Stored static member "${member.name}" (${member.id}) binds missing value "${member.valueId}".`
-        );
-      }
+      if (!documentIndex.valuesById.has(member.valueId))
+        sharedBindings.push({ member, valueId: member.valueId });
       continue;
     }
     const shouldBind = isRequiredMember(member) || seed !== void 0;
@@ -114994,6 +115601,20 @@ function materializeAuthoredValueSeeds(args) {
     });
     consumedSeedMemberIds.add(seed.memberId);
   }
+  if (sharedBindings.length > 0) {
+    const createdValueIds = /* @__PURE__ */ new Set();
+    for (const change of args.prepared) {
+      if (change.recordKind === "value" && change.operation === "create")
+        createdValueIds.add(change.recordId);
+    }
+    for (const { member, valueId } of sharedBindings) {
+      if (!createdValueIds.has(valueId)) {
+        throw new Error(
+          `Stored static member "${member.name}" (${member.id}) binds missing value "${valueId}".`
+        );
+      }
+    }
+  }
   return pendingGraphValidations;
 }
 function materializeExistingAuthoredValueSeed(args) {
@@ -116041,9 +116662,10 @@ function commitInitEvaluator(document, createdValues) {
 function hasAuthoredNeoScriptBody(member) {
   if (member.kind === 10 /* NSProperty */) return true;
   if (member.kind === 23 /* NSFunction */) return true;
-  if (isMemberDelegateBase(member) && isLiteralValueContent(member.defaultValue) && (isNSDelegateClosureValueDraft(member.defaultValue.value) || isNSDelegateClosureValue(member.defaultValue.value)))
+  const defaultValue = getField(member, "defaultValue");
+  if (member.kind === 25 /* NSDelegate */ && isLiteralValueContent(defaultValue) && (isNSDelegateClosureValueDraft(defaultValue.value) || isNSDelegateClosureValue(defaultValue.value)))
     return true;
-  return isInitValueContent(member.defaultValue);
+  return isInitValueContent(defaultValue);
 }
 function touchedInitializerFilter(prepared) {
   const createdClassIds = /* @__PURE__ */ new Set();
@@ -116083,7 +116705,6 @@ function assertTouchedInitializersConstruct(args) {
   );
   const schemaIndex = projectSchemaIndexFor(args.document);
   for (const site of sites) {
-    if ((site.init.compiled?.parameters.length ?? 2) > 2) continue;
     if (site.sourceValueId === void 0 && [
       ...referencedGenericParams(
         resolveMember(site.member, args.document.members),
@@ -116091,6 +116712,13 @@ function assertTouchedInitializersConstruct(args) {
       )
     ].some((paramId) => site.genericEnv.get(paramId)?.kind !== "member"))
       continue;
+    const compiled = compileMemberInitializer({
+      init: site.init,
+      member: site.member,
+      document: args.document,
+      sourceValueId: site.sourceValueId
+    });
+    if (compiled.parameters.length > 2) continue;
     const createdValues = [];
     const produced = evaluateMemberInitializer({
       init: site.init,
@@ -120502,9 +121130,6 @@ function isOpaqueCallableMemberIdentifier(value) {
 function isOpaqueCallableArgumentIdentifier(value) {
   return isOpaqueGeneratedIdentifier(value, isValidNeoProjectBindingIdentifier) && !value.startsWith("__");
 }
-function isOpaqueNSFunctionArgumentIdentifier(value) {
-  return isOpaqueCallableArgumentIdentifier(value) && value !== "value";
-}
 function isOpaqueNSTypeInfo(value, ancestors = /* @__PURE__ */ new Set()) {
   if (!isRecord8(value) || typeof value.required !== "boolean") return false;
   if (value.type === "Unknown") return true;
@@ -120596,11 +121221,7 @@ function isOpaqueNSFunctionReturnTypeInfo(value) {
   }
   return isOpaqueNSTypeInfo(value);
 }
-function isOpaqueNSFunctionArgumentTypeInfo(value) {
-  return isOpaqueNSTypeInfo(value) && isOpaqueNSFunctionArgumentIdentifier(value.name) && !opaqueTypeInfoContainsUnknown(value) && hasValidOpaqueParameterDefault(value);
-}
-function isOpaqueConstructorArgumentTypeInfo(value) {
-  if (!isRecord8(value)) return false;
+function isOpaqueCallableArgumentTypeInfo(value) {
   return isOpaqueNSTypeInfo(value) && isOpaqueCallableArgumentIdentifier(value.name) && !opaqueTypeInfoContainsUnknown(value) && hasValidOpaqueParameterDefault(value);
 }
 function hasValidOpaqueParameterDefault(value) {
@@ -121691,7 +122312,7 @@ function resolveOpaqueNSFunctionSignature(member, membersById) {
     }
     seen.add(cursor.id);
     if (cursor.kind !== 23) return null;
-    if (isOpaqueNSFunctionReturnTypeInfo(cursor.returnTypeInfo) && Array.isArray(cursor.argumentTypes) && cursor.argumentTypes.every(isOpaqueNSFunctionArgumentTypeInfo)) {
+    if (isOpaqueNSFunctionReturnTypeInfo(cursor.returnTypeInfo) && Array.isArray(cursor.argumentTypes) && cursor.argumentTypes.every(isOpaqueCallableArgumentTypeInfo)) {
       return {
         returnTypeInfo: cursor.returnTypeInfo,
         argumentTypes: cursor.argumentTypes,
@@ -121957,7 +122578,7 @@ function assertOpaqueConstructorValid(declaredConstructor) {
     );
   }
   const argumentTypes = declaredConstructor.argumentTypes;
-  if (!argumentTypes.every(isOpaqueConstructorArgumentTypeInfo)) {
+  if (!argumentTypes.every(isOpaqueCallableArgumentTypeInfo)) {
     throw new Error(
       `Constructor "${declaredConstructor.id}" argumentTypes are invalid.`
     );
@@ -122262,8 +122883,8 @@ function assertOpaqueNSFunctionValid(member, membersById, typeInfoInDeclaringCla
   if (!Array.isArray(member.argumentTypes)) {
     throw new Error(`NSFunction "${member.id}" argumentTypes are invalid.`);
   }
-  if (!member.argumentTypes.every(isOpaqueNSFunctionArgumentTypeInfo)) {
-    throw new Error(`NSFunction "${member.id}" argumentTypes are invalid.`);
+  if (!member.argumentTypes.every(isOpaqueCallableArgumentTypeInfo)) {
+    throw new Error(`NSFunction "${member.id}" has an invalid argument type.`);
   }
   const argumentNames = /* @__PURE__ */ new Set();
   for (const argument2 of member.argumentTypes) {
@@ -126829,35 +127450,6 @@ var init_lower_variants = __esm({
   }
 });
 
-// src/project-source/member-records.ts
-function memberRecordOwnerClassId(member) {
-  const owner = isObjectRecord2(member.owner) ? member.owner : null;
-  if (owner === null) return null;
-  if (owner.kind !== "classMember" && owner.kind !== "sharedClassMember") {
-    return null;
-  }
-  if (typeof owner.classId === "string") return owner.classId;
-  const first = Array.isArray(owner.members) ? owner.members[0] : void 0;
-  if (!isObjectRecord2(first)) return null;
-  return typeof first.classId === "string" ? first.classId : null;
-}
-function memberOwnerClassIdIndex(classes) {
-  const result = /* @__PURE__ */ new Map();
-  for (const [classId, schemaClass2] of classes) {
-    if (!isObjectRecord2(schemaClass2.schema)) continue;
-    for (const memberId of Object.values(schemaClass2.schema)) {
-      if (typeof memberId === "string") result.set(memberId, classId);
-    }
-  }
-  return result;
-}
-var init_member_records = __esm({
-  "src/project-source/member-records.ts"() {
-    "use strict";
-    init_value_comparison();
-  }
-});
-
 // src/project-source/root-value-paths.ts
 function rootValuePathsByValueId(records3, storedPlacements) {
   const allRecords = [...records3];
@@ -126998,7 +127590,7 @@ function buildValueEmitIndexesV4(records3, manifest, localizedTextDependencies,
   const enums = dataById(records3, "enum");
   const localizedTexts = dataById(records3, "localized-text");
   const dialogues = dataById(records3, "dialogue");
-  const symbolsByValueId = staticSymbols(classes, members);
+  const { symbolsByValueId, staticOwnerIds } = staticSymbols(classes, members);
   let document;
   const readDocument = () => document ??= trackPulledLocalizedTextReads(
     readPulledProjectDocumentV4(records3),
@@ -127139,6 +127731,7 @@ function buildValueEmitIndexesV4(records3, manifest, localizedTextDependencies,
     localizedTexts,
     mainLocale: projectMainLocale(records3),
     symbolsByValueId,
+    staticOwnerIds,
     rootPathsByValueId,
     readRootIndexPaths: () => rootIndexPaths ??= indexRootIndexPaths(
       values,
@@ -127190,7 +127783,8 @@ function emitStoredValueBindingSourcesV4(records3, memberIds, options) {
     );
     let initializer = emitValue(context, member, valueId, {
       environment: declaringClassGenericEnvironment(context, member),
-      definitionSite: true,
+      // A static sharing another static's row names that static (#1385).
+      definitionSite: (context.staticOwnerIds.get(valueId) ?? memberId) === memberId,
       // The row is `derivedMemberValueId(memberId)` and the declaration
       // above it already carries `@id(memberId)`.
       writeIdentity: false,
@@ -128433,14 +129027,8 @@ function mergedOverStoredRow(base, lowered) {
   if (storedArgs !== null && loweredArgs !== null) {
     let preserved = null;
     for (const [key, argument2] of Object.entries(loweredArgs)) {
-      if (!isObjectRecord2(argument2)) continue;
-      if (typeof argument2.code !== "string") continue;
-      if ("action" in argument2) continue;
-      const stored = storedArgs[key];
-      if (!isObjectRecord2(stored)) continue;
-      if (typeof stored.code !== "string") continue;
-      if (!sameNeoScriptTokens(stored.code, argument2.code)) continue;
-      if (!("action" in stored)) continue;
+      const stored = storedCompiledClosure(storedArgs[key], argument2);
+      if (stored === null) continue;
       preserved ??= { ...loweredArgs };
       preserved[key] = stored;
     }
@@ -128472,6 +129060,13 @@ function mergedOverStoredRow(base, lowered) {
   void _instanceVariantRowValueId;
   return initializer;
 }
+function storedCompiledClosure(stored, lowered) {
+  if (!isNSDelegateClosureValueDraft(lowered)) return null;
+  if (!isObjectRecord2(stored)) return null;
+  if (typeof stored.code !== "string") return null;
+  if (!("action" in stored)) return null;
+  return sameNeoScriptTokens(stored.code, lowered.code) ? stored : null;
+}
 function variantRowFields(row) {
   return { id: row.id, ...encodeStoredValueRowFields(row) };
 }
@@ -128696,6 +129291,15 @@ function lowerMemberDefaultSourcesV4(state, analysis, manifest, options = {}) {
         }
         continue;
       }
+      const loweredDefault = member.defaultValue;
+      const storedClosure = loweredDefault !== null && "value" in loweredDefault ? storedCompiledClosure(storedDefault?.value, loweredDefault.value) : null;
+      if (storedClosure !== null) {
+        memberDefaultValues.set(memberId, {
+          value: storedClosure,
+          classId: null
+        });
+        continue;
+      }
       if (!defaultRequiresOwnedRows(context, member, expression, binding)) {
         if (member.kind === "lookup" || member.kind === "dialogueLookup") {
           const entries = expression.kind === "litList" ? expression.elements : [expression];
@@ -129397,7 +130001,7 @@ function memberInitializerRequiresEvaluation(context, member, expression, source
     return false;
   }
   const unorderedDefault = source.purpose === "memberDefault" && member.id === source.memberId && member.kind === "list" && member.listKind === "unordered" && expression.kind === "litList" && expression.elements.length > 0;
-  const requiresEvaluation = unorderedDefault || context.localValues.readsInstance(expression) || isSchemaMemberValueRead(context, expression, source) || isUnresolvedLiteralName(context, member, expression) || initializerRequiresEvaluation(
+  const requiresEvaluation = unorderedDefault || source.purpose === "memberDefault" && member.id === source.memberId && constructsValue(expression) && slotForwardsTypeParameter2(context, member, source.ownerClassId) || context.localValues.readsInstance(expression) || isSchemaMemberValueRead(context, expression, source) || isUnresolvedLiteralName(context, member, expression) || initializerRequiresEvaluation(
     context.declaredConstructors,
     expression,
     memberClassName(context, member),
@@ -129405,6 +130009,20 @@ function memberInitializerRequiresEvaluation(context, member, expression, source
   );
   return requiresEvaluation;
 }
+function slotForwardsTypeParameter2(context, member, ownerClassId) {
+  if (member.kind === "list" || member.kind === "dictionary") {
+    const entry = context.members.get(member.entryMemberId);
+    return entry !== void 0 && slotForwardsTypeParameter2(context, entry, ownerClassId);
+  }
+  if (member.kind !== "class") return false;
+  let bindings;
+  for (const argument2 of Object.values(member.classArguments ?? {})) {
+    if (argument2.kind !== "generic") continue;
+    bindings ??= ownerClassId === void 0 ? /* @__PURE__ */ new Map() : classGenericBindings(context.classes, ownerClassId);
+    if (bindings.get(argument2.genericParamId)?.kind !== "member") return true;
+  }
+  return false;
+}
 function isIndexPathReferenceValue(sourceExpression) {
   const expression = annotatedValue(sourceExpression).expression;
   const elements = expression.kind === "litList" ? expression.elements : [expression];
@@ -129432,7 +130050,7 @@ function isSchemaMemberValueRead(context, expression, source) {
   if (classId === void 0) return false;
   const memberId = classSchemaMemberId(context, classId, name);
   const member = memberId === null ? void 0 : context.members.get(memberId);
-  return member !== void 0 && member.kind !== "function" && (staticClass === void 0 || member.modifier === "static");
+  return member !== void 0 && member.kind !== "function" && member.kind !== "scriptFunction" && (staticClass === void 0 || member.modifier === "static");
 }
 function isUnresolvedLiteralName(context, member, sourceExpression) {
   const expression = annotatedValue(sourceExpression).expression;
@@ -129657,6 +130275,7 @@ function lowerRowBackedDefault(context, member, backed, baseData3, binding) {
       schemaClass2,
       expression,
       environment,
+      member.classArguments,
       binding.label
     );
     const baseBody = retainedStoredClassBody(
@@ -129837,6 +130456,18 @@ function lowerRowBackedDefault(context, member, backed, baseData3, binding) {
     `Default value ${binding.label} does not match its persisted ${member.kind} container shape.`
   );
 }
+function foreignDelegateCopy(context, member, expression, binding) {
+  if (member.kind !== "delegate") return null;
+  const path = memberPath2(annotatedValue(expression).expression);
+  const parts = path?.split(".");
+  if (path === null || parts?.length !== 2) return null;
+  const owner = context.classesByName.get(parts[0]);
+  if (owner === void 0 || owner.id === binding.ownerClassId) return null;
+  const targetId = classSchemaMemberId(context, owner.id, parts[1]);
+  if (targetId === null) return null;
+  const target = context.members.get(targetId);
+  return target?.kind === "delegate" && target.modifier === "static" ? path : null;
+}
 function lowerStoredBinding(context, binding, memberValueIds, seeds) {
   const member = context.members.get(binding.memberId);
   if (member === void 0) {
@@ -129860,7 +130491,19 @@ function lowerStoredBinding(context, binding, memberValueIds, seeds) {
     binding.initializer
   );
   const currentValueId = typeof memberData?.valueId === "string" ? memberData.valueId : null;
-  const referenced = sourceValueSymbol(context, expression);
+  const foreign = foreignDelegateCopy(context, member, expression, binding);
+  if (foreign !== null) {
+    context.loweringFailures.push({
+      message: `Static delegate ${member.name} cannot copy ${foreign} from another Class; write () => ${foreign}() instead.`,
+      site: referenceSite(binding, expression)
+    });
+    memberValueIds.set(
+      binding.memberId,
+      currentValueId ?? memberValueId(binding.memberId)
+    );
+    return;
+  }
+  const referenced = member.kind === "class" || member.kind === "list" || member.kind === "dictionary" ? sourceValueSymbol(context, expression) : null;
   if (referenced !== null) {
     const listeners = context.listenerBindings.get(
       `${binding.purpose}:${binding.memberId}`
@@ -130267,7 +130910,12 @@ function lowerSeedRow(context, member, sourceExpression, source, valueId, path,
       authoredSlice
     );
   }
-  if (!isStoredCallableLiteral(resolvedMember.kind, expression) && memberInitializerRequiresEvaluation(
+  if (!isStoredCallableLiteral(
+    context,
+    resolvedMember.kind,
+    expression,
+    source
+  ) && memberInitializerRequiresEvaluation(
     context,
     resolvedMember,
     expression,
@@ -130395,6 +131043,7 @@ function lowerSeedRow(context, member, sourceExpression, source, valueId, path,
         effectiveClass,
         expression,
         environment,
+        resolvedMember.classArguments,
         path
       );
     }
@@ -131154,7 +131803,12 @@ function lowerValueRow(context, member, sourceExpression, expectedValueId, sourc
     member,
     environment
   );
-  if (!isStoredCallableLiteral(resolvedMember.kind, expression) && memberInitializerRequiresEvaluation(
+  if (!isStoredCallableLiteral(
+    context,
+    resolvedMember.kind,
+    expression,
+    source
+  ) && memberInitializerRequiresEvaluation(
     context,
     resolvedMember,
     expression,
@@ -131347,8 +132001,8 @@ function lowerValueBody(context, member, expression, base, source, environment,
     case "delegate": {
       const value = lowerDelegateValue(
         context,
+        source,
         expression,
-        source.ownerClassId,
         authoredSlice
       );
       if (isObjectRecord2(value) && typeof value.code === "string" && typeof base.id === "string")
@@ -131472,6 +132126,7 @@ function lowerClassValue(context, member, expression, base, source, outerEnviron
       schemaClass2,
       expression,
       environment,
+      member.classArguments,
       String(base.id ?? member.name)
     );
   }
@@ -132184,7 +132839,7 @@ function genericBindingClassId(context, bindingMemberId) {
   const rawBinding = stateData(context, "member", bindingMemberId);
   return rawBinding?.kind === 7 && typeof rawBinding.classId === "string" ? rawBinding.classId : null;
 }
-function validateConstructedGenericArguments(context, schemaClass2, expression, environment, path) {
+function validateConstructedGenericArguments(context, schemaClass2, expression, environment, slotArguments, path) {
   const actual = expression.className === "Partial" ? [] : expression.typeArguments ?? [];
   const expected = schemaClass2.genericParameters;
   if (expected.length === 0) {
@@ -132206,12 +132861,15 @@ function validateConstructedGenericArguments(context, schemaClass2, expression,
       `Class ${schemaClass2.name} requires ${expected.length} type argument${expected.length === 1 ? "" : "s"} (${path}).`
     );
   }
+  let forwarded;
   for (let index = 0; index < expected.length; index++) {
     const parameter4 = expected[index];
     const bindingMemberId = environment.get(parameter4.id);
     const inferredClassId = inferredGenericClassId(bindingMemberId);
     const bindingMember = inferredClassId === null && bindingMemberId ? context.members.get(bindingMemberId) : void 0;
-    const expectedName = inferredClassId ? context.classes.get(inferredClassId)?.name ?? null : bindingMember ? lowerSchemaMemberTypeName(context, bindingMember) : bindingMemberId ? lowerRawMemberTypeName(context, bindingMemberId) : null;
+    const closedName = inferredClassId ? context.classes.get(inferredClassId)?.name ?? null : bindingMember ? lowerSchemaMemberTypeName(context, bindingMember) : bindingMemberId ? lowerRawMemberTypeName(context, bindingMemberId) : null;
+    forwarded ??= closedName === null ? forwardedParameterNames(context, schemaClass2.id, slotArguments) : void 0;
+    const expectedName = closedName ?? forwarded?.get(parameter4.id) ?? null;
     const actualName = actual[index] ? astTypeNameV4(actual[index]) : null;
     if (expectedName === null || actualName !== expectedName) {
       throw new Error(
@@ -132220,20 +132878,65 @@ function validateConstructedGenericArguments(context, schemaClass2, expression,
     }
   }
 }
+function forwardedParameterNames(context, classId, slotArguments) {
+  const names = /* @__PURE__ */ new Map();
+  const bindings = classGenericBindings(context.classes, classId);
+  for (const [genericParamId, argument2] of Object.entries(slotArguments)) {
+    if (argument2.kind === "member") continue;
+    const terminal2 = bindings.get(genericParamId);
+    if (terminal2?.kind === "member") continue;
+    const name = genericParameterName3(context.classes, argument2.genericParamId);
+    if (terminal2 !== void 0 && name !== void 0) {
+      names.set(terminal2.genericParamId, name);
+    }
+  }
+  return names;
+}
+function genericParameterName3(classes, genericParamId) {
+  let names = genericParameterNamesByClasses.get(classes);
+  if (names === void 0) {
+    const built = /* @__PURE__ */ new Map();
+    for (const schemaClass2 of classes.values()) {
+      for (const parameter4 of schemaClass2.genericParameters) {
+        built.set(parameter4.id, parameter4.name);
+      }
+    }
+    genericParameterNamesByClasses.set(classes, built);
+    names = built;
+  }
+  return names.get(genericParamId);
+}
 function lowerRawMemberTypeName(context, memberId) {
   const member = stateData(context, "member", memberId);
   if (!member) return null;
-  if (member.kind === 7 && typeof member.classId === "string") {
+  if (member.kind === 7 /* Class */ && typeof member.classId === "string") {
     return context.classes.get(member.classId)?.name ?? null;
   }
+  if (member.kind === 8 /* Enum */ && typeof member.enumId === "string") {
+    return context.enumNames.get(member.enumId) ?? null;
+  }
+  if (member.kind === 6 /* List */) return "List";
+  if (member.kind === 5 /* Dictionary */) return "Dictionary";
+  if (member.kind === 25 /* NSDelegate */) return "NeoDelegate";
   return typeof member.kind === "number" ? fixedSourceTypeNameForKindNumber(member.kind) : null;
 }
 function lowerSchemaMemberTypeName(context, member) {
-  if (member.kind === "class") {
-    return context.classes.get(member.classId)?.name ?? null;
+  switch (member.kind) {
+    case "class":
+      return context.classes.get(member.classId)?.name ?? null;
+    case "enum":
+      return context.enumNames.get(member.enumId) ?? null;
+    case "list":
+      return "List";
+    case "dictionary":
+      return "Dictionary";
+    case "delegate":
+      return "NeoDelegate";
+    case "generic":
+      return null;
+    default:
+      return fixedSourceTypeNameForKind(member.kind) ?? member.kind;
   }
-  if (member.kind === "generic") return null;
-  return fixedSourceTypeNameForKind(member.kind) ?? member.kind;
 }
 function constructedClass(context, member, expression, currentClassId, path) {
   if (member.partial === true) {
@@ -133711,9 +134414,16 @@ function lowerFunctionReference(context, expression, ownerClassId) {
   }
   return { functionMemberId: target.id };
 }
-function isStoredCallableLiteral(kind, expression) {
+function isStoredCallableLiteral(context, kind, expression, source) {
+  if (kind === "delegate" && expression.kind === "lambda")
+    return !initializerRequiresEvaluation(
+      context.declaredConstructors,
+      expression,
+      null,
+      bindingRuntimeIdentifiers(context, source)
+    );
   if (kind === "delegate")
-    return expression.kind === "lambda" || memberPath2(expression) !== null;
+    return memberPath2(expression) !== null && !isSchemaMemberValueRead(context, expression, source);
   if (kind !== "action") return false;
   return expression.kind === "litList";
 }
@@ -133788,7 +134498,7 @@ function lowerActionListener2(context, element, ownerClassId, index) {
   }
   return { memberId: target.id, valueId };
 }
-function lowerDelegateValue(context, expression, ownerClassId, authoredSlice) {
+function lowerDelegateValue(context, source, expression, authoredSlice) {
   if (expression.kind === "lambda") {
     const code = initializerExpressionSlice(authoredSlice);
     if (code === void 0) {
@@ -133798,25 +134508,60 @@ function lowerDelegateValue(context, expression, ownerClassId, authoredSlice) {
     }
     return { code };
   }
-  const path = memberPath2(expression);
-  const symbol = path?.startsWith("this.") ? path.slice("this.".length) : path;
-  if (symbol === null || symbol === void 0 || symbol.includes(".")) {
-    throw new Error(
-      "Delegate method groups require a function, NSFunction, or NSDelegate member on the current Class."
-    );
+  const target = methodGroupTarget(context, expression, source.ownerClassId);
+  if ("failure" in target) {
+    context.loweringFailures.push({
+      message: target.failure,
+      site: referenceSite(source, expression)
+    });
+    return null;
   }
-  if (ownerClassId === void 0) {
-    throw new Error(
-      `Delegate ${symbol} cannot be resolved without its owning Class.`
-    );
+  return { memberId: target.memberId, valueId: null };
+}
+function methodGroupTarget(context, expression, ownerClassId) {
+  const path = memberPath2(expression)?.split(".");
+  if (path === void 0 || path.length > 2) {
+    return {
+      failure: "Delegate method groups name a member, this.Member, or Class.Member."
+    };
   }
-  const target = classMemberByName(context, ownerClassId, symbol);
-  if (target.kind !== "function" && target.kind !== "scriptFunction" && target.kind !== "delegate") {
-    throw new Error(
-      `Delegate ${symbol} does not resolve to a function, NSFunction, or NSDelegate member.`
-    );
+  const symbol = path.at(-1);
+  const qualifier = path.length === 2 && path[0] !== "this" ? path[0] : null;
+  let classId;
+  if (qualifier === null) {
+    if (ownerClassId === void 0) {
+      throw new Error(
+        `Delegate ${symbol} cannot be resolved without its owning Class.`
+      );
+    }
+    classId = ownerClassId;
+  } else {
+    const named = context.classesByName.get(qualifier);
+    if (named === void 0) {
+      return {
+        failure: `Delegate ${qualifier}.${symbol} names no Class ${qualifier}.`
+      };
+    }
+    classId = named.id;
+  }
+  const targetId = classMemberIdByName(context, classId, symbol);
+  if (targetId === null) {
+    return {
+      failure: `Delegate ${path.join(".")} names no member of Class ${context.classes.get(classId)?.name ?? classId}.`
+    };
   }
-  return { memberId: target.id, valueId: null };
+  const target = requiredMember(context, targetId);
+  if (target.kind !== "function" && target.kind !== "scriptFunction") {
+    return {
+      failure: `Delegate ${path.join(".")} does not name a function or NSFunction member.`
+    };
+  }
+  if (qualifier !== null && target.modifier !== "static") {
+    return {
+      failure: `Delegate ${qualifier}.${symbol} names an instance function; a default binds only Member or this.Member to its own instance.`
+    };
+  }
+  return { memberId: target.id };
 }
 function fileTargetId(context, expression, registry) {
   const path = memberPath2(expression);
@@ -134712,18 +135457,20 @@ function materializedValueSubgraphsEqual(context, currentGraph, replayGraph, cur
   if (!isAnyMemberBase(resolvedMember))
     throw new Error("Settle comparison has an invalid member descriptor.");
   const document = context.readDocument();
+  const genericEnv = /* @__PURE__ */ new Map();
+  for (const [id2, memberId] of environment)
+    genericEnv.set(id2, { kind: "member", memberId });
   const typeInfo = resolveMemberDeclaredTypeInfo(
     resolvedMember,
-    document.members
+    document.members,
+    null,
+    genericEnv
   );
   if (typeInfo === null) {
     throw new Error(
       `Stored member ${String(member.name ?? member.id)} has no declared type for materialized settle comparison.`
     );
   }
-  const genericEnv = /* @__PURE__ */ new Map();
-  for (const [id2, memberId] of environment)
-    genericEnv.set(id2, { kind: "member", memberId });
   return context.compareEffectiveValues(
     currentGraph.normalizeTypedRow(
       currentId,
@@ -134740,7 +135487,7 @@ function materializedValueSubgraphsEqual(context, currentGraph, replayGraph, cur
     )
   ) === 0;
 }
-function firstRequiredConstructorParameterKey(context, classId) {
+function firstRequiredConstructorParameterKey(context, classId, environment) {
   const seen = /* @__PURE__ */ new Set();
   let cursor = classId;
   while (cursor !== void 0 && !seen.has(cursor)) {
@@ -134764,7 +135511,7 @@ function firstRequiredConstructorParameterKey(context, classId) {
           continue;
         }
         if (constructorParameterIsRequired(
-          isRequiredMember(member),
+          kind === 21 /* Generic */ ? genericSlotIsRequired(context, member, environment) : isRequiredMember(member),
           member.defaultValue
         )) {
           return schemaKey;
@@ -134775,6 +135522,11 @@ function firstRequiredConstructorParameterKey(context, classId) {
   }
   return null;
 }
+function genericSlotIsRequired(context, member, environment) {
+  const bindingId = environment.get(stringField2(member, "genericParamId"));
+  const binding = bindingId === void 0 ? void 0 : context.members.get(bindingId);
+  return binding === void 0 || isRequiredMember(binding);
+}
 function storedConstructorCallSource(context, schemaClass2, value, className, environment, visited, targetTyped, cloneAggregateArguments = false) {
   const constructorArgs2 = value.constructorArgs;
   if (!isObjectRecord2(constructorArgs2)) return null;
@@ -134790,7 +135542,8 @@ function storedConstructorCallSource(context, schemaClass2, value, className, en
     }
     if (firstRequiredConstructorParameterKey(
       context,
-      stringField2(schemaClass2, "id")
+      stringField2(schemaClass2, "id"),
+      environment
     ) !== null) {
       return null;
     }
@@ -135318,13 +136071,16 @@ function storedSchemaTypeName(context, type, environment, valueId) {
     }
     case "generic": {
       const memberId = environment.get(type.genericParamId);
-      const member = memberId === void 0 ? void 0 : context.manifestMembers.get(memberId);
-      if (member === void 0) {
+      if (memberId === void 0) {
         throw new Error(
           `Stored Generic constructor argument has no concrete binding for ${type.genericParamId}.`
         );
       }
-      return manifestMemberTypeName(context, member);
+      return storedSchemaTypeName(
+        context,
+        schemaTypeForBindingMember(context, memberId, environment),
+        environment
+      );
     }
     case "list":
       return `List<${storedTypeArgumentName(context, type.entryType, environment)}>`;
@@ -135359,7 +136115,12 @@ function storedSchemaTypeName(context, type, environment, valueId) {
     case "dialogueLookup":
       return "NeoDialogueReference";
     case "delegate":
-      return "object";
+      return `NeoDelegate<${[
+        type.returnType.kind === "void" ? "void" : storedTypeArgumentName(context, type.returnType, environment),
+        ...type.argumentTypes.map(
+          (argument2) => storedTypeArgumentName(context, argument2, environment)
+        )
+      ].join(", ")}>`;
     case "action":
       return "object";
     case "null":
@@ -135562,51 +136323,19 @@ function classValueTypeName(context, classId, member, environment) {
     if (inferredClassId !== null) {
       return context.manifestClasses.get(inferredClassId)?.name ?? stringField2(context.classes.get(inferredClassId) ?? {}, "name");
     }
-    const bindingMember = bindingMemberId ? context.manifestMembers.get(bindingMemberId) : void 0;
-    if (bindingMember === void 0) {
+    if (bindingMemberId === void 0) {
       throw new Error(
         `Stored Class member ${String(member.name ?? member.id)} has no concrete ${parameter4.name} binding.`
       );
     }
-    return typeArgumentName(context, bindingMember);
+    return storedTypeArgumentName(
+      context,
+      schemaTypeForBindingMember(context, bindingMemberId, environment),
+      environment
+    );
   });
   return `${name}<${argumentsValue.join(", ")}>`;
 }
-function typeArgumentName(context, member) {
-  return `${manifestMemberTypeName(context, member)}${member.required ? "" : "?"}`;
-}
-function manifestMemberTypeName(context, member) {
-  if (member.kind === "class") {
-    const schemaClass2 = context.manifestClasses.get(member.classId);
-    if (schemaClass2 === void 0) {
-      throw new Error(`Stored Class type ${member.classId} was not pulled.`);
-    }
-    if (schemaClass2.genericParameters.length === 0) return schemaClass2.name;
-    const argumentsValue = schemaClass2.genericParameters.map((parameter4) => {
-      const binding = member.classArguments[parameter4.id];
-      if (binding?.kind !== "member") {
-        throw new Error(
-          `Stored Class member ${member.name} has no concrete ${parameter4.name} binding.`
-        );
-      }
-      const argument2 = context.manifestMembers.get(binding.memberId);
-      if (argument2 === void 0) {
-        throw new Error(
-          `Stored generic binding ${binding.memberId} was not pulled.`
-        );
-      }
-      return typeArgumentName(context, argument2);
-    });
-    return `${schemaClass2.name}<${argumentsValue.join(", ")}>`;
-  }
-  if (member.kind === "generic") {
-    throw new Error(`Stored Generic member ${member.name} is not closed.`);
-  }
-  if (member.kind === "scriptFunction" || member.kind === "function") {
-    return "FunctionRef";
-  }
-  return fixedSourceTypeNameForKind(member.kind) ?? member.kind;
-}
 function constructorProjectionSource(context, classId, body, visited, environment) {
   const projections2 = effectiveConstructorProjections(
     context.manifestClasses,
@@ -136086,27 +136815,38 @@ function functionReferenceValue(context, body) {
   return target.name;
 }
 function delegateValue(context, body) {
-  if (!isObjectRecord2(body)) {
-    throw new Error("NSDelegate value is not a closure or bound target.");
-  }
-  if (typeof body.code === "string") return body.code;
-  if (typeof body.memberId !== "string") {
-    throw new Error("NSDelegate bound target is missing memberId.");
-  }
-  if (body.valueId !== null && body.valueId !== void 0) {
-    throw new Error(
-      "NSDelegate instance-bound target cannot be represented by current project source."
-    );
-  }
-  const target = context.members.get(body.memberId);
-  if (target === void 0 || typeof target.name !== "string") {
-    throw new Error(`NSDelegate target ${body.memberId} was not pulled.`);
-  }
-  const kind = numberField(target, "kind");
-  if (kind !== 10 && kind !== 23 && kind !== 25) {
-    throw new Error(`NSDelegate target ${body.memberId} is not callable.`);
-  }
-  return target.name;
+  return delegateValueSource(body, (memberId) => {
+    const target = context.members.get(memberId);
+    if (target === void 0) {
+      throw new Error(`NSDelegate target ${memberId} was not pulled.`);
+    }
+    if (typeof target.name !== "string") {
+      throw new Error(`NSDelegate target ${memberId} has no name.`);
+    }
+    const kind = numberField(target, "kind");
+    if (kind !== 10 && kind !== 23 && kind !== 25) {
+      throw new Error(`NSDelegate target ${memberId} is not callable.`);
+    }
+    if (target.modifier !== 3 /* Static */) {
+      return { name: target.name, staticClassName: null };
+    }
+    const classId = context.ownerClassIds.get(memberId);
+    if (classId === void 0) {
+      throw new Error(`Static NSDelegate target ${memberId} has no Class.`);
+    }
+    const owner = context.classes.get(classId);
+    if (owner === void 0) {
+      throw new Error(
+        `Static NSDelegate target ${memberId} Class ${classId} was not pulled.`
+      );
+    }
+    if (typeof owner.name !== "string") {
+      throw new Error(
+        `Static NSDelegate target ${memberId} Class ${classId} has no name.`
+      );
+    }
+    return { name: target.name, staticClassName: owner.name };
+  });
 }
 function actionValue(context, body) {
   if (!isObjectRecord2(body)) {
@@ -136230,19 +136970,26 @@ function localizedString(context, member, body) {
   return isObjectRecord2(main2) && typeof main2.value === "string" ? main2.value : "";
 }
 function staticSymbols(classes, members) {
-  const result = /* @__PURE__ */ new Map();
+  const symbolsByValueId = /* @__PURE__ */ new Map();
+  const staticOwnerIds = /* @__PURE__ */ new Map();
   for (const schemaClass2 of classes.values()) {
     if (typeof schemaClass2.name !== "string" || !isObjectRecord2(schemaClass2.schema))
       continue;
     for (const memberId of Object.values(schemaClass2.schema)) {
       if (typeof memberId !== "string") continue;
       const member = members.get(memberId);
-      if (member?.modifier === 3 && typeof member.name === "string" && typeof member.valueId === "string") {
-        result.set(member.valueId, `${schemaClass2.name}.${member.name}`);
+      if (member?.modifier === 3 && typeof member.name === "string" && typeof member.valueId === "string" && // A static naming another static shares its row. The member the row
+      // derives from owns it; otherwise the first keeps it.
+      (!staticOwnerIds.has(member.valueId) || member.valueId === memberValueId(memberId))) {
+        symbolsByValueId.set(
+          member.valueId,
+          `${schemaClass2.name}.${member.name}`
+        );
+        staticOwnerIds.set(member.valueId, memberId);
       }
     }
   }
-  return result;
+  return { symbolsByValueId, staticOwnerIds };
 }
 function projectFileSymbols(records3) {
   const files = [...records3.values()].flatMap((record7) => {
@@ -136378,7 +137125,7 @@ function memberDefaultBody(member) {
   if (!("value" in defaultValue)) return null;
   return defaultValue.value;
 }
-var INFERRED_GENERIC_CLASS_PREFIX, MEMBER_KIND_DICTIONARY2, MEMBER_KIND_LIST2, MEMBER_KIND_CLASS2, LEADING_AUTHORED_ROW_ID, INITIALIZER_KEY_PLACEHOLDER, MissingStoredMemberError, CANONICAL_CONSTRUCTOR_INLINE_WIDTH;
+var INFERRED_GENERIC_CLASS_PREFIX, MEMBER_KIND_DICTIONARY2, MEMBER_KIND_LIST2, MEMBER_KIND_CLASS2, LEADING_AUTHORED_ROW_ID, genericParameterNamesByClasses, INITIALIZER_KEY_PLACEHOLDER, MissingStoredMemberError, CANONICAL_CONSTRUCTOR_INLINE_WIDTH;
 var init_value_sources = __esm({
   "src/project-source/value-sources.ts"() {
     "use strict";
@@ -136435,11 +137182,13 @@ var init_value_sources = __esm({
     init_stored_value_placements();
     init_structured_leaf_source();
     init_variant_selection_source();
+    init_delegate_value_source();
     INFERRED_GENERIC_CLASS_PREFIX = "__inferred_class__:";
     MEMBER_KIND_DICTIONARY2 = 5;
     MEMBER_KIND_LIST2 = 6;
     MEMBER_KIND_CLASS2 = 7;
     LEADING_AUTHORED_ROW_ID = /^@id\(\s*"((?:[^"\\]|\\.)*)"\s*\)/;
+    genericParameterNamesByClasses = /* @__PURE__ */ new WeakMap();
     INITIALIZER_KEY_PLACEHOLDER = new RegExp(
       `${PENDING_ID_PREFIX}reference-key:init:\\d+`,
       "g"
@@ -196295,7 +197044,7 @@ There is no --keep-current: preserving current semantic state defines flatten.
 async function main() {
   const args = parseArgs(process.argv.slice(2));
   if (args.command === "--version") {
-    console.log("0.77.0");
+    console.log("0.77.1");
     return;
   }
   if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {