@neocompose/cli 0.19.5 → 0.20.0

package/dist/neo.mjs

@@ -898,6 +898,7 @@ var init_language_spec = __esm({
       "Reference",
       "Partial",
       "FunctionRef",
+      "NeoDelegate",
       "Dialogue",
       "Trigger",
       "Node",
@@ -1534,6 +1535,16 @@ function isNeoScriptTypeAssignable(source, target, project) {
   if (source.kind === "dictionary" && target.kind === "dictionary") {
     return isNeoScriptTypeAssignable(source.keyType, target.keyType, project) && isNeoScriptTypeAssignable(source.valueType, target.valueType, project);
   }
+  if (source.kind === "delegate" && target.kind === "delegate") {
+    return source.parameterTypes.length === target.parameterTypes.length && isNeoScriptTypeAssignable(
+      source.returnType,
+      target.returnType,
+      project
+    ) && source.parameterTypes.every((parameter3, index) => {
+      const expected = target.parameterTypes[index];
+      return expected !== void 0 && isNeoScriptTypeAssignable(parameter3, expected, project) && isNeoScriptTypeAssignable(expected, parameter3, project);
+    });
+  }
   return false;
 }
 function commonNeoScriptAssignableType(left, right, project) {
@@ -1588,6 +1599,13 @@ function formatType(type, project) {
       return `Dictionary<${formatType(type.keyType, project)}, ${formatType(type.valueType, project)}>${suffix}`;
     case "typeParameter":
       return `${type.name}${suffix}`;
+    case "delegate":
+      return `NeoDelegate<${[
+        formatType(type.returnType, project),
+        ...type.parameterTypes.map(
+          (parameter3) => formatType(parameter3, project)
+        )
+      ].join(", ")}>${suffix}`;
   }
 }
 var UNKNOWN_TYPE;
@@ -6476,6 +6494,8 @@ function neoScriptPositionalTypeKey(type) {
       return `dictionary:${neoScriptPositionalTypeKey(type.keyType)}:${neoScriptPositionalTypeKey(type.valueType)}`;
     case "typeParameter":
       return `typeParameter:${type.id}`;
+    case "delegate":
+      return `delegate:${neoScriptPositionalTypeKey(type.returnType)}(${type.parameterTypes.map(neoScriptPositionalTypeKey).join(",")})`;
   }
 }
 function validateNeoScriptOverloadSignatures(className, signatures) {
@@ -6575,7 +6595,7 @@ var NEOSCRIPT_COMPILER_REVISION;
 var init_strict_ir = __esm({
   "../packages/neoscript-language/src/strict-ir.ts"() {
     "use strict";
-    NEOSCRIPT_COMPILER_REVISION = 6;
+    NEOSCRIPT_COMPILER_REVISION = 7;
   }
 });
 
@@ -6731,6 +6751,12 @@ function typeRefsEqual(left, right) {
   if (left.kind === "set" && right.kind === "set") {
     return typeRefsEqual(left.elementType, right.elementType);
   }
+  if (left.kind === "delegate" && right.kind === "delegate") {
+    return typeRefsEqual(left.returnType, right.returnType) && left.parameterTypes.length === right.parameterTypes.length && left.parameterTypes.every((parameter3, index) => {
+      const other = right.parameterTypes[index];
+      return other !== void 0 && typeRefsEqual(parameter3, other);
+    });
+  }
   return left.kind === "dictionary" && right.kind === "dictionary" ? typeRefsEqual(left.keyType, right.keyType) && typeRefsEqual(left.valueType, right.valueType) : false;
 }
 function variable(id2, type, pointer, project) {
@@ -7104,6 +7130,15 @@ function toWireType(type, project) {
         ownerClassId: type.ownerClassId ?? findGenericParameterOwner(type.id, project) ?? "",
         genericParamId: type.id
       };
+    case "delegate":
+      return {
+        type: 25 /* Delegate */,
+        required: required2,
+        returnTypeInfo: type.returnType.kind === "primitive" && type.returnType.name === "void" ? { type: "Void", required: true } : toWireType(type.returnType, project),
+        argumentTypes: type.parameterTypes.map(
+          (parameter3) => toWireType(parameter3, project)
+        )
+      };
   }
 }
 function fromWireType(type) {
@@ -7150,6 +7185,14 @@ function fromWireType(type) {
       nullable
     };
   }
+  if (type.type === 25 /* Delegate */) {
+    return {
+      kind: "delegate",
+      returnType: type.returnTypeInfo.type === "Void" ? { kind: "primitive", name: "void" } : fromWireType(type.returnTypeInfo),
+      parameterTypes: type.argumentTypes.map(fromWireType),
+      nullable
+    };
+  }
   return { kind: "primitive", name: valueKindPrimitive(type.type), nullable };
 }
 function findGenericParameterOwner(parameterId, project) {
@@ -7371,6 +7414,13 @@ function substituteTypeParameters(member, receiver, declaring) {
         valueType: visit(type.valueType)
       };
     }
+    if (type.kind === "delegate") {
+      return {
+        ...type,
+        returnType: visit(type.returnType),
+        parameterTypes: type.parameterTypes.map(visit)
+      };
+    }
     return type;
   };
   return visit(member);
@@ -8882,6 +8932,17 @@ var init_strict_resolver = __esm({
         );
       }
       resolveExpression(expression, scope, expected) {
+        if (expected?.kind === "delegate") {
+          if (expression.kind === "lambda") {
+            return this.resolveDelegateLambda(expression, expected, scope);
+          }
+          const methodGroup = this.resolveDelegateMethodGroup(
+            expression,
+            expected,
+            scope
+          );
+          if (methodGroup !== null) return methodGroup;
+        }
         switch (expression.kind) {
           case "litNull":
             return literal(
@@ -9123,11 +9184,174 @@ var init_strict_resolver = __esm({
           }
           case "lambda":
             throw new CompileError(
-              "A lambda is valid only as an argument to a collection function.",
+              "A lambda requires a NeoDelegate expected type.",
               expression.pos
             );
         }
       }
+      resolveDelegateLambda(ast, expected, outerScope) {
+        if (ast.params.length !== expected.parameterTypes.length) {
+          throw new CompileError(
+            `Delegate lambda expects ${expected.parameterTypes.length} parameter${expected.parameterTypes.length === 1 ? "" : "s"}, got ${ast.params.length}.`,
+            ast.pos
+          );
+        }
+        const scope = new Scope(outerScope);
+        const parameters = ast.params.map((parameter3, index) => {
+          this.assertLocalNameAvailable(parameter3.name, scope, parameter3.pos);
+          const expectedType = requiredAt(expected.parameterTypes, index);
+          const declared = parameter3.type ? this.resolveType(parameter3.type) : expectedType;
+          if (!isNeoScriptTypeAssignable(declared, expectedType, this.project) || !isNeoScriptTypeAssignable(expectedType, declared, this.project)) {
+            throw new CompileError(
+              `Delegate lambda parameter ${index + 1} must be ${this.describe(expectedType)}, got ${this.describe(declared)}.`,
+              parameter3.pos
+            );
+          }
+          const item = variable(
+            `__arg_${index}__`,
+            declared,
+            void 0,
+            this.project
+          );
+          scope.define(
+            scopeVariable(
+              parameter3.name,
+              item,
+              declared,
+              void 0,
+              "runtime" /* Runtime */
+            )
+          );
+          return item;
+        });
+        this.functionControlBoundaries.push({
+          controlDepth: this.controlContexts.length,
+          loopFlowDepth: this.loopFlowContexts.length,
+          catchDepth: this.catchContexts.length
+        });
+        this.lambdaDepth++;
+        this.expectedReturnStack.push(expected.returnType);
+        try {
+          const instructions = this.resolveStatements(ast.body, scope);
+          const returnsVoid = isVoid(expected.returnType);
+          if (!returnsVoid && !instructionsTerminate(instructions)) {
+            throw new CompileError(
+              "Not every reachable delegate path returns a value or throws.",
+              ast.pos
+            );
+          }
+          const action = {
+            compilerRevision: NEOSCRIPT_COMPILER_REVISION,
+            parameters: [this.thisVariable, this.rootVariable, ...parameters],
+            instructions,
+            typeInfo: returnsVoid ? toWireType({ kind: "primitive", name: "null" }, this.project) : toWireType(expected.returnType, this.project)
+          };
+          return literal(expected, { action }, this.project);
+        } finally {
+          this.expectedReturnStack.pop();
+          this.lambdaDepth--;
+          this.functionControlBoundaries.pop();
+        }
+      }
+      resolveDelegateMethodGroup(expression, expected, scope) {
+        let symbol;
+        let receiver = null;
+        let owner;
+        if (expression.kind === "ident") {
+          const implicit = this.implicitMember(expression.name);
+          if (implicit === null || implicit.symbol.kind !== "function" && implicit.symbol.kind !== "method") {
+            return null;
+          }
+          symbol = implicit.symbol;
+          owner = implicit.owner;
+          receiver = symbol.static === true ? { kind: "static", memberId: symbol.id } : {
+            kind: "instance",
+            expression: this.resolveIdentifier("this", scope, expression.pos)
+          };
+        } else if (expression.kind === "member") {
+          if (expression.receiver.kind === "ident" && !scope.lookup(expression.receiver.name)) {
+            owner = this.project.typeByName.get(expression.receiver.name);
+            symbol = owner?.members.find(
+              (candidate) => candidate.name === expression.name && (candidate.kind === "function" || candidate.kind === "method")
+            );
+            if (symbol === void 0) return null;
+            if (symbol.static !== true) {
+              throw new CompileError(
+                `Member '${owner?.name}.${symbol.name}' requires an instance receiver.`,
+                expression.pos
+              );
+            }
+            receiver = { kind: "static", memberId: symbol.id };
+          } else {
+            const receiverExpression = this.resolveExpression(
+              expression.receiver,
+              scope
+            );
+            if (receiverExpression.type.kind !== "named") return null;
+            owner = this.project.typeById.get(receiverExpression.type.typeId);
+            symbol = owner?.members.find(
+              (candidate) => candidate.name === expression.name && (candidate.kind === "function" || candidate.kind === "method")
+            );
+            if (symbol === void 0) return null;
+            if (symbol.static === true) {
+              throw new CompileError(
+                `Static member '${owner?.name}.${symbol.name}' must be accessed through the type name, not an instance.`,
+                expression.pos
+              );
+            }
+            receiver = { kind: "instance", expression: receiverExpression };
+          }
+        } else {
+          return null;
+        }
+        if (owner !== void 0)
+          this.assertMemberAccessible(owner, symbol, expression.pos);
+        let returnType = symbol.returnType ?? symbol.type;
+        let parameterTypes = (symbol.parameters ?? []).map(
+          (parameter3) => parameter3.type
+        );
+        if (receiver?.kind === "instance" && receiver.expression.type.kind === "named" && owner !== void 0) {
+          const receiverType = receiver.expression.type;
+          returnType = substituteTypeParameters(returnType, receiverType, owner);
+          parameterTypes = parameterTypes.map(
+            (parameter3) => substituteTypeParameters(parameter3, receiverType, owner)
+          );
+        }
+        const expectedVoid = isVoid(expected.returnType);
+        const actualVoid = isVoid(returnType);
+        if (expectedVoid !== actualVoid || !expectedVoid && !isNeoScriptTypeAssignable(returnType, expected.returnType, this.project) || parameterTypes.length !== expected.parameterTypes.length || !parameterTypes.every((parameter3, index) => {
+          const target = expected.parameterTypes[index];
+          return target !== void 0 && isNeoScriptTypeAssignable(parameter3, target, this.project) && isNeoScriptTypeAssignable(target, parameter3, this.project);
+        })) {
+          throw new CompileError(
+            `Function '${symbol.name}' is not assignable to ${this.describe(expected)}.`,
+            expression.pos
+          );
+        }
+        const parameters = expected.parameterTypes.map(
+          (type, index) => variable(`__arg_${index}__`, type, void 0, this.project)
+        );
+        const call = {
+          type: "callFunction" /* CallFunction */,
+          memberId: symbol.id,
+          receiver: receiver?.kind === "static" ? { kind: "static", memberId: receiver.memberId } : {
+            kind: "instance",
+            pointer: receiver?.expression.pointer ?? this.thisVariable.pointer
+          },
+          args: parameters.map((parameter3) => ({
+            type: "variable" /* Variable */,
+            variableId: parameter3.id
+          })),
+          callSiteId: this.nextCallSite(expression.pos)
+        };
+        const action = {
+          compilerRevision: NEOSCRIPT_COMPILER_REVISION,
+          parameters: [this.thisVariable, this.rootVariable, ...parameters],
+          instructions: expectedVoid ? [{ type: "functionCall" /* FunctionCall */, call }] : [{ type: "return" /* Return */, pointer: call }],
+          typeInfo: expectedVoid ? toWireType({ kind: "primitive", name: "null" }, this.project) : toWireType(expected.returnType, this.project)
+        };
+        return literal(expected, { action }, this.project);
+      }
       resolveInterpolatedString(parts, scope) {
         const stringType = { kind: "primitive", name: "string" };
         const pointers = parts.map((part) => {
@@ -9949,6 +10173,16 @@ var init_strict_resolver = __esm({
         }
       }
       resolveCall(callee, argumentsList2, scope, pos) {
+        const delegate = this.resolveDelegateCallee(callee, scope);
+        if (delegate !== null) {
+          return this.resolveDelegateCall(
+            delegate,
+            argumentsList2,
+            scope,
+            pos,
+            callee.kind === "member" && callee.optional === true
+          );
+        }
         if (callee.kind === "ident") {
           const vector = vectorKind(callee.name);
           if (vector)
@@ -10146,6 +10380,71 @@ var init_strict_resolver = __esm({
           pos
         );
       }
+      resolveDelegateCallee(callee, scope) {
+        if (callee.kind === "ident") {
+          const scoped = scope.lookup(callee.name);
+          const implicit = this.implicitMember(callee.name);
+          if (scoped === null && (implicit === null || implicit.symbol.kind === "function" || implicit.symbol.kind === "method")) {
+            return null;
+          }
+          const resolved = this.resolveIdentifier(callee.name, scope, callee.pos);
+          return resolved.type.kind === "delegate" ? resolved : null;
+        }
+        if (callee.kind !== "member") return null;
+        try {
+          const resolved = this.resolveMember(
+            callee.receiver,
+            callee.name,
+            scope,
+            callee.pos,
+            callee.optional === true
+          );
+          return resolved.type.kind === "delegate" ? resolved : null;
+        } catch (error) {
+          if (error instanceof CompileError) return null;
+          throw error;
+        }
+      }
+      resolveDelegateCall(delegate, args, scope, pos, optional) {
+        if (delegate.type.kind !== "delegate") {
+          throw new Error("Delegate call received a non-delegate type.");
+        }
+        const delegateType = delegate.type;
+        if (isNullable(delegateType) && !optional) {
+          throw new CompileError(
+            `Cannot call optional ${this.describe(delegate.type)} without optional chaining or force-unwrapping it.`,
+            pos
+          );
+        }
+        requireArgCount("Delegate", args, delegateType.parameterTypes.length, pos);
+        const pointers = args.map((argument2, index) => {
+          const expected = requiredAt(delegateType.parameterTypes, index);
+          const resolved = this.resolveExpression(argument2, scope, expected);
+          this.requireAssignable(
+            resolved.type,
+            expected,
+            argument2.pos,
+            `delegate argument ${index + 1}`
+          );
+          return resolved.pointer;
+        });
+        if (isVoid(delegateType.returnType)) {
+          throw new CompileError(
+            "A void delegate cannot be used as a value; call it as a statement instead.",
+            pos
+          );
+        }
+        return {
+          pointer: {
+            type: "callDelegate" /* CallDelegate */,
+            delegate: delegate.pointer,
+            args: pointers,
+            ...optional ? { optional: true } : {},
+            callSiteId: this.nextCallSite(pos)
+          },
+          type: optional ? { ...delegateType.returnType, nullable: true } : delegateType.returnType
+        };
+      }
       resolveClassConstructor(className, argumentsList2, scope, pos) {
         const schemaClass2 = this.project.typeByName.get(className);
         if (!schemaClass2 || schemaClass2.kind !== "class") {
@@ -10917,8 +11216,42 @@ var init_strict_resolver = __esm({
         };
       }
       resolveFunctionStatement(expression, scope) {
-        if (expression.kind !== "call" || expression.callee.kind !== "member")
-          return null;
+        if (expression.kind !== "call") return null;
+        const delegate = this.resolveDelegateCallee(expression.callee, scope);
+        if (delegate?.type.kind === "delegate") {
+          const delegateType = delegate.type;
+          requireArgCount(
+            "Delegate",
+            expression.args,
+            delegateType.parameterTypes.length,
+            expression.pos
+          );
+          if (isNullable(delegateType) && !(expression.callee.kind === "member" && expression.callee.optional)) {
+            throw new CompileError(
+              `Cannot call optional ${this.describe(delegate.type)} without optional chaining or force-unwrapping it.`,
+              expression.pos
+            );
+          }
+          const args2 = expression.args.map((argument2, index) => {
+            const expected = requiredAt(delegateType.parameterTypes, index);
+            const resolved = this.resolveExpression(argument2, scope, expected);
+            this.requireAssignable(
+              resolved.type,
+              expected,
+              argument2.pos,
+              `delegate argument ${index + 1}`
+            );
+            return resolved.pointer;
+          });
+          return {
+            type: "callDelegate" /* CallDelegate */,
+            delegate: delegate.pointer,
+            args: args2,
+            ...expression.callee.kind === "member" && expression.callee.optional ? { optional: true } : {},
+            callSiteId: this.nextCallSite(expression.pos)
+          };
+        }
+        if (expression.callee.kind !== "member") return null;
         const memberName = expression.callee.name;
         if (expression.callee.receiver.kind === "ident" && !scope.lookup(expression.callee.receiver.name)) {
           const staticType = this.project.typeByName.get(
@@ -20118,6 +20451,13 @@ function substituteInheritedSourceMember(member, baseInfo, resolvedBaseType) {
         valueType: substitute2(type.valueType)
       };
     }
+    if (type.kind === "delegate") {
+      return {
+        ...type,
+        returnType: substitute2(type.returnType),
+        parameterTypes: type.parameterTypes.map(substitute2)
+      };
+    }
     return type;
   };
   return {
@@ -20188,6 +20528,15 @@ function sourceTypeRef(type, owner, typeIds) {
       ...nullable ? { nullable } : {}
     };
   }
+  if (type.name === "NeoDelegate") {
+    const returnType = type.typeArguments[0] ? sourceTypeRef(type.typeArguments[0], owner, typeIds) : { kind: "primitive", name: "unknown" };
+    return {
+      kind: "delegate",
+      returnType,
+      parameterTypes: type.typeArguments.slice(1).map((argument2) => sourceTypeRef(argument2, owner, typeIds)),
+      ...nullable ? { nullable } : {}
+    };
+  }
   if (type.name === "Reference" && type.typeArguments[0]) {
     return {
       ...sourceTypeRef(type.typeArguments[0], owner, typeIds),
@@ -20906,6 +21255,18 @@ function validateTypeApplication(uri, type, genericParameters, environment, diag
     return;
   }
   const target = environment.declarations.get(type.name);
+  if (type.name === "NeoDelegate") {
+    if (type.typeArguments.length < 1 || type.typeArguments.length > 17) {
+      diagnose(
+        diagnostics,
+        uri,
+        type.range,
+        "generic-argument-arity",
+        `Type 'NeoDelegate' expects a return type followed by up to 16 parameter types, but ${type.typeArguments.length} type arguments were provided.`
+      );
+    }
+    return;
+  }
   const expected = target?.declaration.kind === "class" ? target.declaration.genericParameters.length : BUILTIN_ARITY.get(type.name) ?? 0;
   if (!target && !BUILTIN_TYPES.has(type.name)) return;
   if (type.typeArguments.length !== expected) {
@@ -21557,9 +21918,15 @@ function memberCompatibility(implementation, implementationSubstitution, target,
     environment,
     implementationGenericParameters
   ) && isClassTypedShape(targetType, environment, implementationGenericParameters);
+  const permitsDelegateReturnCovariance = isClassOverride && implementationFamily === "value" && delegateShapeAssignable(
+    implementationType,
+    targetType,
+    environment,
+    implementationGenericParameters
+  );
   const permitsStoredOverrideNullability = isClassOverride && implementation.kind === "field" && (target.member.kind === "field" || isAbstractPropertyContract(target.member, targetAccessors));
   const comparableImplementationType = permitsStoredOverrideNullability ? { ...implementationType, nullable: targetType.nullable } : implementationType;
-  if (!typesEqual(comparableImplementationType, targetType) && !((permitsCovariantGetter || permitsClassCovariance) && isTypeAssignable(
+  if (!typesEqual(comparableImplementationType, targetType) && !(permitsDelegateReturnCovariance || (permitsCovariantGetter || permitsClassCovariance) && isTypeAssignable(
     comparableImplementationType,
     targetType,
     environment,
@@ -21600,6 +21967,28 @@ function memberCompatibility(implementation, implementationSubstitution, target,
   }
   return null;
 }
+function delegateShapeAssignable(actual, expected, environment, genericParameters) {
+  if (actual.name !== "NeoDelegate" || expected.name !== "NeoDelegate") {
+    return false;
+  }
+  if (actual.nullable !== expected.nullable) return false;
+  if (actual.arguments.length !== expected.arguments.length) return false;
+  const actualReturn = actual.arguments[0];
+  const expectedReturn = expected.arguments[0];
+  if (actualReturn === void 0 || expectedReturn === void 0) return false;
+  if (!isTypeAssignable(
+    actualReturn,
+    expectedReturn,
+    environment,
+    genericParameters
+  )) {
+    return false;
+  }
+  return actual.arguments.slice(1).every((argument2, index) => {
+    const expectedArgument = expected.arguments[index + 1];
+    return expectedArgument !== void 0 && typesEqual(argument2, expectedArgument);
+  });
+}
 function valueAccessors(member, environment) {
   if (member.kind === "field") {
     const owner = environment.memberOwners.get(member);
@@ -28009,6 +28398,12 @@ function normalizeTypeInfoBindings(value) {
     }
   }
   normalizeTypeInfoBindings(value.entryTypeInfo);
+  normalizeTypeInfoBindings(value.returnTypeInfo);
+  if (Array.isArray(value.argumentTypes)) {
+    for (const argument2 of value.argumentTypes) {
+      normalizeTypeInfoBindings(argument2);
+    }
+  }
 }
 function stripCompiledInitializer(value) {
   if (!isRecord(value)) return;
@@ -28573,6 +28968,22 @@ function memberFromDocument(record3, members, owners, classNames, context) {
   if (kind === MEMBER_KIND.FunctionRef) {
     return { ...common, kind: "functionRef" };
   }
+  if (kind === MEMBER_KIND.NSDelegate) {
+    return {
+      ...common,
+      kind: "delegate",
+      returnType: documentReturnTypeToManifest(
+        field("returnTypeInfo", void 0),
+        record3,
+        "returnTypeInfo"
+      ),
+      arguments: documentArgumentsToManifest(
+        field("argumentTypes", []),
+        record3,
+        source.span
+      )
+    };
+  }
   if (kind === MEMBER_KIND.Generic) {
     return {
       ...common,
@@ -28711,6 +29122,13 @@ function memberToDocumentFields(member, baseData3) {
       if (member.uiAction !== void 0) fields.uiAction = member.uiAction;
     }
   }
+  if (member.kind === "delegate") {
+    fields.returnTypeInfo = manifestReturnTypeToDocument(member.returnType);
+    fields.argumentTypes = member.arguments.map((argument2) => ({
+      name: argument2.name,
+      ...manifestTypeToDocument(argument2.type)
+    }));
+  }
   if (member.kind === "generic") {
     fields.genericParamId = member.genericParamId;
     if (member.partial) fields.partial = true;
@@ -28908,6 +29326,24 @@ function documentTypeToManifest(value, record3, path) {
       collectionValueId: optionalStringOrNull(typeInfo.collectionValueId)
     };
   }
+  if (kind === MEMBER_KIND.NSDelegate) {
+    return {
+      kind: "delegate",
+      nullable,
+      returnType: documentReturnTypeToManifest(
+        typeInfo.returnTypeInfo,
+        record3,
+        `${path}.returnTypeInfo`
+      ),
+      argumentTypes: optionalArray(typeInfo.argumentTypes).map(
+        (argument2, index) => documentTypeToManifest(
+          argument2,
+          record3,
+          `${path}.argumentTypes.${index}`
+        )
+      )
+    };
+  }
   throw invalidDocument(
     record3,
     path,
@@ -28971,6 +29407,14 @@ function manifestTypeToDocument(type) {
       readOnly: type.readOnly || void 0
     });
   }
+  if (type.kind === "delegate") {
+    return {
+      type: MEMBER_KIND.NSDelegate,
+      required: required2,
+      returnTypeInfo: manifestReturnTypeToDocument(type.returnType),
+      argumentTypes: type.argumentTypes.map(manifestTypeToDocument)
+    };
+  }
   if (type.kind !== "lookup") {
     throw new Error(`No document type-info mapping for ${type.kind}.`);
   }
@@ -29362,7 +29806,8 @@ var init_codecs = __esm({
       Generic: 21,
       Interface: 22,
       NSFunction: 23,
-      FunctionRef: 24
+      FunctionRef: 24,
+      NSDelegate: 25
     };
     TYPE_KIND_BY_MEMBER_KIND = /* @__PURE__ */ new Map([
       [MEMBER_KIND.Null, "null"],
@@ -29413,7 +29858,8 @@ var init_codecs = __esm({
       ["decimal", MEMBER_KIND.Decimal],
       ["generic", MEMBER_KIND.Generic],
       ["scriptFunction", MEMBER_KIND.NSFunction],
-      ["functionRef", MEMBER_KIND.FunctionRef]
+      ["functionRef", MEMBER_KIND.FunctionRef],
+      ["delegate", MEMBER_KIND.NSDelegate]
     ]);
     TYPE_MEMBER_KIND_BY_KIND = /* @__PURE__ */ new Map([
       ["null", MEMBER_KIND.Null],
@@ -31428,10 +31874,18 @@ function assertMember2(value, path) {
   assertMemberOwner(member.owner, `${path}.owner`);
   assertOptionalDocsText2(member.docsText, `${path}.docsText`);
   const owner = requireRecord(member.owner, `${path}.owner`);
-  if (member.docsText !== void 0 && owner.kind !== "classMember" && owner.kind !== "sharedClassMember") {
+  if (member.docsText !== void 0 && owner.kind !== "classMember" && owner.kind !== "sharedClassMember" && // A loose member is not a kind of member — it is a member no class schema
+  // in *this* view claims. A workspace merging its own pending records over
+  // newer server ones sees exactly that: the local class still names the
+  // pending member id the push replaced, so the committed member it now
+  // holds is claimed by nothing. Doc text belongs to the member record, not
+  // to where a schema happens to place it, so rejecting it here fails a pull
+  // for a workspace whose only problem is being mid-sync — the one operation
+  // that would fix it.
+  owner.kind !== "loose") {
     invalid(
       `${path}.docsText`,
-      "is allowed only on source-declarable class members."
+      `is allowed only on source-declarable class members; ${JSON.stringify(String(member.name))} is owned by ${JSON.stringify(String(owner.kind))}.`
     );
   }
   nonEmptyString(member.name, `${path}.name`);
@@ -31601,6 +32055,14 @@ function assertMember2(value, path) {
     assertAbstractScriptInvariant(member, path);
     return;
   }
+  if (kind === "delegate") {
+    assertReturnType(member.returnType, `${path}.returnType`);
+    arrayOf(member.arguments, `${path}.arguments`, assertFunctionArgument);
+    if (Array.isArray(member.arguments) && member.arguments.length > 16) {
+      invalid(`${path}.arguments`, "delegate arity cannot exceed 16.");
+    }
+    return;
+  }
   if (kind === "generic") {
     nonEmptyString(member.genericParamId, `${path}.genericParamId`);
     if (member.partial !== void 0) {
@@ -31909,6 +32371,20 @@ function assertType2(value, path, depth = 0) {
     nullableNonEmptyString(type.collectionValueId, `${path}.collectionValueId`);
     return;
   }
+  if (kind === "delegate") {
+    knownKeys(type, path, ["kind", "nullable", "returnType", "argumentTypes"]);
+    booleanAt(type.nullable, `${path}.nullable`);
+    assertReturnType(type.returnType, `${path}.returnType`);
+    arrayOf(
+      type.argumentTypes,
+      `${path}.argumentTypes`,
+      (entry, entryPath) => assertType2(entry, entryPath, depth + 1)
+    );
+    if (Array.isArray(type.argumentTypes) && type.argumentTypes.length > 16) {
+      invalid(`${path}.argumentTypes`, "delegate arity cannot exceed 16.");
+    }
+    return;
+  }
   invalid(`${path}.kind`, `unsupported schema type ${JSON.stringify(kind)}.`);
 }
 function assertInterface(value, path) {
@@ -32810,7 +33286,8 @@ var init_validate = __esm({
       function: ["returnType", "arguments", "deferred"],
       scriptFunction: ["returnType", "arguments", "deferred", "script"],
       generic: ["genericParamId"],
-      functionRef: []
+      functionRef: [],
+      delegate: ["returnType", "arguments"]
     };
     PRIMITIVE_TYPE_KINDS = /* @__PURE__ */ new Set([
       "null",
@@ -35875,6 +36352,27 @@ function isNSTypeInfoGenericParam(value) {
   if (typeof v.genericParamId !== "string") return false;
   return v.genericParamId.length > 0;
 }
+function isNSTypeInfoDelegateInternal(value, ancestors) {
+  if (!isNSTypeInfoBase(value) || value.type !== 25 /* NSDelegate */) {
+    return false;
+  }
+  const delegate = value;
+  if (ancestors.has(delegate)) return false;
+  ancestors.add(delegate);
+  try {
+    if (!isNSTypeInfoVoid(delegate.returnTypeInfo) && !isNSTypeInfoInternal(delegate.returnTypeInfo, ancestors)) {
+      return false;
+    }
+    if (!Array.isArray(delegate.argumentTypes) || delegate.argumentTypes.length > 16) {
+      return false;
+    }
+    return delegate.argumentTypes.every(
+      (argument2) => isNSTypeInfoInternal(argument2, ancestors)
+    );
+  } finally {
+    ancestors.delete(delegate);
+  }
+}
 function isNSTypeInfoCollection(value) {
   return isNSTypeInfoCollectionInternal(value, /* @__PURE__ */ new Set());
 }
@@ -35931,7 +36429,7 @@ function isNSTypeInfo(value) {
   return isNSTypeInfoInternal(value, /* @__PURE__ */ new Set());
 }
 function isNSTypeInfoInternal(value, ancestors) {
-  return isNSTypeInfoUnknown(value) || isNSTypeInfoPrimitive(value) || isNSTypeInfoAsset(value) || isNSTypeInfoVector(value) || isNSTypeInfoColor(value) || isNSTypeInfoDialogueLookup(value) || isNSTypeInfoClassInternal(value, ancestors) || isNSTypeInfoInterface(value) || isNSTypeInfoGenericParam(value) || isNSTypeInfoCollectionInternal(value, ancestors) || isNSTypeInfoLookupInternal(value, ancestors) || isNSTypeInfoEnum(value);
+  return isNSTypeInfoUnknown(value) || isNSTypeInfoPrimitive(value) || isNSTypeInfoAsset(value) || isNSTypeInfoVector(value) || isNSTypeInfoColor(value) || isNSTypeInfoDialogueLookup(value) || isNSTypeInfoClassInternal(value, ancestors) || isNSTypeInfoInterface(value) || isNSTypeInfoGenericParam(value) || isNSTypeInfoDelegateInternal(value, ancestors) || isNSTypeInfoCollectionInternal(value, ancestors) || isNSTypeInfoLookupInternal(value, ancestors) || isNSTypeInfoEnum(value);
 }
 function isNSArgumentTypeInfo(value) {
   return isRequiredType(value, isNSArgumentTypeInfoUnsafe);
@@ -35953,6 +36451,11 @@ function typeInfoContainsUnknown(value, ancestors) {
     if (value.type === 6 /* List */ || value.type === 5 /* Dictionary */ || value.type === 9 /* Lookup */) {
       return typeInfoContainsUnknown(value.entryTypeInfo, ancestors);
     }
+    if (value.type === 25 /* NSDelegate */) {
+      return value.returnTypeInfo.type !== NS_TYPE_VOID && typeInfoContainsUnknown(value.returnTypeInfo, ancestors) || value.argumentTypes.some(
+        (argument2) => typeInfoContainsUnknown(argument2, ancestors)
+      );
+    }
     if (value.type !== 7 /* Class */) return false;
     return Object.values(value.typeArguments ?? {}).some(
       (argument2) => typeInfoContainsUnknown(argument2, ancestors)
@@ -36087,6 +36590,16 @@ function isNSPointerCallFunction(value) {
   }
   return true;
 }
+function isNSPointerCallDelegate(value) {
+  const v = value;
+  if (v?.type !== "callDelegate" /* callDelegate */) return false;
+  if (!isNSPointer(v.delegate)) return false;
+  if (!Array.isArray(v.args) || !v.args.every(isNSPointer)) return false;
+  if (typeof v.callSiteId !== "string" || v.callSiteId.length === 0) {
+    return false;
+  }
+  return v.optional === void 0 || typeof v.optional === "boolean";
+}
 function isNSCallReceiver(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
     return false;
@@ -36105,7 +36618,7 @@ function isNSPointerFunctionErrorCheck(value) {
   return isNSFunctionErrorCheckMode(v.mode);
 }
 function isNSPointer(value) {
-  return isNSPointerReference(value) || isNSPointerVariable(value) || isNSPointerValue(value) || isNSPointerOperation(value) || isNSPointerFunction(value) || isNSPointerKeyOf(value) || isNSPointerListLiteral(value) || isNSPointerDictLiteral(value) || isNSPointerForceUnwrap(value) || isNSPointerIsCheck(value) || isNSPointerCallGetter(value) || isNSPointerCoalesce(value) || isNSPointerToBool(value) || isNSPointerStringify(value) || isNSPointerCallFunction(value) || isNSPointerFunctionErrorCheck(value);
+  return isNSPointerReference(value) || isNSPointerVariable(value) || isNSPointerValue(value) || isNSPointerOperation(value) || isNSPointerFunction(value) || isNSPointerKeyOf(value) || isNSPointerListLiteral(value) || isNSPointerDictLiteral(value) || isNSPointerForceUnwrap(value) || isNSPointerIsCheck(value) || isNSPointerCallGetter(value) || isNSPointerCoalesce(value) || isNSPointerToBool(value) || isNSPointerStringify(value) || isNSPointerCallFunction(value) || isNSPointerCallDelegate(value) || isNSPointerFunctionErrorCheck(value);
 }
 function isNSPointers(value) {
   return Array.isArray(value) && value.every(isNSPointer);
@@ -36443,7 +36956,7 @@ function isNSInstructionCollectionCall(value) {
 function isNSInstructionFunctionCall(value) {
   const v = value;
   if (v?.type !== "functionCall" /* functionCall */) return false;
-  return isNSPointerCallFunction(v.call);
+  return isNSPointerCallFunction(v.call) || isNSPointerCallDelegate(v.call);
 }
 function isNSLoopBinding(value) {
   const binding = value;
@@ -36975,6 +37488,7 @@ var init_member_kind_enum = __esm({
       MemberKind13[MemberKind13["Interface"] = 22] = "Interface";
       MemberKind13[MemberKind13["NSFunction"] = 23] = "NSFunction";
       MemberKind13[MemberKind13["FunctionRef"] = 24] = "FunctionRef";
+      MemberKind13[MemberKind13["NSDelegate"] = 25] = "NSDelegate";
       return MemberKind13;
     })(MemberKind || {});
   }
@@ -37546,6 +38060,61 @@ function isMemberNSFunction(value) {
   if (typeof v.code !== "string" || v.code.length === 0) return false;
   return hasValidNSFunctionAction(v, base.returnTypeInfo, base.argumentTypes);
 }
+function isMemberDelegateTarget(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const record3 = value;
+  if (!hasExactKeys(record3, ["memberId", "valueId"])) return false;
+  return typeof record3.memberId === "string" && record3.memberId.length > 0 && (record3.valueId === null || typeof record3.valueId === "string" && record3.valueId.length > 0);
+}
+function isNSDelegateClosureValueDraft(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const record3 = value;
+  return hasExactKeys(record3, ["code"]) && typeof record3.code === "string" && record3.code.length > 0;
+}
+function isNSDelegateClosureValue(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const record3 = value;
+  const keys = record3.code === void 0 ? ["action"] : ["code", "action"];
+  if (!hasExactKeys(record3, keys)) return false;
+  if (record3.code !== void 0 && (typeof record3.code !== "string" || record3.code.length === 0)) {
+    return false;
+  }
+  return isNSFunctionWithReturnType(record3.action);
+}
+function isNSDelegateValue(value) {
+  return isMemberDelegateTarget(value) || isNSDelegateClosureValueDraft(value) || isNSDelegateClosureValue(value);
+}
+function nsDelegateDirectReferenceValueId(value) {
+  if (!isNSDelegateClosureValue(value)) return null;
+  const instructions = value.action.instructions;
+  if (instructions.length !== 1) return null;
+  const instruction = instructions[0];
+  if (instruction?.type !== "return" /* return */ || instruction.pointer?.type !== "reference" /* reference */) {
+    return null;
+  }
+  return instruction.pointer.valueId;
+}
+function isMemberDelegateBase(value) {
+  const v = asMemberBaseForKind(value, 25 /* NSDelegate */);
+  if (v === null) return false;
+  if (!isNSFunctionReturnTypeInfo(v.returnTypeInfo)) return false;
+  if (!Array.isArray(v.argumentTypes) || v.argumentTypes.length > 16) {
+    return false;
+  }
+  const names = /* @__PURE__ */ new Set();
+  for (const argument2 of v.argumentTypes) {
+    if (!isNSFunctionArgumentTypeInfo(argument2)) return false;
+    if (!isValidCallableIdentifier(argument2.name)) return false;
+    if (argument2.type === NS_TYPE_UNKNOWN) return false;
+    if (names.has(argument2.name)) return false;
+    names.add(argument2.name);
+  }
+  const defaultValue = v.defaultValue;
+  if (defaultValue === void 0 || defaultValue === null) return true;
+  if (!isMemberValueBase(defaultValue)) return false;
+  if (isInitValueContent(defaultValue)) return true;
+  return isNSDelegateValue(defaultValue.value);
+}
 function isFunctionRefValue(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return false;
   const record3 = value;
@@ -37608,7 +38177,7 @@ function isMemberBase(value) {
   if (partial !== void 0 && v?.kind !== 7 /* Class */ && v?.kind !== 21 /* Generic */) {
     return false;
   }
-  const matchesConcreteType = isMemberNullBase(value) || isMemberBoolBase(value) || isMemberIntBase(value) || isMemberStringBase(value) || isMemberFloatBase(value) || isMemberDictionaryBase(value) || isMemberListBase(value) || isMemberClassBase(value) || isMemberEnumBase(value) || isMemberLookupBase(value) || isMemberDialogueLookupBase(value) || isMemberNSPropertyBase(value) || isMemberNSPropertyContractBase(value) || isMemberSpriteBase(value) || isMemberAudioBase(value) || isMemberFunctionBase(value) || isMemberNSFunctionBase(value) || isMemberNSFunction(value) || isMemberFunctionRefBase(value) || isMemberVector2Base(value) || isMemberVector2IntBase(value) || isMemberVector3Base(value) || isMemberVector3IntBase(value) || isMemberColorBase(value) || isMemberDecimalBase(value) || isMemberGenericBase(value);
+  const matchesConcreteType = isMemberNullBase(value) || isMemberBoolBase(value) || isMemberIntBase(value) || isMemberStringBase(value) || isMemberFloatBase(value) || isMemberDictionaryBase(value) || isMemberListBase(value) || isMemberClassBase(value) || isMemberEnumBase(value) || isMemberLookupBase(value) || isMemberDialogueLookupBase(value) || isMemberNSPropertyBase(value) || isMemberNSPropertyContractBase(value) || isMemberSpriteBase(value) || isMemberAudioBase(value) || isMemberFunctionBase(value) || isMemberNSFunctionBase(value) || isMemberNSFunction(value) || isMemberDelegateBase(value) || isMemberFunctionRefBase(value) || isMemberVector2Base(value) || isMemberVector2IntBase(value) || isMemberVector3Base(value) || isMemberVector3IntBase(value) || isMemberColorBase(value) || isMemberDecimalBase(value) || isMemberGenericBase(value);
   if (!matchesConcreteType) return false;
   if (!isValidDocsText(v?.docsText)) return false;
   if (typeof v?.name !== "string") return false;
@@ -38069,7 +38638,7 @@ var init_inheritance = __esm({
 });
 
 // ../src/models/classes/world-system-classes.generated.ts
-var WORLD_GRID_CHILDREN_MEMBER_ID, WORLD_GRID_CHILDREN_ENTRY_MEMBER_ID, WORLD_OBJECT_CHILDREN_MEMBER_ID, WORLD_OBJECT_CHILDREN_ENTRY_MEMBER_ID, WORLD_OBJECT_PLACEMENT_TILES_MEMBER_ID, WORLD_OBJECT_PLACEMENT_TILES_ENTRY_MEMBER_ID, WORLD_OBJECT_PLACEMENT_TILE_CELL_MEMBER_ID, WORLD_TILE_INSTANCE_CELL_MEMBER_ID, WORLD_TILE_LAYER_LINK_TILES_MEMBER_ID, WORLD_TILE_LAYER_LINK_TILE_ENTRY_MEMBER_ID, WORLD_OBJECT_LAYER_LINK_OBJECTS_MEMBER_ID, WORLD_OBJECT_LAYER_LINK_OBJECT_ENTRY_MEMBER_ID, WORLD_ANIMATION_CLIP_TARGET_PARAM_ID, WORLD_ANIMATION_CHILD_OVERRIDE_ENTRY_PARAM_ID, WORLD_ANIMATION_CLIP_FPS_MEMBER_ID, WORLD_ANIMATION_CLIP_DURATION_MEMBER_ID, WORLD_ANIMATION_CLIP_FRAMES_MEMBER_ID, WORLD_ANIMATION_CLIP_TRACKS_MEMBER_ID, WORLD_ANIMATION_FRAME_BASE_INDEX_MEMBER_ID, WORLD_ANIMATION_FRAME_OVERRIDES_MEMBER_ID, WORLD_ANIMATION_FRAME_CHILD_OVERRIDES_MEMBER_ID, WORLD_ANIMATION_FRAME_CHILD_OVERRIDES_ENTRY_MEMBER_ID, WORLD_ANIMATION_FRAME_ACTIONS_MEMBER_ID, WORLD_ANIMATION_CHILD_OVERRIDE_CHILD_MEMBER_ID, WORLD_ANIMATION_CHILD_OVERRIDE_OVERRIDES_MEMBER_ID, WORLD_ANIMATION_TRACK_CHILD_MEMBER_ID, WORLD_ANIMATION_TRACK_START_FRAME_MEMBER_ID, WORLD_ANIMATION_TRACK_DIRECTION_MEMBER_ID, WORLD_ANIMATION_TRACK_OFFSET_START_INDEX_MEMBER_ID, WORLD_ANIMATION_TRACK_OFFSET_END_INDEX_MEMBER_ID, WORLD_ANIMATION_CHILD_TRACK_CLIP_KEY_MEMBER_ID, WORLD_ANIMATION_SEGMENT_DURATION_MEMBER_ID, WORLD_ANIMATION_SEGMENT_FRAMES_MEMBER_ID, WORLD_ANIMATION_SEGMENT_TRACK_CHILD_PARAM_ID, WORLD_ANIMATION_SEGMENT_TRACK_VALUE_PARAM_ID, WORLD_PLAY_DIRECTION_FORWARD_OPTION_ID, WORLD_PLAY_DIRECTION_REVERSE_OPTION_ID, WORLD_SYSTEM_CLASS_DEFINITIONS;
+var WORLD_GRID_CHILDREN_MEMBER_ID, WORLD_GRID_CHILDREN_ENTRY_MEMBER_ID, WORLD_OBJECT_CHILDREN_MEMBER_ID, WORLD_OBJECT_CHILDREN_ENTRY_MEMBER_ID, WORLD_OBJECT_PLACEMENT_TILES_MEMBER_ID, WORLD_OBJECT_PLACEMENT_TILES_ENTRY_MEMBER_ID, WORLD_OBJECT_PLACEMENT_TILE_CELL_MEMBER_ID, WORLD_TILE_INSTANCE_CELL_MEMBER_ID, WORLD_TILE_LAYER_LINK_TILES_MEMBER_ID, WORLD_TILE_LAYER_LINK_TILE_ENTRY_MEMBER_ID, WORLD_OBJECT_LAYER_LINK_OBJECTS_MEMBER_ID, WORLD_OBJECT_LAYER_LINK_OBJECT_ENTRY_MEMBER_ID, WORLD_ANIMATION_CLIP_TARGET_PARAM_ID, WORLD_ANIMATION_CHILD_OVERRIDE_ENTRY_PARAM_ID, WORLD_ANIMATION_CLIP_FPS_MEMBER_ID, WORLD_ANIMATION_CLIP_DURATION_MEMBER_ID, WORLD_ANIMATION_CLIP_FRAMES_MEMBER_ID, WORLD_ANIMATION_CLIP_TRACKS_MEMBER_ID, WORLD_ANIMATION_FRAME_BASE_INDEX_MEMBER_ID, WORLD_ANIMATION_FRAME_OVERRIDES_MEMBER_ID, WORLD_ANIMATION_FRAME_CHILD_OVERRIDES_MEMBER_ID, WORLD_ANIMATION_FRAME_CHILD_OVERRIDES_ENTRY_MEMBER_ID, WORLD_ANIMATION_FRAME_ACTIONS_MEMBER_ID, WORLD_ANIMATION_CHILD_OVERRIDE_SELECTOR_MEMBER_ID, WORLD_ANIMATION_CHILD_OVERRIDE_REFRESH_MEMBER_ID, WORLD_ANIMATION_CHILD_OVERRIDE_OVERRIDES_MEMBER_ID, WORLD_ANIMATION_TRACK_SELECTOR_MEMBER_ID, WORLD_ANIMATION_TRACK_REFRESH_MEMBER_ID, WORLD_ANIMATION_TRACK_START_FRAME_MEMBER_ID, WORLD_ANIMATION_TRACK_DIRECTION_MEMBER_ID, WORLD_ANIMATION_TRACK_OFFSET_START_INDEX_MEMBER_ID, WORLD_ANIMATION_TRACK_OFFSET_END_INDEX_MEMBER_ID, WORLD_ANIMATION_CHILD_TRACK_CLIP_KEY_MEMBER_ID, WORLD_ANIMATION_SEGMENT_DURATION_MEMBER_ID, WORLD_ANIMATION_SEGMENT_FRAMES_MEMBER_ID, WORLD_ANIMATION_SEGMENT_TRACK_CHILD_PARAM_ID, WORLD_ANIMATION_SEGMENT_TRACK_VALUE_PARAM_ID, WORLD_SELECTOR_REFRESH_ON_LOAD_OPTION_ID, WORLD_SELECTOR_REFRESH_PER_FRAME_OPTION_ID, WORLD_PLAY_DIRECTION_FORWARD_OPTION_ID, WORLD_PLAY_DIRECTION_REVERSE_OPTION_ID, WORLD_SYSTEM_CLASS_DEFINITIONS;
 var init_world_system_classes_generated = __esm({
   "../src/models/classes/world-system-classes.generated.ts"() {
     "use strict";
@@ -38096,9 +38665,11 @@ var init_world_system_classes_generated = __esm({
     WORLD_ANIMATION_FRAME_CHILD_OVERRIDES_MEMBER_ID = "system_a5905750-c472-46a8-89e9-f04f0bf66696";
     WORLD_ANIMATION_FRAME_CHILD_OVERRIDES_ENTRY_MEMBER_ID = "system_86688965-6b26-529e-95f3-a4070f022582";
     WORLD_ANIMATION_FRAME_ACTIONS_MEMBER_ID = "system_23e05410-6428-4bd1-b085-c0390ed7fcb7";
-    WORLD_ANIMATION_CHILD_OVERRIDE_CHILD_MEMBER_ID = "system_6e15db41-a6f2-43fd-9793-c52fe4f3d0f8";
+    WORLD_ANIMATION_CHILD_OVERRIDE_SELECTOR_MEMBER_ID = "system_48e66117-43fe-4429-97a8-964165f063ea";
+    WORLD_ANIMATION_CHILD_OVERRIDE_REFRESH_MEMBER_ID = "system_ba319c4b-3419-4301-a0d6-8bc5a89e20d1";
     WORLD_ANIMATION_CHILD_OVERRIDE_OVERRIDES_MEMBER_ID = "system_819b3743-0c3d-4896-b679-9aeeb73255f4";
-    WORLD_ANIMATION_TRACK_CHILD_MEMBER_ID = "system_29abc85e-2d38-4cef-a200-88915d176d06";
+    WORLD_ANIMATION_TRACK_SELECTOR_MEMBER_ID = "system_1e877396-1802-474a-9e4d-1df478d4c888";
+    WORLD_ANIMATION_TRACK_REFRESH_MEMBER_ID = "system_330602f7-bbc0-4be4-9dc3-d33e9dbdbab9";
     WORLD_ANIMATION_TRACK_START_FRAME_MEMBER_ID = "system_5af60692-74a0-45ea-a9ba-747854989b2a";
     WORLD_ANIMATION_TRACK_DIRECTION_MEMBER_ID = "system_75a314b5-c799-4af6-9e64-4cde6eae1b30";
     WORLD_ANIMATION_TRACK_OFFSET_START_INDEX_MEMBER_ID = "system_c71caaab-df72-48c6-a291-2772288351eb";
@@ -38108,6 +38679,8 @@ var init_world_system_classes_generated = __esm({
     WORLD_ANIMATION_SEGMENT_FRAMES_MEMBER_ID = "system_40658ad2-b4a5-4404-bb6d-ed778088a772";
     WORLD_ANIMATION_SEGMENT_TRACK_CHILD_PARAM_ID = "system_d4fe9f71-d9d9-4baf-bc52-8de16933b655";
     WORLD_ANIMATION_SEGMENT_TRACK_VALUE_PARAM_ID = "system_03497842-3381-45a2-b2fa-b2dee36c2759";
+    WORLD_SELECTOR_REFRESH_ON_LOAD_OPTION_ID = "system_88c5d17a-b73e-47a1-a96e-4ebe16e6d200";
+    WORLD_SELECTOR_REFRESH_PER_FRAME_OPTION_ID = "system_dc350ac4-de4b-4d1c-9b46-097dc5b4180f";
     WORLD_PLAY_DIRECTION_FORWARD_OPTION_ID = "system_2e4ca40e-f305-49c6-a91b-b99d56239ba0";
     WORLD_PLAY_DIRECTION_REVERSE_OPTION_ID = "system_6478d195-3905-48db-befe-d276eb5478f0";
     WORLD_SYSTEM_CLASS_DEFINITIONS = [
@@ -38944,8 +39517,12 @@ var init_world_system_classes_generated = __esm({
         isAbstract: false,
         constructorProjections: [
           {
-            memberId: "system_6e15db41-a6f2-43fd-9793-c52fe4f3d0f8",
-            parameterName: "id"
+            memberId: "system_48e66117-43fe-4429-97a8-964165f063ea",
+            parameterName: "selector"
+          },
+          {
+            memberId: "system_819b3743-0c3d-4896-b679-9aeeb73255f4",
+            parameterName: "overrides"
           }
         ],
         genericParams: [
@@ -38957,13 +39534,26 @@ var init_world_system_classes_generated = __esm({
         ],
         schemaFields: [
           {
-            memberId: "system_6e15db41-a6f2-43fd-9793-c52fe4f3d0f8",
-            memberKind: "lookup",
-            collectionMemberId: "system_bb5d2cf1-a0dd-4eba-a62e-0e1bf0177071",
-            collectionValueId: null,
+            memberId: "system_48e66117-43fe-4429-97a8-964165f063ea",
+            memberKind: "delegate",
+            returnTypeInfo: {
+              type: 21,
+              required: true,
+              ownerClassId: "system_e2e88eba-5335-4a16-9dcf-2c0e1951e8bd",
+              genericParamId: "system_de23448a-45be-4e3f-8965-072a545e08f0"
+            },
+            argumentTypes: [],
+            required: true,
+            schemaKey: "Selector"
+          },
+          {
+            memberId: "system_ba319c4b-3419-4301-a0d6-8bc5a89e20d1",
+            memberKind: "enum",
+            defaultValue: ["system_88c5d17a-b73e-47a1-a96e-4ebe16e6d200"],
+            enumId: "system_fb8a4243-fa52-4142-8097-765d9e86ff25",
             multiselect: false,
             required: true,
-            schemaKey: "Child"
+            schemaKey: "Refresh"
           },
           {
             memberId: "system_819b3743-0c3d-4896-b679-9aeeb73255f4",
@@ -38981,15 +39571,33 @@ var init_world_system_classes_generated = __esm({
         name: "NeoAnimationTrackBase",
         docsText: "A lane on a clip's timeline: which child it plays against, when it starts,\nwhich way it runs, and which slice of the content to use. Both kinds of\ntrack derive from this, so playing a child clip reversed or cropped is\nsomething you author on the lane rather than pass in when you play it.",
         isAbstract: true,
+        constructorProjections: [
+          {
+            memberId: "system_1e877396-1802-474a-9e4d-1df478d4c888",
+            parameterName: "selector"
+          }
+        ],
         schemaFields: [
           {
-            memberId: "system_29abc85e-2d38-4cef-a200-88915d176d06",
-            memberKind: "lookup",
-            collectionMemberId: "system_bb5d2cf1-a0dd-4eba-a62e-0e1bf0177071",
-            collectionValueId: null,
+            memberId: "system_1e877396-1802-474a-9e4d-1df478d4c888",
+            memberKind: "delegate",
+            returnTypeInfo: {
+              type: 7,
+              required: true,
+              classId: "system_61b30a92-90dc-4bf8-8503-ee4f6414effc"
+            },
+            argumentTypes: [],
+            required: true,
+            schemaKey: "Selector"
+          },
+          {
+            memberId: "system_330602f7-bbc0-4be4-9dc3-d33e9dbdbab9",
+            memberKind: "enum",
+            defaultValue: ["system_88c5d17a-b73e-47a1-a96e-4ebe16e6d200"],
+            enumId: "system_fb8a4243-fa52-4142-8097-765d9e86ff25",
             multiselect: false,
             required: true,
-            schemaKey: "Child"
+            schemaKey: "Refresh"
           },
           {
             memberId: "system_5af60692-74a0-45ea-a9ba-747854989b2a",
@@ -39048,8 +39656,12 @@ var init_world_system_classes_generated = __esm({
         isAbstract: false,
         constructorProjections: [
           {
-            memberId: "system_29abc85e-2d38-4cef-a200-88915d176d06",
-            parameterName: "id"
+            memberId: "system_1e877396-1802-474a-9e4d-1df478d4c888",
+            parameterName: "selector"
+          },
+          {
+            memberId: "system_2c816624-0281-46d3-9ed5-d20bd43519f4",
+            parameterName: "clipKey"
           }
         ],
         schemaFields: [
@@ -39071,8 +39683,8 @@ var init_world_system_classes_generated = __esm({
         isAbstract: true,
         constructorProjections: [
           {
-            memberId: "system_87900a74-0d7c-4dfc-a6f6-3bd204ebb8f6",
-            parameterName: "id"
+            memberId: "system_b29e7ab9-0b8e-4399-84c1-1203070b75dd",
+            parameterName: "selector"
           }
         ],
         genericParams: [
@@ -39085,21 +39697,19 @@ var init_world_system_classes_generated = __esm({
         ],
         schemaFields: [
           {
-            memberId: "system_87900a74-0d7c-4dfc-a6f6-3bd204ebb8f6",
-            memberKind: "lookup",
-            extendsMemberId: "system_29abc85e-2d38-4cef-a200-88915d176d06",
+            memberId: "system_b29e7ab9-0b8e-4399-84c1-1203070b75dd",
+            memberKind: "delegate",
+            extendsMemberId: "system_1e877396-1802-474a-9e4d-1df478d4c888",
             docsText: "The child this lane plays against, typed as the child class you derived with, so a Segment getter can read that child's own members.",
-            collectionMemberId: "system_bb5d2cf1-a0dd-4eba-a62e-0e1bf0177071",
-            collectionValueId: null,
-            multiselect: false,
-            declaredTypeInfo: {
+            returnTypeInfo: {
               type: 21,
               required: true,
               ownerClassId: "system_fd551dd8-6e6b-4044-9f32-7445ab344200",
               genericParamId: "system_d4fe9f71-d9d9-4baf-bc52-8de16933b655"
             },
+            argumentTypes: [],
             required: true,
-            schemaKey: "Child"
+            schemaKey: "Selector"
           },
           {
             memberId: "system_d2d0bf9b-211f-4b2f-bff3-3d6da5766abd",
@@ -39748,6 +40358,7 @@ var init_generics = __esm({
       13 /* Function */,
       23 /* NSFunction */,
       24 /* FunctionRef */,
+      25 /* NSDelegate */,
       21 /* Generic */
     ]);
   }
@@ -41950,6 +42561,13 @@ function primitiveFallbackValue(document, member) {
   if (isMemberAudioBase(member)) {
     return { value: pendingAudioValue() };
   }
+  if (member.kind === 25 /* NSDelegate */) {
+    return {
+      value: {
+        code: '() => { throw "Not implemented exception"; }'
+      }
+    };
+  }
   if (member.kind === 21 /* Generic */) {
     throw new Error(
       `Unreachable: Generic member "${member.name}" must be substituted through its binding environment before default value construction \u2014 a substitution site was skipped upstream (https://github.com/ryanbliss/neo-compose-specs/tree/main/new-features/complete/class-generics.md \xA74.1).`
@@ -43532,6 +44150,23 @@ function lowerFieldMember(context, ownerClass, declaration, id2, commonInput, ba
     }
     return { ...common, kind: "functionRef" };
   }
+  if (name === "NeoDelegate") {
+    if (partial) {
+      throw new Error("Partial<T> requires a Class or Class generic target.");
+    }
+    const returnType = requiredTypeArgument(fieldType, 0);
+    return {
+      ...common,
+      kind: "delegate",
+      returnType: returnType.name === "void" ? { kind: "void", nullable: false } : lowerType(context, returnType, ownerClass),
+      arguments: fieldType.arguments.slice(1).map((argumentType, index) => ({
+        name: `p${index + 1}`,
+        type: lowerType(context, argumentType, ownerClass),
+        source: span(declaration),
+        selectionSpan: span(declaration)
+      }))
+    };
+  }
   if (name === "bool" || name === "null") {
     return { ...common, kind: name };
   }
@@ -44103,6 +44738,18 @@ function lowerType(context, type, ownerClass) {
       readOnly: false
     };
   }
+  if (type.name === "Partial") {
+    return lowerType(context, requiredTypeArgument(type, 0), ownerClass);
+  }
+  if (type.name === "NeoDelegate") {
+    const returnType = requiredTypeArgument(type, 0);
+    return {
+      kind: "delegate",
+      nullable,
+      returnType: returnType.name === "void" ? { kind: "void", nullable: false } : lowerType(context, returnType, ownerClass),
+      argumentTypes: type.arguments.slice(1).map((argument2) => lowerType(context, argument2, ownerClass))
+    };
+  }
   const classId = context.classIdsByName.get(type.name);
   if (classId) {
     const parameters = context.genericParametersByClass.get(classId);
@@ -44146,7 +44793,7 @@ function lowerDefault(context, initializer, type, ownerClass, base, memberId, st
     return base?.defaultValue && "serverValueId" in base.defaultValue ? base.defaultValue : null;
   }
   const expression = parseExpression(initializer);
-  if (initializerRequiresEvaluation(
+  if (!isStoredDelegateLiteral(type, expression) && initializerRequiresEvaluation(
     context.declaredConstructors,
     expression,
     type.name,
@@ -44160,7 +44807,15 @@ function lowerDefault(context, initializer, type, ownerClass, base, memberId, st
   if (context.rowBackedDefaultMemberIds.has(memberId) && base?.defaultValue && !("serverValueId" in base.defaultValue)) {
     return base.defaultValue;
   }
-  let value = lowerExpressionValue(context, expression, type, ownerClass, path);
+  let value = lowerExpressionValue(
+    context,
+    expression,
+    type,
+    ownerClass,
+    path,
+    EMPTY_GENERIC_TYPE_ENVIRONMENT,
+    initializer
+  );
   if (value !== null && storesSelectionArray && !Array.isArray(value)) {
     value = [value];
   }
@@ -44207,12 +44862,12 @@ function manifestTypeFromAstType(type) {
     arguments: (type.typeArguments ?? []).map(manifestTypeFromAstType)
   };
 }
-function lowerExpressionValue(context, expression, declaredExpected, ownerClass, path, genericEnvironment = EMPTY_GENERIC_TYPE_ENVIRONMENT) {
+function lowerExpressionValue(context, expression, declaredExpected, ownerClass, path, genericEnvironment = EMPTY_GENERIC_TYPE_ENVIRONMENT, sourceText) {
   const expected = substituteGenericTypeNames(
     declaredExpected,
     genericEnvironment
   );
-  if (initializerRequiresEvaluation(
+  if (!isStoredDelegateLiteral(expected, expression) && initializerRequiresEvaluation(
     context.declaredConstructors,
     expression,
     expected.name,
@@ -44230,7 +44885,8 @@ function lowerExpressionValue(context, expression, declaredExpected, ownerClass,
       expected,
       ownerClass,
       path,
-      genericEnvironment
+      genericEnvironment,
+      sourceText
     );
   }
   switch (expression.kind) {
@@ -44255,7 +44911,8 @@ function lowerExpressionValue(context, expression, declaredExpected, ownerClass,
         expected,
         ownerClass,
         path,
-        genericEnvironment
+        genericEnvironment,
+        sourceText
       );
       if (typeof operand === "number") return -operand;
       if (expected.name === "decimal" && typeof operand === "string") {
@@ -44285,7 +44942,8 @@ function lowerExpressionValue(context, expression, declaredExpected, ownerClass,
           entry,
           ownerClass,
           `${path}[${index}]`,
-          genericEnvironment
+          genericEnvironment,
+          sourceText
         )
       );
     }
@@ -44299,7 +44957,8 @@ function lowerExpressionValue(context, expression, declaredExpected, ownerClass,
           { name: "string", nullable: false, arguments: [] },
           ownerClass,
           path,
-          genericEnvironment
+          genericEnvironment,
+          sourceText
         );
         if (typeof key !== "string")
           throw new Error("Dictionary keys must be strings.");
@@ -44309,7 +44968,8 @@ function lowerExpressionValue(context, expression, declaredExpected, ownerClass,
           valueType,
           ownerClass,
           `${path}[${JSON.stringify(key)}]`,
-          genericEnvironment
+          genericEnvironment,
+          sourceText
         );
       }
       return value;
@@ -44378,11 +45038,24 @@ function lowerExpressionValue(context, expression, declaredExpected, ownerClass,
           structuredLeafAssignmentType(partialExpected, declaredType),
           ownerClass,
           `${path}.${assignment.name}`,
-          innerEnvironment
+          innerEnvironment,
+          sourceText
         );
       }
       return result;
     }
+    case "lambda": {
+      if (expected.name !== "NeoDelegate") {
+        throw new Error(
+          `A lambda at ${path} requires a NeoDelegate expected type.`
+        );
+      }
+      const code = sourceText === void 0 ? null : lambdaExpressionSource(sourceText, expression.pos);
+      if (code === null || code.length === 0) {
+        throw new Error(`Delegate value ${path} has no recoverable source.`);
+      }
+      return { code: normalizeInitializerSource(code) };
+    }
     case "call": {
       if (expression.callee.kind === "ident" && expression.callee.name === "Reference") {
         const index = expression.argumentNames?.findIndex((name) => name === "id") ?? -1;
@@ -44452,6 +45125,56 @@ function lowerExpressionValue(context, expression, declaredExpected, ownerClass,
       );
   }
 }
+function isStoredDelegateLiteral(type, expression) {
+  if (type.name !== "NeoDelegate") return false;
+  let current = expression;
+  while (current.kind === "annotated") current = current.expression;
+  return current.kind === "lambda";
+}
+function lambdaExpressionSource(source, pos) {
+  let start = 0;
+  for (let line = 1; line < pos.line; line += 1) {
+    const next = source.indexOf("\n", start);
+    if (next < 0) return null;
+    start = next + 1;
+  }
+  start = Math.min(start + pos.column - 1, source.length);
+  const arrow = source.indexOf("=>", start);
+  if (arrow < 0) return null;
+  const bodyStart = source.indexOf("{", arrow + 2);
+  if (bodyStart < 0) return null;
+  let depth = 0;
+  let quote6 = null;
+  let escaped = false;
+  for (let index = bodyStart; index < source.length; index += 1) {
+    const character = source[index];
+    if (quote6 !== null) {
+      if (escaped) escaped = false;
+      else if (character === "\\") escaped = true;
+      else if (character === quote6) quote6 = null;
+      continue;
+    }
+    if (character === '"' || character === "'") {
+      quote6 = character;
+      continue;
+    }
+    if (character === "/" && source[index + 1] === "/") {
+      const newline = source.indexOf("\n", index + 2);
+      index = newline < 0 ? source.length : newline;
+      continue;
+    }
+    if (character === "/" && source[index + 1] === "*") {
+      const close = source.indexOf("*/", index + 2);
+      index = close < 0 ? source.length : close + 1;
+      continue;
+    }
+    if (character === "{") depth += 1;
+    if (character !== "}") continue;
+    depth -= 1;
+    if (depth === 0) return source.slice(start, index + 1).trim();
+  }
+  return null;
+}
 function lowerStructuredLeafDefault(context, kind, expression, expectedType, ownerClass, partialExpected, path) {
   const label = `${structuredLeafLabel(kind, path)} default`;
   const partial = structuredLeafPartialLiteral(expression);
@@ -44578,6 +45301,18 @@ function manifestTypeForMember(context, member) {
   if (member.kind === "functionRef") {
     return { name: "FunctionRef", nullable, arguments: [] };
   }
+  if (member.kind === "delegate") {
+    return {
+      name: "NeoDelegate",
+      nullable,
+      arguments: [
+        member.returnType.kind === "void" ? { name: "void", nullable: false, arguments: [] } : manifestTypeForSchemaType(context, member.returnType),
+        ...member.arguments.map(
+          (argument2) => manifestTypeForSchemaType(context, argument2.type)
+        )
+      ]
+    };
+  }
   if (member.kind === "enum") {
     return {
       name: context.baseEnums.get(member.enumId)?.name ?? "object",
@@ -44587,6 +45322,99 @@ function manifestTypeForMember(context, member) {
   }
   return { name: "object", nullable, arguments: [] };
 }
+function manifestTypeForSchemaType(context, type) {
+  const nullable = type.nullable;
+  switch (type.kind) {
+    case "unknown":
+      return { name: "object", nullable, arguments: [] };
+    case "null":
+    case "bool":
+    case "int":
+    case "string":
+    case "float":
+    case "decimal":
+      return { name: type.kind, nullable, arguments: [] };
+    case "sprite":
+      return { name: "SpriteInfo", nullable, arguments: [] };
+    case "audio":
+      return { name: "AudioClipInfo", nullable, arguments: [] };
+    case "vector2":
+      return { name: "Vector2", nullable, arguments: [] };
+    case "vector2Int":
+      return { name: "Vector2Int", nullable, arguments: [] };
+    case "vector3":
+      return { name: "Vector3", nullable, arguments: [] };
+    case "vector3Int":
+      return { name: "Vector3Int", nullable, arguments: [] };
+    case "dialogueLookup":
+      return { name: "Dialogue", nullable, arguments: [] };
+    case "color":
+      return { name: "Color", nullable, arguments: [] };
+    case "class": {
+      const schemaClass2 = context.baseClasses.get(type.classId);
+      return {
+        name: schemaClass2?.name ?? "object",
+        nullable,
+        arguments: schemaClass2?.genericParameters.map((parameter3) => type.classArguments[parameter3.id]).filter(
+          (argument2) => argument2 !== void 0
+        ).map((argument2) => manifestTypeForSchemaType(context, argument2)) ?? []
+      };
+    }
+    case "interface":
+      return {
+        name: context.baseInterfaces.get(type.interfaceId)?.name ?? "object",
+        nullable,
+        arguments: []
+      };
+    case "generic":
+      return {
+        name: genericParameterName(context, type.genericParamId),
+        nullable,
+        arguments: []
+      };
+    case "enum":
+      return {
+        name: context.baseEnums.get(type.enumId)?.name ?? "object",
+        nullable,
+        arguments: []
+      };
+    case "list":
+      return {
+        name: "List",
+        nullable,
+        arguments: [manifestTypeForSchemaType(context, type.entryType)]
+      };
+    case "dictionary":
+      return {
+        name: "Dictionary",
+        nullable,
+        arguments: [
+          type.keyEnumId === null ? { name: "string", nullable: false, arguments: [] } : {
+            name: context.baseEnums.get(type.keyEnumId)?.name ?? "object",
+            nullable: false,
+            arguments: []
+          },
+          manifestTypeForSchemaType(context, type.entryType)
+        ]
+      };
+    case "lookup":
+      return manifestTypeForSchemaType(context, {
+        ...type.entryType,
+        nullable
+      });
+    case "delegate":
+      return {
+        name: "NeoDelegate",
+        nullable,
+        arguments: [
+          type.returnType.kind === "void" ? { name: "void", nullable: false, arguments: [] } : manifestTypeForSchemaType(context, type.returnType),
+          ...type.argumentTypes.map(
+            (argument2) => manifestTypeForSchemaType(context, argument2)
+          )
+        ]
+      };
+  }
+}
 function genericParameterName(context, genericParamId) {
   for (const parameters of context.genericParametersByClass.values()) {
     for (const [name, id2] of parameters) {
@@ -46458,6 +47286,14 @@ function renderMemberType(context, member, enclosingClassId) {
     case "functionRef":
       value = "FunctionRef";
       break;
+    case "delegate":
+      value = `NeoDelegate<${[
+        renderReturnType(context, member.returnType),
+        ...member.arguments.map(
+          (argument2) => renderType(context, argument2.type)
+        )
+      ].join(", ")}>`;
+      break;
   }
   if ((member.kind === "class" || member.kind === "generic") && member.partial === true) {
     value = `Partial<${value}>`;
@@ -46545,6 +47381,12 @@ function renderType(context, type) {
     case "lookup":
       value = renderType(context, type.entryType);
       break;
+    case "delegate":
+      value = `NeoDelegate<${[
+        renderReturnType(context, type.returnType),
+        ...type.argumentTypes.map((argument2) => renderType(context, argument2))
+      ].join(", ")}>`;
+      break;
   }
   return type.nullable && value !== "null" ? `${value}?` : value;
 }
@@ -52238,6 +53080,16 @@ function objectInitializerSlices(authoredSlice) {
   }
   return assignments;
 }
+function constructorArgumentValueSlices(authoredSlice) {
+  const expression = initializerExpressionSlice(authoredSlice);
+  if (expression === void 0) return [];
+  return topLevelEntrySlices(expression, "(", ")").map((entry) => {
+    const separator = entry.indexOf(":");
+    return normalizeInitializerSource(
+      separator < 0 ? entry : entry.slice(separator + 1)
+    );
+  });
+}
 function initializerExpressionSlice(authoredSlice) {
   if (authoredSlice === void 0) return void 0;
   let text = normalizeInitializerSource(authoredSlice);
@@ -52327,7 +53179,8 @@ function lowerRowBackedDefault(context, member, backed, baseData3, binding) {
       baseBody,
       body,
       binding,
-      environment
+      environment,
+      binding.initializer
     );
     for (const assignment of expression.initializer ?? []) {
       const childMember = classMemberByName(context, classId, assignment.name);
@@ -52601,7 +53454,7 @@ function lowerSeedRow(context, member, sourceExpression, source, valueId, path,
     member,
     inheritedEnvironment
   );
-  if (initializerRequiresEvaluation(
+  if (resolvedMember.kind !== "delegate" && initializerRequiresEvaluation(
     context.declaredConstructors,
     expression,
     memberClassName(context, resolvedMember),
@@ -52675,10 +53528,12 @@ function lowerSeedRow(context, member, sourceExpression, source, valueId, path,
       path
     );
     const body = {};
+    const argumentSlices = constructorArgumentValueSlices(authoredSlice);
     for (const {
       projectedMember,
       schemaKey,
-      target
+      argument: argument2,
+      argumentIndex
     } of resolveConstructorProjectionArguments(
       context,
       effectiveClass,
@@ -52692,18 +53547,39 @@ function lowerSeedRow(context, member, sourceExpression, source, valueId, path,
       if (rows.has(childValueId)) {
         throw new Error(`Value construction reuses identity ${childValueId}.`);
       }
-      const projectionStamp = materializedRowStamp(
+      if (projectedMember.kind === "lookup") {
+        if (argument2.kind !== "litString") {
+          throw new Error(
+            `Class value ${path}.${schemaKey} requires a value-row id string literal.`
+          );
+        }
+        const projectionStamp = materializedRowStamp(
+          context,
+          materializedChild(context, materialization, schemaKey)
+        );
+        rows.set(childValueId, {
+          id: childValueId,
+          memberId: projectedMember.id,
+          value: [argument2.value],
+          classId: null,
+          ...projectionStamp === null ? {} : { sourceValueId: projectionStamp }
+        });
+        body[schemaKey] = childValueId;
+        continue;
+      }
+      body[schemaKey] = lowerSeedChild(
         context,
-        materializedChild(context, materialization, schemaKey)
+        projectedMember,
+        argument2,
+        source,
+        childPath,
+        rows,
+        localizedTexts,
+        void 0,
+        environment,
+        materializedChild(context, materialization, schemaKey),
+        argumentSlices[argumentIndex]
       );
-      rows.set(childValueId, {
-        id: childValueId,
-        memberId: projectedMember.id,
-        value: [target.id],
-        classId: null,
-        ...projectionStamp === null ? {} : { sourceValueId: projectionStamp }
-      });
-      body[schemaKey] = childValueId;
     }
     for (const assignment of expression.initializer ?? []) {
       const childMember = classMemberByName(
@@ -52828,7 +53704,8 @@ function lowerSeedRow(context, member, sourceExpression, source, valueId, path,
       expression,
       { id: valueId, value: null },
       source,
-      inheritedEnvironment
+      inheritedEnvironment,
+      authoredSlice
     );
     value = lowered.value;
     classId = typeof lowered.classId === "string" ? lowered.classId : null;
@@ -52985,7 +53862,7 @@ function lowerValueRow(context, member, sourceExpression, expectedValueId, sourc
     member,
     environment
   );
-  if (initializerRequiresEvaluation(
+  if (resolvedMember.kind !== "delegate" && initializerRequiresEvaluation(
     context.declaredConstructors,
     expression,
     memberClassName(context, resolvedMember),
@@ -53075,6 +53952,16 @@ function lowerValueBody(context, member, expression, base, source, environment,
         ...next,
         value: lowerFunctionReference(context, expression, source.ownerClassId)
       };
+    case "delegate":
+      return {
+        ...next,
+        value: lowerDelegateValue(
+          context,
+          expression,
+          source.ownerClassId,
+          authoredSlice
+        )
+      };
     case "class":
       return lowerClassValue(
         context,
@@ -53156,7 +54043,8 @@ function lowerClassValue(context, member, expression, base, source, outerEnviron
     baseBody,
     body,
     source,
-    environment
+    environment,
+    authoredSlice
   );
   for (const assignment of expression.initializer ?? []) {
     const childMember = classMemberByName(context, classId, assignment.name);
@@ -53216,7 +54104,7 @@ function lowerClassValue(context, member, expression, base, source, outerEnviron
     ...classId === currentClassId ? {} : { classId }
   };
 }
-function lowerConstructorProjections(context, schemaClass2, expression, base, baseBody, body, source, environment) {
+function lowerConstructorProjections(context, schemaClass2, expression, base, baseBody, body, source, environment, authoredSlice) {
   const resolved = resolveConstructorProjectionArguments(
     context,
     schemaClass2,
@@ -53225,20 +54113,44 @@ function lowerConstructorProjections(context, schemaClass2, expression, base, ba
     environment,
     source
   );
-  for (const { schemaKey, target } of resolved) {
+  const argumentSlices = constructorArgumentValueSlices(authoredSlice);
+  for (const {
+    schemaKey,
+    projectedMember,
+    argument: argument2,
+    argumentIndex
+  } of resolved) {
     const childValueId = baseBody[schemaKey];
     if (typeof childValueId !== "string") {
       throw new Error(
         `Class value ${String(base.id)}.${schemaKey} has no existing structural row.`
       );
     }
-    const projectedBase = valueBase(context, childValueId);
-    addReconstructed(
+    if (projectedMember.kind === "lookup") {
+      if (argument2.kind !== "litString") {
+        throw new Error(
+          `Class value ${String(base.id)}.${schemaKey} requires a value-row id string literal.`
+        );
+      }
+      const projectedBase = valueBase(context, childValueId);
+      addReconstructed(
+        context,
+        "value",
+        childValueId,
+        { ...valueFileFields(projectedBase), value: [argument2.value] },
+        source.source
+      );
+      body[schemaKey] = childValueId;
+      continue;
+    }
+    lowerValueRow(
       context,
-      "value",
+      projectedMember,
+      argument2,
       childValueId,
-      { ...valueFileFields(projectedBase), value: [target.id] },
-      source.source
+      source,
+      environment,
+      argumentSlices[argumentIndex]
     );
     body[schemaKey] = childValueId;
   }
@@ -53342,14 +54254,6 @@ function resolveConstructorProjectionArguments(context, schemaClass2, expression
       });
       continue;
     }
-    if (argument2.kind !== "litString") {
-      context.loweringFailures.push({
-        message: `Constructor '${signature}' parameter '${parameterName}' projects a row identity, so its argument must be a value-row id string literal.`,
-        code: "non-literal-constructor-argument",
-        site: referenceSite(source, argument2)
-      });
-      continue;
-    }
     const schemaKey = inheritedProjectionSchemaKey(
       context.classes,
       schemaClass2.id,
@@ -53364,29 +54268,40 @@ function resolveConstructorProjectionArguments(context, schemaClass2, expression
       continue;
     }
     const projectedMember = context.members.get(projection.memberId);
-    if (projectedMember?.kind !== "lookup") {
+    if (projectedMember === void 0) {
       context.loweringFailures.push({
-        message: `Constructor '${signature}' parameter '${parameterName}' projects member ${projection.memberId}, which is ${projectedMember === void 0 ? "in no member of this project" : `a ${projectedMember.kind} member`} and not the Lookup field a projection writes.`,
+        message: `Constructor '${signature}' parameter '${parameterName}' projects member ${projection.memberId}, which is not present in this project.`,
         code: "unprojectable-constructor-argument",
         site: referenceSite(source, argument2)
       });
       continue;
     }
-    context.referenceObligations.push({
-      kind: "constructorProjection",
-      site: referenceSite(source, argument2),
-      schemaClassId: schemaClass2.id,
-      parameterName,
-      projectedMemberId: projectedMember.id,
-      targetId: argument2.value,
-      ownerValueId,
-      environment
-    });
+    if (projectedMember.kind === "lookup") {
+      if (argument2.kind !== "litString") {
+        context.loweringFailures.push({
+          message: `Constructor '${signature}' parameter '${parameterName}' projects a row identity, so its argument must be a value-row id string literal.`,
+          code: "non-literal-constructor-argument",
+          site: referenceSite(source, argument2)
+        });
+        continue;
+      }
+      context.referenceObligations.push({
+        kind: "constructorProjection",
+        site: referenceSite(source, argument2),
+        schemaClassId: schemaClass2.id,
+        parameterName,
+        projectedMemberId: projectedMember.id,
+        targetId: argument2.value,
+        ownerValueId,
+        environment
+      });
+    }
     resolved.push({
       parameterName,
       projectedMember,
       schemaKey,
-      target: { id: argument2.value, kind: "value" }
+      argument: argument2,
+      argumentIndex: index
     });
   }
   return resolved;
@@ -53439,13 +54354,24 @@ function inferAnimationChildOverrideLowerEnvironment(context, schemaClass2, expr
   );
   const argument2 = argumentIndex === void 0 || argumentIndex < 0 ? void 0 : expression.args[argumentIndex];
   const target = argument2?.kind === "litString" ? valueData(context, argument2.value) : null;
-  const targetClassId = target && typeof target.classId === "string" ? target.classId : null;
+  const targetClassId = target && typeof target.classId === "string" ? target.classId : selectorReferenceReturnClassId(context, argument2);
   if (targetClassId === null) return inherited;
   return new Map(inherited).set(
     parameter3.id,
     inferredGenericClassBinding(targetClassId)
   );
 }
+function selectorReferenceReturnClassId(context, expression) {
+  if (expression?.kind !== "lambda") return null;
+  const returned = expression.body.find(
+    (statement) => statement.kind === "return" && statement.expr !== null
+  )?.expr;
+  if (returned?.kind !== "call" || returned.callee.kind !== "ident" || returned.callee.name !== "Reference" || returned.typeArguments?.length !== 1) {
+    return null;
+  }
+  const className = astTypeNameV4(returned.typeArguments[0]);
+  return className === null ? null : context.classesByName.get(className)?.id ?? null;
+}
 function animationChildOverrideSeedBindings(context, schemaClass2, environment, source, path) {
   if (schemaClass2.system?.worldKind !== "animationChildOverride") {
     return void 0;
@@ -54653,6 +55579,36 @@ function lowerFunctionReference(context, expression, ownerClassId) {
   }
   return { functionMemberId: target.id };
 }
+function lowerDelegateValue(context, expression, ownerClassId, authoredSlice) {
+  if (expression.kind === "lambda") {
+    const code = initializerExpressionSlice(authoredSlice);
+    if (code === void 0) {
+      throw new Error(
+        "Delegate lambdas require recoverable authored source so the server can compile their closure."
+      );
+    }
+    return { code };
+  }
+  const path = memberPath(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."
+    );
+  }
+  if (ownerClassId === void 0) {
+    throw new Error(
+      `Delegate ${symbol} cannot be resolved without its owning Class.`
+    );
+  }
+  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.`
+    );
+  }
+  return { memberId: target.id, valueId: null };
+}
 function fileTargetId(context, expression, registry) {
   const path = memberPath(expression);
   if (path !== null) {
@@ -54832,6 +55788,7 @@ function emitValueBody(context, member, value, visited, targetTyped, environment
   if (kind === 9) return referenceValue(context, member, body, false);
   if (kind === 18) return referenceValue(context, member, body, true);
   if (kind === 24) return functionReferenceValue(context, body);
+  if (kind === 25) return delegateValue(context, body);
   if (kind === 12) {
     return fileValue(
       context,
@@ -54874,7 +55831,8 @@ function classValue(context, member, value, visited, targetTyped, outerEnvironme
     context,
     classId,
     value.value,
-    visited
+    visited,
+    storedEnvironment
   );
   const environment = inferAnimationChildOverrideEmitEnvironment(
     context,
@@ -54975,7 +55933,7 @@ function manifestMemberTypeName(context, member) {
   }
   return fixedSourceTypeNameForKind(member.kind) ?? member.kind;
 }
-function constructorProjectionSource(context, classId, body, visited) {
+function constructorProjectionSource(context, classId, body, visited, environment) {
   const projections = inheritedConstructorProjections(
     context.manifestClasses,
     classId
@@ -54991,18 +55949,42 @@ function constructorProjectionSource(context, classId, body, visited) {
     );
     const childValueId = schemaKey === null ? void 0 : body[schemaKey];
     const childValue = typeof childValueId === "string" ? context.values.get(childValueId) : void 0;
-    const targetIds = Array.isArray(childValue?.value) ? childValue.value.filter(
-      (entry) => typeof entry === "string"
-    ) : [];
-    if (schemaKey === null || typeof childValueId !== "string" || targetIds.length !== 1) {
+    const projectedMember = context.members.get(projection.memberId);
+    if (schemaKey === null || typeof childValueId !== "string" || childValue === void 0 || projectedMember === void 0) {
       throw new Error(
-        `Class ${context.manifestClasses.get(classId)?.name ?? classId} constructor projection ${projection.parameterName} requires exactly one referenced value.`
+        `Class ${context.manifestClasses.get(classId)?.name ?? classId} constructor projection ${projection.parameterName} has no stored projected value.`
       );
     }
-    visited.add(childValueId);
     memberIds.add(projection.memberId);
-    targetValueIds.push(targetIds[0]);
-    argumentsValue.push(`${projection.parameterName}: ${quote4(targetIds[0])}`);
+    if (numberField(projectedMember, "kind") === 9) {
+      const targetIds = Array.isArray(childValue.value) ? childValue.value.filter(
+        (entry) => typeof entry === "string"
+      ) : [];
+      if (targetIds.length !== 1) {
+        throw new Error(
+          `Class ${context.manifestClasses.get(classId)?.name ?? classId} constructor projection ${projection.parameterName} requires exactly one referenced value.`
+        );
+      }
+      visited.add(childValueId);
+      targetValueIds.push(targetIds[0]);
+      argumentsValue.push(
+        `${projection.parameterName}: ${quote4(targetIds[0])}`
+      );
+      continue;
+    }
+    argumentsValue.push(
+      `${projection.parameterName}: ${emitValue(
+        context,
+        projectedMember,
+        childValueId,
+        {
+          definitionSite: true,
+          writeIdentity: false,
+          environment,
+          visited
+        }
+      )}`
+    );
   }
   return { arguments: argumentsValue, memberIds, targetValueIds };
 }
@@ -55317,6 +56299,29 @@ 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;
+}
 function fileValue(context, kind, label, body) {
   if (body === null || body === void 0) return "null";
   if (!isObjectRecord2(body)) {
@@ -58318,7 +59323,8 @@ var init_animation_clips = __esm({
             frameNode,
             frameClassId,
             childIds: authoredChildren.ids,
-            childStoragePath: authoredChildren.storagePath
+            childStoragePath: authoredChildren.storagePath,
+            selectorOwnerNode: targetDefinition
           });
           this.validateActions({
             clipName: clipMember.name,
@@ -58334,6 +59340,7 @@ var init_animation_clips = __esm({
           clipClassId: clipMember.classId,
           childIds: authoredChildren.ids,
           childStoragePath: authoredChildren.storagePath,
+          selectorOwnerNode: targetDefinition,
           duration
         });
       }
@@ -58347,12 +59354,16 @@ var init_animation_clips = __esm({
         const seenChildren = /* @__PURE__ */ new Set();
         for (const row of rows) {
           const rowClassId = this.requireNodeClassId(row, "animationChildOverride");
-          const childId = this.requireSingleLookupField(
+          const selected2 = this.resolveSelector(
             row,
             rowClassId,
-            WORLD_ANIMATION_CHILD_OVERRIDE_CHILD_MEMBER_ID,
+            WORLD_ANIMATION_CHILD_OVERRIDE_SELECTOR_MEMBER_ID,
+            WORLD_ANIMATION_CHILD_OVERRIDE_REFRESH_MEMBER_ID,
+            args.selectorOwnerNode,
             `Animation clip "${args.clipName}" frame ${args.frameIndex} child override`
           );
+          if (selected2 === null) continue;
+          const { childId, childClassId, childNode: child } = selected2;
           if (!args.childIds.has(childId)) {
             throw new Error(
               `Animation clip "${args.clipName}" frame ${args.frameIndex} references child "${childId}" outside the owner's authored Children graph.`
@@ -58364,13 +59375,6 @@ var init_animation_clips = __esm({
             );
           }
           seenChildren.add(childId);
-          const child = this.valueById.get(childId);
-          const childClassId = child === void 0 ? null : this.rowClassId(child);
-          if (child === void 0 || childClassId === null) {
-            throw new Error(
-              `Animation clip "${args.clipName}" frame ${args.frameIndex} references missing class-backed child "${childId}".`
-            );
-          }
           const bindingMemberId = row.genericBindings?.[WORLD_ANIMATION_CHILD_OVERRIDE_ENTRY_PARAM_ID];
           const bindingMember = typeof bindingMemberId === "string" ? this.memberById.get(bindingMemberId) : void 0;
           const bindingClassId = isMemberClass(bindingMember) ? bindingMember.classId : null;
@@ -58467,10 +59471,12 @@ var init_animation_clips = __esm({
             track,
             trackClassId: row.classId,
             childIds: args.childIds,
+            selectorOwnerNode: args.selectorOwnerNode,
             duration: args.duration,
             label
           });
           if (row.kind === "childClip") {
+            if (child === null) continue;
             this.validateChildClipTrack({
               track,
               trackClassId: row.classId,
@@ -58483,8 +59489,6 @@ var init_animation_clips = __esm({
           }
           this.validateSegmentTrack({
             trackClassId: row.classId,
-            childClassId: child.childClassId,
-            childId: child.childId,
             childStoragePath: args.childStoragePath,
             label
           });
@@ -58525,22 +59529,17 @@ var init_animation_clips = __esm({
        * segment's length is instance data this document does not have.
        */
       validateTrackBase(args) {
-        const childId = this.requireSingleLookupField(
+        const selected2 = this.resolveSelector(
           args.track,
           args.trackClassId,
-          WORLD_ANIMATION_TRACK_CHILD_MEMBER_ID,
+          WORLD_ANIMATION_TRACK_SELECTOR_MEMBER_ID,
+          WORLD_ANIMATION_TRACK_REFRESH_MEMBER_ID,
+          args.selectorOwnerNode,
           args.label
         );
-        if (!args.childIds.has(childId)) {
+        if (selected2 !== null && !args.childIds.has(selected2.childId)) {
           throw new Error(
-            `${args.label} references child "${childId}" outside the owner's authored Children graph.`
-          );
-        }
-        const childNode = this.valueById.get(childId);
-        const childClassId = childNode === void 0 ? null : this.rowClassId(childNode);
-        if (childNode === void 0 || childClassId === null) {
-          throw new Error(
-            `${args.label} references missing class-backed child "${childId}".`
+            `${args.label} references child "${selected2.childId}" outside the owner's authored Children graph.`
           );
         }
         const startFrame = this.requireIntegerField(
@@ -58559,7 +59558,36 @@ var init_animation_clips = __esm({
         }
         this.validateTrackDirection(args.track, args.trackClassId, args.label);
         this.validateTrackCropWindow(args.track, args.trackClassId, args.label);
-        return { childId, childClassId, childNode };
+        return selected2;
+      }
+      resolveSelector(parent, classId, selectorMemberId, refreshMemberId, _selectorOwnerNode, label) {
+        this.validateSelectorRefresh(parent, classId, refreshMemberId, label);
+        const selector = this.scalarField(parent, classId, selectorMemberId);
+        if (!isNSDelegateValue(selector)) {
+          throw new Error(`${label} must carry a valid NeoDelegate selector.`);
+        }
+        const directReferenceId = nsDelegateDirectReferenceValueId(selector);
+        if (directReferenceId === null) return null;
+        const childNode = this.valueById.get(directReferenceId);
+        if (childNode === void 0) {
+          throw new Error(`${label} selector did not resolve a stored child row.`);
+        }
+        const childClassId = this.rowClassId(childNode);
+        if (childClassId === null) {
+          throw new Error(
+            `${label} selector resolved child "${childNode.id}" without a class.`
+          );
+        }
+        return { childId: childNode.id, childClassId, childNode };
+      }
+      validateSelectorRefresh(parent, classId, memberId, label) {
+        const value = this.scalarField(parent, classId, memberId);
+        if (value === void 0 || value === null) return;
+        if (!Array.isArray(value) || value.length !== 1 || value[0] !== WORLD_SELECTOR_REFRESH_ON_LOAD_OPTION_ID && value[0] !== WORLD_SELECTOR_REFRESH_PER_FRAME_OPTION_ID) {
+          throw new Error(
+            `${label} Refresh must be exactly one NeoSelectorRefreshKind option.`
+          );
+        }
       }
       validateTrackDirection(track, trackClassId, label) {
         const authored = this.scalarField(
@@ -58684,13 +59712,6 @@ var init_animation_clips = __esm({
             `${args.label} class "${trackClassName}" does not bind its TChild generic to a Class member.`
           );
         }
-        if (!this.classDescendsFrom(args.childClassId, boundChildClassId)) {
-          const boundName = this.classById.get(boundChildClassId)?.name ?? boundChildClassId;
-          const childName = this.classById.get(args.childClassId)?.name ?? args.childClassId;
-          throw new Error(
-            `${args.label} plays against child "${args.childId}" of class "${childName}", which does not descend from the track's bound TChild "${boundName}".`
-          );
-        }
         const targetEntry = mergeStoredInstanceSchema(
           boundChildClassId,
           this.document.classes,
@@ -60117,7 +61138,7 @@ function computeWorkspaceStatus(workspace, options = {}) {
       parseErrors,
       parseWarnings,
       reconstructed: /* @__PURE__ */ new Map(),
-      staticValueSeeds: /* @__PURE__ */ new Map(),
+      authoredValueSeeds: /* @__PURE__ */ new Map(),
       binaryChanges: [],
       binaryFiles: []
     };
@@ -60125,7 +61146,7 @@ function computeWorkspaceStatus(workspace, options = {}) {
   const baseDocuments = schemaBaseDocuments(workspace);
   const baseManifest = baseDocuments.length === 0 ? void 0 : documentsToProjectSchemaManifest(baseDocuments);
   let manifest;
-  let staticValueSeeds = /* @__PURE__ */ new Map();
+  let authoredValueSeeds = /* @__PURE__ */ new Map();
   let staticMemberValueIds = /* @__PURE__ */ new Map();
   let memberDefaults = {
     records: [],
@@ -60167,7 +61188,7 @@ function computeWorkspaceStatus(workspace, options = {}) {
         parseErrors,
         parseWarnings,
         reconstructed: /* @__PURE__ */ new Map(),
-        staticValueSeeds,
+        authoredValueSeeds,
         binaryChanges: [],
         binaryFiles: []
       };
@@ -60192,7 +61213,7 @@ function computeWorkspaceStatus(workspace, options = {}) {
         parseErrors,
         parseWarnings,
         reconstructed: /* @__PURE__ */ new Map(),
-        staticValueSeeds,
+        authoredValueSeeds,
         binaryChanges: [],
         binaryFiles: []
       };
@@ -60241,7 +61262,7 @@ function computeWorkspaceStatus(workspace, options = {}) {
       parseErrors,
       parseWarnings,
       reconstructed: /* @__PURE__ */ new Map(),
-      staticValueSeeds: /* @__PURE__ */ new Map(),
+      authoredValueSeeds: /* @__PURE__ */ new Map(),
       binaryChanges: [],
       binaryFiles: []
     };
@@ -60289,7 +61310,10 @@ function computeWorkspaceStatus(workspace, options = {}) {
     manifest,
     { registry: valueLowerRegistry }
   );
-  staticValueSeeds = new Map([...staticValues.seeds, ...memberDefaults.seeds]);
+  authoredValueSeeds = new Map([
+    ...staticValues.seeds,
+    ...memberDefaults.seeds
+  ]);
   staticMemberValueIds = staticValues.memberValueIds;
   const rootValues = lowerProjectRootSourceV4(
     workspace.state.records,
@@ -60297,7 +61321,7 @@ function computeWorkspaceStatus(workspace, options = {}) {
     manifest,
     { registry: valueLowerRegistry }
   );
-  staticValueSeeds = new Map([...staticValueSeeds, ...rootValues.seeds]);
+  authoredValueSeeds = new Map([...authoredValueSeeds, ...rootValues.seeds]);
   const rootPathResolutionState = overlayProspectiveSourceRecords(
     workspace.state.records,
     documents,
@@ -60533,7 +61557,7 @@ function computeWorkspaceStatus(workspace, options = {}) {
       parseErrors,
       parseWarnings,
       reconstructed: /* @__PURE__ */ new Map(),
-      staticValueSeeds: /* @__PURE__ */ new Map(),
+      authoredValueSeeds: /* @__PURE__ */ new Map(),
       binaryChanges: [],
       binaryFiles: []
     };
@@ -60607,7 +61631,7 @@ function computeWorkspaceStatus(workspace, options = {}) {
         workspace.state.records,
         reconstructed3,
         changes,
-        staticValueSeeds
+        authoredValueSeeds
       )
     );
   } catch (error) {
@@ -60637,7 +61661,7 @@ function computeWorkspaceStatus(workspace, options = {}) {
     parseErrors,
     parseWarnings,
     reconstructed: reconstructed3,
-    staticValueSeeds,
+    authoredValueSeeds,
     binaryChanges,
     binaryFiles,
     initConversions: collectInitDefaultConversions(
@@ -63586,7 +64610,7 @@ var init_project_file_pull = __esm({
 function staticValueSeedEmitRecords(status, present) {
   const records2 = /* @__PURE__ */ new Map();
   if (status === null) return records2;
-  for (const [memberId, seed] of status.staticValueSeeds) {
+  for (const [memberId, seed] of status.authoredValueSeeds) {
     const rootId = seed.valueId ?? memberValueIdFromRecord(status, memberId);
     if (rootId !== null) {
       addSeedRecord(records2, present, {
@@ -66778,6 +67802,20 @@ function memberRuntimeType(record3, context, seen = /* @__PURE__ */ new Set(), g
       return primitive2("void", true);
     case 24 /* FunctionRef */:
       return UNKNOWN_TYPE2;
+    case 25 /* NSDelegate */:
+      if (!isMemberDelegateBase(member)) return UNKNOWN_TYPE2;
+      return {
+        kind: "delegate",
+        returnType: functionReturnType(
+          member.returnTypeInfo,
+          context,
+          genericEnvironment
+        ),
+        parameterTypes: member.argumentTypes.map(
+          (argument2) => toLanguageType(argument2, context, genericEnvironment)
+        ),
+        nullable: !required2
+      };
     case 21 /* Generic */: {
       const genericParamId = getOptionalString(member, "genericParamId");
       if (!genericParamId) return UNKNOWN_TYPE2;
@@ -66972,6 +68010,19 @@ function toLanguageType(type, context, genericEnvironment) {
         ),
         nullable: !required2
       };
+    case 25 /* NSDelegate */:
+      return {
+        kind: "delegate",
+        returnType: functionReturnType(
+          type.returnTypeInfo,
+          context,
+          genericEnvironment
+        ),
+        parameterTypes: type.argumentTypes.map(
+          (argument2) => toLanguageType(argument2, context, genericEnvironment)
+        ),
+        nullable: !required2
+      };
     case 21 /* Generic */: {
       const environmentEntry = genericEnvironment?.get(type.genericParamId);
       if (environmentEntry?.kind === "member") {
@@ -67940,6 +68991,7 @@ function pushConstructionFrame(ctx, label) {
       "Class construction requires an effect-capable evaluator Session scope."
     );
   }
+  consumeBudget(ctx, "workUnits", 1, "work unit");
   if (state.constructionStack.length >= MAX_CONSTRUCTION_DEPTH) {
     const chain = [...state.constructionStack, label].join(" -> ");
     throw new NSGetterRuntimeError(
@@ -67983,6 +69035,7 @@ function evaluateNSGetterWithEffects(getter, ctx, argumentValues = []) {
   const ownsInvocationState = ctx.__executionState === void 0;
   const requestedWrites = [];
   const runtimeCtx = withEvaluationRuntime(ctx, requestedWrites);
+  consumeBudget(runtimeCtx, "workUnits", 1, "work unit");
   const writes = runtimeCtx.__executionState?.writes ?? requestedWrites;
   const existingIds = new Set(runtimeCtx.__runtimeSessionValues.keys());
   const scope = createTopLevelScope(runtimeCtx);
@@ -68033,6 +69086,7 @@ function evaluateNSAction(action, ctx) {
   const ownsInvocationState = ctx.__executionState === void 0;
   const writes = [];
   const runtimeCtx = withEvaluationRuntime(ctx, writes);
+  consumeBudget(runtimeCtx, "workUnits", 1, "work unit");
   const existingIds = new Set(runtimeCtx.__runtimeSessionValues.keys());
   const scope = createTopLevelScope(runtimeCtx);
   try {
@@ -68063,6 +69117,7 @@ function evaluateNSFunction(action, ctx, args) {
   const ownsInvocationState = ctx.__executionState === void 0;
   const writes = [];
   const runtimeCtx = withEvaluationRuntime(ctx, writes);
+  consumeBudget(runtimeCtx, "workUnits", 1, "work unit");
   const existingIds = new Set(runtimeCtx.__runtimeSessionValues.keys());
   const runtimeArgs = remapRuntimeArguments(args, runtimeCtx);
   let value;
@@ -68115,14 +69170,62 @@ function withEvaluationRuntime(ctx, writes) {
     __executionState: ctx.__executionState ?? {
       writes,
       functionStack: [],
+      delegateStack: [],
       constructorGroups: /* @__PURE__ */ new Map(),
       ownedValueAttachments: /* @__PURE__ */ new Map(),
       constructionStack: [],
-      loopIterations: 0
+      loopIterations: 0,
+      budget: createExecutionBudget(ctx.executionBudgetLimits)
     },
     __indexes: ctx.__executionState === void 0 || ctx.__valueOverlay === void 0 ? void 0 : ctx.__indexes
   };
 }
+function createExecutionBudget(requested) {
+  const limits = { ...DEFAULT_NEO_SCRIPT_EXECUTION_BUDGET_LIMITS };
+  for (const key of Object.keys(limits)) {
+    const value = requested?.[key];
+    if (value === void 0) continue;
+    if (!Number.isSafeInteger(value)) {
+      throw new NeoScriptResourceLimitError(
+        `NeoScript ${key} limit must be a safe integer.`
+      );
+    }
+    if (value < 0) {
+      throw new NeoScriptResourceLimitError(
+        `NeoScript ${key} limit must not be negative.`
+      );
+    }
+    if (value > DEFAULT_NEO_SCRIPT_EXECUTION_BUDGET_LIMITS[key]) {
+      throw new NeoScriptResourceLimitError(
+        `NeoScript ${key} limit cannot exceed the safety ceiling of ${DEFAULT_NEO_SCRIPT_EXECUTION_BUDGET_LIMITS[key]}.`
+      );
+    }
+    limits[key] = value;
+  }
+  return {
+    limits,
+    workUnits: 0,
+    collectionVisits: 0,
+    producedCollectionEntries: 0,
+    constructedSessionRows: 0,
+    producedStringCharacters: 0
+  };
+}
+function consumeBudget(ctx, counter, amount, label) {
+  const budget = ctx.__executionState?.budget;
+  if (budget === void 0) {
+    throw new NSGetterRuntimeError(
+      "NeoScript work executed without a shared execution budget."
+    );
+  }
+  const limit = budget.limits[counter];
+  if (amount > limit - budget[counter]) {
+    throw new NeoScriptResourceLimitError(
+      `NeoScript ${label} limit of ${limit} exceeded.`
+    );
+  }
+  budget[counter] += amount;
+}
 function staticBindingMap(bindings) {
   if (bindings === void 0) return /* @__PURE__ */ new Map();
   if (bindings instanceof Map) return new Map(bindings);
@@ -68497,11 +69600,12 @@ function consumeLoopIteration(ctx) {
     );
   }
   if (state.loopIterations >= MAX_LOOP_ITERATIONS) {
-    throw new NSGetterRuntimeError(
+    throw new NeoScriptResourceLimitError(
       `NeoScript loop iteration limit of ${MAX_LOOP_ITERATIONS} exceeded.`
     );
   }
   state.loopIterations += 1;
+  consumeBudget(ctx, "workUnits", 1, "work unit");
 }
 function synchronizeExistingBindings(parent, child, bindingIds) {
   for (const bindingId of bindingIds) {
@@ -68671,6 +69775,7 @@ function validateTryInstruction(instruction) {
 }
 function evalInstructions(instructions, scope, ctx, options) {
   for (const ins of instructions) {
+    consumeBudget(ctx, "workUnits", 1, "work unit");
     switch (ins.type) {
       case "variable" /* variable */: {
         let value = evalPointer(ins.variable.pointer, scope, ctx);
@@ -68785,7 +69890,7 @@ function evalInstructions(instructions, scope, ctx, options) {
       }
       case "forEach" /* forEach */: {
         const collection = evalPointer(ins.collectionPointer, scope, ctx);
-        const membership = snapshotCollectionMembership(collection);
+        const membership = snapshotCollectionMembership(collection, ctx);
         const parentBindingIds = [...scope.keys()];
         const loopScope = createChildScope(scope);
         markReadonlyBinding(
@@ -69155,6 +70260,7 @@ function resolvedDestinationFieldsForContainer(targetValue, ctx) {
   return containerValueId === null ? {} : { resolvedDestination: { containerValueId } };
 }
 function dispatchNSSetter(target, value, scope, ctx, writes) {
+  consumeBudget(ctx, "workUnits", 1, "work unit");
   if (target.type !== "callGetter" /* callGetter */) {
     throw new NSGetterRuntimeError(
       "Setter write target must be a callGetter pointer."
@@ -69258,8 +70364,22 @@ function evalCollectionMutationInstruction(ins, scope, ctx, options) {
   const targetValue = evalPointer(ins.target.pointer, scope, ctx);
   const args = ins.args.map((arg) => evalPointer(arg, scope, ctx));
   const isLookupSet = ins.target.typeInfo.type === 9 /* Lookup */;
+  if (ins.mutation === "Add" /* Add */) {
+    consumeBudget(
+      ctx,
+      "producedCollectionEntries",
+      1,
+      "produced collection entry"
+    );
+  }
   if (ins.target.pointer.type === "variable" /* variable */) {
-    applyLocalCollectionMutation(targetValue, ins.mutation, args, isLookupSet);
+    applyLocalCollectionMutation(
+      targetValue,
+      ins.mutation,
+      args,
+      ctx,
+      isLookupSet
+    );
     invalidateEvaluatorIndexes(ctx);
     scope.set(ins.target.pointer.variableId, targetValue);
     return;
@@ -69289,6 +70409,7 @@ function evalCollectionMutationInstruction(ins, scope, ctx, options) {
     targetValue,
     ins.mutation,
     overlayArgs,
+    ctx,
     isLookupSet
   );
   invalidateEvaluatorIndexes(ctx);
@@ -69349,12 +70470,22 @@ function evalCollectionMutationInstruction(ins, scope, ctx, options) {
       return;
   }
 }
-function applyLocalCollectionMutation(targetValue, mutation, args, unique = false) {
+function applyLocalCollectionMutation(targetValue, mutation, args, ctx, unique = false) {
   validateCollectionMutation(targetValue, mutation, args);
   switch (mutation) {
     case "Add" /* Add */:
       if (Array.isArray(targetValue)) {
-        if (!unique || !targetValue.some((entry) => jsEqual(entry, args[0]))) {
+        let alreadyPresent = false;
+        if (unique) {
+          for (const entry of targetValue) {
+            consumeBudget(ctx, "collectionVisits", 1, "collection visit");
+            if (jsEqual(entry, args[0])) {
+              alreadyPresent = true;
+              break;
+            }
+          }
+        }
+        if (!alreadyPresent) {
           targetValue.push(args[0]);
         }
         return;
@@ -69363,7 +70494,14 @@ function applyLocalCollectionMutation(targetValue, mutation, args, unique = fals
       return;
     case "Remove" /* Remove */:
       if (Array.isArray(targetValue)) {
-        const index = targetValue.findIndex((entry) => jsEqual(entry, args[0]));
+        let index = -1;
+        for (let candidate = 0; candidate < targetValue.length; candidate += 1) {
+          consumeBudget(ctx, "collectionVisits", 1, "collection visit");
+          if (jsEqual(targetValue[candidate], args[0])) {
+            index = candidate;
+            break;
+          }
+        }
         if (index >= 0) targetValue.splice(index, 1);
         return;
       }
@@ -69380,10 +70518,18 @@ function applyLocalCollectionMutation(targetValue, mutation, args, unique = fals
     }
     case "Clear" /* Clear */:
       if (Array.isArray(targetValue)) {
+        consumeBudget(
+          ctx,
+          "collectionVisits",
+          targetValue.length,
+          "collection visit"
+        );
         targetValue.length = 0;
         return;
       }
-      for (const key of Object.keys(objectArg(targetValue, "Clear target"))) {
+      const keys = Object.keys(objectArg(targetValue, "Clear target"));
+      consumeBudget(ctx, "collectionVisits", keys.length, "collection visit");
+      for (const key of keys) {
         delete objectArg(targetValue, "Clear target")[key];
       }
       return;
@@ -69518,8 +70664,17 @@ function evalStaticMember(memberId, ctx) {
 }
 function evalPointer(pointer, scope, ctx) {
   switch (pointer.type) {
-    case "value" /* value */:
-      return pointer.value.value;
+    case "value" /* value */: {
+      const value = pointer.value.value;
+      if (isNSDelegateClosureValue(value)) {
+        return {
+          ...value,
+          [DELEGATE_LEXICAL_THIS]: ctx.thisValue,
+          [DELEGATE_LEXICAL_ROOT]: ctx.rootValue
+        };
+      }
+      return value;
+    }
     case "variable" /* variable */: {
       if (!scope.has(pointer.variableId)) {
         throw new NSGetterRuntimeError(
@@ -69557,8 +70712,20 @@ function evalPointer(pointer, scope, ctx) {
     case "function" /* function */:
       return evalFunction(pointer.function, scope, ctx);
     case "listLiteral" /* listLiteral */:
+      consumeBudget(
+        ctx,
+        "producedCollectionEntries",
+        pointer.entries.length,
+        "produced collection entry"
+      );
       return pointer.entries.map((e) => evalPointer(e, scope, ctx));
     case "dictLiteral" /* dictLiteral */: {
+      consumeBudget(
+        ctx,
+        "producedCollectionEntries",
+        pointer.entries.length,
+        "produced collection entry"
+      );
       const out = {};
       for (const e of pointer.entries) {
         const k = evalPointer(e.key, scope, ctx);
@@ -69611,6 +70778,7 @@ function evalPointer(pointer, scope, ctx) {
           `Function call '${member.name}' resolves to non-callable member kind ${MemberKind[member.kind]}.`
         );
       }
+      consumeBudget(ctx, "workUnits", 1, "work unit");
       if (member.kind === 13 /* Function */) {
         throw new NativeFunctionDelegateUnavailableError(
           `Cannot evaluate native Function '${member.name}' in web preview because no native delegate is available.`
@@ -69666,6 +70834,17 @@ function evalPointer(pointer, scope, ctx) {
         state.functionStack.pop();
       }
     }
+    case "callDelegate" /* callDelegate */: {
+      const delegate = evalPointer(pointer.delegate, scope, ctx);
+      if (delegate === null || delegate === void 0) {
+        if (pointer.optional === true) return null;
+        throw new NSGetterRuntimeError(
+          "Cannot invoke a null NeoDelegate value."
+        );
+      }
+      const args = pointer.args.map((arg) => evalPointer(arg, scope, ctx));
+      return invokeDelegateValue(delegate, args, ctx);
+    }
     case "functionErrorCheck" /* functionErrorCheck */: {
       try {
         evalPointer(pointer.call, scope, ctx);
@@ -69674,7 +70853,7 @@ function evalPointer(pointer, scope, ctx) {
         if (err instanceof NativeFunctionDelegateUnavailableError) {
           return pointer.mode === "doesNotThrow" /* DoesNotThrow */;
         }
-        if (err instanceof NSGetterRuntimeError) {
+        if (isCatchableNSRuntimeError(err)) {
           return pointer.mode === "throws" /* Throws */;
         }
         throw err;
@@ -69691,7 +70870,14 @@ function evalPointer(pointer, scope, ctx) {
     }
     case "stringify" /* stringify */: {
       const v = evalPointer(pointer.pointer, scope, ctx);
-      return formatForInterp(v, pointer.sourceType, ctx);
+      const formatted = formatForInterp(v, pointer.sourceType, ctx);
+      consumeBudget(
+        ctx,
+        "producedStringCharacters",
+        formatted.length,
+        "produced string character"
+      );
+      return formatted;
     }
   }
 }
@@ -69706,6 +70892,174 @@ function resolveEffectiveCallableMember(pointer, receiver, ctx) {
   const runtimeMember = resolveRuntimeSchemaMember(receiver, schemaKey, ctx);
   return runtimeMember ?? staticMember;
 }
+function invokeDelegateValue(value, args, ctx) {
+  if (isNSDelegateClosureValueDraft(value)) {
+    throw new NSGetterRuntimeError(
+      "NeoDelegate closure has source code but no compiled action."
+    );
+  }
+  if (isNSDelegateClosureValue(value)) {
+    const closure = value;
+    const thisValue = delegateClosureLexicalThis(closure, ctx);
+    return executeCompiledFunction(
+      value.action,
+      {
+        ...ctx,
+        thisValue,
+        rootValue: closure[DELEGATE_LEXICAL_ROOT] ?? ctx.rootValue
+      },
+      args,
+      value.action.typeInfo.type === 0 /* Null */
+    );
+  }
+  if (!isMemberDelegateTarget(value)) {
+    throw new NSGetterRuntimeError(
+      "NeoDelegate value is neither a closure nor a bound member target."
+    );
+  }
+  const member = evalMemberById(ctx.vm, value.memberId);
+  if (member === null) {
+    throw new NSGetterRuntimeError(
+      `NeoDelegate target member '${value.memberId}' does not exist.`
+    );
+  }
+  const state = ctx.__executionState;
+  if (state === void 0) {
+    throw new NSGetterRuntimeError(
+      "NeoDelegate invocation reached an evaluator without execution state."
+    );
+  }
+  const frame = `${member.name}[${value.valueId ?? "default"}]`;
+  if (state.delegateStack.includes(frame)) {
+    throw new NSGetterRuntimeError(
+      `NeoDelegate target cycle: ${[...state.delegateStack, frame].join(" -> ")}.`
+    );
+  }
+  if (state.delegateStack.length >= 64) {
+    throw new NSGetterRuntimeError(
+      `NeoDelegate call stack exceeded 64 frames: ${[
+        ...state.delegateStack,
+        frame
+      ].join(" -> ")}.`
+    );
+  }
+  let receiver = null;
+  if (value.valueId !== null) {
+    const row = evalValueById(
+      ctx.vm,
+      value.valueId,
+      ctx.__runtimeSessionValues,
+      ctx.__valueOverlay
+    );
+    if (row === null) {
+      throw new NSGetterRuntimeError(
+        `NeoDelegate target '${member.name}' has missing receiver value '${value.valueId}'.`
+      );
+    }
+    receiver = row.value;
+  }
+  state.delegateStack.push(frame);
+  try {
+    if (member.kind === 13 /* Function */) {
+      throw new NativeFunctionDelegateUnavailableError(
+        `Cannot evaluate native Function '${member.name}' in web preview because no native delegate is available.`
+      );
+    }
+    if (member.kind === 23 /* NSFunction */) {
+      const signature = resolveCallableSignature(member.id, member.kind, ctx);
+      const action = resolveCompiledNSFunction(member.id, ctx);
+      if (signature === null || action === null) {
+        throw new NSGetterRuntimeError(
+          `NeoDelegate target NSFunction '${member.name}' has no valid compiled body.`
+        );
+      }
+      const runtimeSignature = receiver === null ? signature : substituteCallableSignatureForReceiver(signature, receiver, ctx);
+      return executeCompiledFunction(
+        action,
+        { ...ctx, thisValue: receiver },
+        args,
+        runtimeSignature.returnTypeInfo.type === NS_TYPE_VOID,
+        runtimeSignature
+      );
+    }
+    if (member.kind === 25 /* NSDelegate */) {
+      let nested;
+      if (receiver !== null) {
+        const schemaKey = cachedSchemaKeyForMember(member.id, ctx);
+        if (schemaKey === null || typeof receiver !== "object" || !Object.prototype.hasOwnProperty.call(receiver, schemaKey)) {
+          throw new NSGetterRuntimeError(
+            `NeoDelegate target '${member.name}' is missing from its receiver.`
+          );
+        }
+        nested = resolveValueIfIdForMember(
+          receiver[schemaKey],
+          member,
+          ctx
+        );
+      } else if (member.defaultValue !== void 0 && member.defaultValue !== null && isLiteralValueContent(member.defaultValue)) {
+        nested = member.defaultValue.value;
+      } else {
+        throw new NSGetterRuntimeError(
+          `NeoDelegate target '${member.name}' has no declaration default.`
+        );
+      }
+      return invokeDelegateValue(nested, args, ctx);
+    }
+    throw new NSGetterRuntimeError(
+      `NeoDelegate target '${member.name}' resolves to non-callable member kind ${MemberKind[member.kind]}.`
+    );
+  } finally {
+    state.delegateStack.pop();
+  }
+}
+function delegateClosureLexicalThis(closure, ctx) {
+  if (Object.prototype.hasOwnProperty.call(closure, DELEGATE_LEXICAL_THIS)) {
+    return closure[DELEGATE_LEXICAL_THIS];
+  }
+  const closureRow = trackedRowForValueReference(closure, ctx);
+  if (closureRow === null) {
+    throw new NSGetterRuntimeError(
+      "Stored NeoDelegate closure has no resolvable value row; lexical this cannot be reconstructed from ownership."
+    );
+  }
+  const owners = /* @__PURE__ */ new Map();
+  for (const link of evaluatorIndexes(ctx).parentLinksByChildId.get(
+    closureRow.id
+  ) ?? []) {
+    const parent = evalValueById(
+      ctx.vm,
+      link.parentId,
+      ctx.__runtimeSessionValues,
+      ctx.__valueOverlay
+    );
+    if (parent === null) continue;
+    if (typeof parent.value !== "object") continue;
+    if (parent.value === null) continue;
+    if (Array.isArray(parent.value)) continue;
+    const classId = classIdForValueRow(parent, ctx);
+    if (classId === void 0) continue;
+    const owningMember = memberForCustomSchemaValue(classId, link.key, ctx);
+    if (owningMember?.kind !== 25 /* NSDelegate */) continue;
+    owners.set(parent.id, parent.value);
+  }
+  if (owners.size === 0) {
+    throw new NSGetterRuntimeError(
+      `Stored NeoDelegate closure value '${closureRow.id}' has no owning class instance; lexical this cannot be reconstructed from ownership.`
+    );
+  }
+  if (owners.size > 1) {
+    throw new NSGetterRuntimeError(
+      `Stored NeoDelegate closure value '${closureRow.id}' has multiple owning class instances (${[...owners.keys()].join(", ")}); lexical this is ambiguous.`
+    );
+  }
+  const owner = owners.values().next();
+  if (owner.done) {
+    throw new NSGetterRuntimeError(
+      `Stored NeoDelegate closure value '${closureRow.id}' lost its owning class instance during lexical-this resolution.`
+    );
+  }
+  return owner.value;
+}
 function resolveCallableSignature(memberId, memberKind, ctx) {
   const cacheKey = `${memberKind}:${memberId}`;
   const cache = evaluatorResolutionCache(ctx).callableSignatureByKey;
@@ -70633,11 +71987,11 @@ function evalOperation(operation, scope, ctx) {
   if (operation.type === "arithmetic" /* arithmetic */) {
     const op = operation.arithmetic;
     const operands = op.pointers.map((p) => evalPointer(p, scope, ctx));
-    return applyArithmetic(op.type, operands, op.decimal === true);
+    return applyArithmetic(op.type, operands, op.decimal === true, ctx);
   }
   return evalBooleanExpression(operation.expression, scope, ctx);
 }
-function applyArithmetic(op, operands, decimal2) {
+function applyArithmetic(op, operands, decimal2, ctx) {
   if (operands.length === 0) {
     throw new NSGetterRuntimeError("Arithmetic operation with no operands");
   }
@@ -70645,10 +71999,24 @@ function applyArithmetic(op, operands, decimal2) {
     return applyDecimalArithmetic(op, operands);
   }
   if (op === "+" /* addition */ && operands.every((o) => typeof o === "string")) {
-    return operands.join("");
+    const result = operands.join("");
+    consumeBudget(
+      ctx,
+      "producedStringCharacters",
+      result.length,
+      "produced string character"
+    );
+    return result;
   }
   if (op === "+" /* addition */ && operands.some((o) => typeof o === "string")) {
-    return operands.map((o) => stringifyForInterp(o)).join("");
+    const result = operands.map((o) => stringifyForInterp(o)).join("");
+    consumeBudget(
+      ctx,
+      "producedStringCharacters",
+      result.length,
+      "produced string character"
+    );
+    return result;
   }
   const numbers = operands.map((o) => {
     if (typeof o === "number") return o;
@@ -71043,12 +72411,36 @@ function evalFunction(fn, scope, ctx) {
         );
       }
       switch (fn.info.op) {
-        case "toLower":
-          return receiver.toLowerCase();
-        case "toUpper":
-          return receiver.toUpperCase();
-        case "trim":
-          return receiver.trim();
+        case "toLower": {
+          const result = receiver.toLowerCase();
+          consumeBudget(
+            ctx,
+            "producedStringCharacters",
+            result.length,
+            "produced string character"
+          );
+          return result;
+        }
+        case "toUpper": {
+          const result = receiver.toUpperCase();
+          consumeBudget(
+            ctx,
+            "producedStringCharacters",
+            result.length,
+            "produced string character"
+          );
+          return result;
+        }
+        case "trim": {
+          const result = receiver.trim();
+          consumeBudget(
+            ctx,
+            "producedStringCharacters",
+            result.length,
+            "produced string character"
+          );
+          return result;
+        }
         case "startsWith":
         case "endsWith": {
           if (fn.info.argPointer === void 0) {
@@ -71073,6 +72465,7 @@ function evalFunction(fn, scope, ctx) {
       const isList = Array.isArray(c);
       const out = isList ? [] : {};
       iterateCollection(c, ctx, (entry, key, valueId) => {
+        consumeBudget(ctx, "workUnits", 1, "work unit");
         const innerScope = pushParams(
           scope,
           innerFn.parameters,
@@ -71090,6 +72483,12 @@ function evalFunction(fn, scope, ctx) {
           evaluationOptions(ctx, false)
         );
         if (result.kind === "return" && result.value === true) {
+          consumeBudget(
+            ctx,
+            "producedCollectionEntries",
+            1,
+            "produced collection entry"
+          );
           if (isList) {
             out.push(valueId ?? entry);
           } else {
@@ -71112,6 +72511,7 @@ function evalFunction(fn, scope, ctx) {
           found = entry;
           return;
         }
+        consumeBudget(ctx, "workUnits", 1, "work unit");
         const innerScope = pushParams(
           scope,
           innerFn.parameters,
@@ -71142,6 +72542,7 @@ function evalFunction(fn, scope, ctx) {
       const isList = Array.isArray(c);
       const out = [];
       iterateCollection(c, ctx, (entry, key) => {
+        consumeBudget(ctx, "workUnits", 1, "work unit");
         const innerScope = pushParams(
           scope,
           innerFn.parameters,
@@ -71155,6 +72556,12 @@ function evalFunction(fn, scope, ctx) {
           evaluationOptions(ctx, false)
         );
         if (result.kind === "return") {
+          consumeBudget(
+            ctx,
+            "producedCollectionEntries",
+            1,
+            "produced collection entry"
+          );
           out.push(result.value);
         }
       });
@@ -71530,6 +72937,25 @@ function publishConstructedRows(args) {
       "Class construction requires an effect-capable evaluator Session scope."
     );
   }
+  consumeBudget(
+    ctx,
+    "constructedSessionRows",
+    createdValues.length,
+    "constructed Session row"
+  );
+  let producedEntries = 0;
+  for (const row of createdValues) {
+    if (Array.isArray(row.value)) producedEntries += row.value.length;
+    else if (typeof row.value === "object" && row.value !== null) {
+      producedEntries += Object.keys(row.value).length;
+    }
+  }
+  consumeBudget(
+    ctx,
+    "producedCollectionEntries",
+    producedEntries,
+    "produced collection entry"
+  );
   const retained = new Set(createdValues.map((row) => row.id));
   for (const rowId of beforeRetain) {
     if (retained.has(rowId)) continue;
@@ -72942,9 +74368,10 @@ function collectionLength(c) {
     `Cannot Count() ${typeof c}; expected list, dictionary, or string`
   );
 }
-function snapshotCollectionMembership(collection) {
+function snapshotCollectionMembership(collection, ctx) {
   const membership = [];
   const valid = forEachRawCollectionEntry(collection, ({ raw }) => {
+    consumeBudget(ctx, "collectionVisits", 1, "collection visit");
     membership.push(raw);
   });
   if (valid) return membership;
@@ -72979,12 +74406,14 @@ function forEachRawCollectionEntry(c, callback) {
 function collectionEntries(c, ctx) {
   const entries = [];
   forEachRawCollectionEntry(c, ({ raw }) => {
+    consumeBudget(ctx, "collectionVisits", 1, "collection visit");
     entries.push(resolveValueIfId(raw, ctx));
   });
   return entries;
 }
 function iterateCollection(c, ctx, callback) {
   forEachRawCollectionEntry(c, ({ raw, key, valueId }) => {
+    consumeBudget(ctx, "collectionVisits", 1, "collection visit");
     const entry = resolveValueIfId(raw, ctx);
     callback(entry, key, valueId);
   });
@@ -73000,7 +74429,7 @@ function pushParams(parent, parameters, positional, isList) {
   }
   return child;
 }
-var NonCatchableNSGetterRuntimeError, NativeFunctionDelegateUnavailableError, CorruptNeoScriptIRError, liveListIndexesByProject, MAX_CONSTRUCTION_DEPTH, MAX_LOOP_ITERATIONS, LazyValueOverlay, readonlyBindingErrorsByScope, READONLY_FOREACH_BINDING_ERROR, READONLY_CATCH_BINDING_ERROR;
+var DELEGATE_LEXICAL_THIS, DELEGATE_LEXICAL_ROOT, NonCatchableNSGetterRuntimeError, NativeFunctionDelegateUnavailableError, CorruptNeoScriptIRError, NeoScriptResourceLimitError, DEFAULT_NEO_SCRIPT_EXECUTION_BUDGET_LIMITS, liveListIndexesByProject, MAX_CONSTRUCTION_DEPTH, MAX_LOOP_ITERATIONS, LazyValueOverlay, readonlyBindingErrorsByScope, READONLY_FOREACH_BINDING_ERROR, READONLY_CATCH_BINDING_ERROR;
 var init_evaluateNSGetter = __esm({
   "../src/view-models/neoscript-evaluator/evaluateNSGetter.ts"() {
     "use strict";
@@ -73016,12 +74445,27 @@ var init_evaluateNSGetter = __esm({
     init_core();
     init_member_storage_key();
     init_project2();
+    DELEGATE_LEXICAL_THIS = /* @__PURE__ */ Symbol("neoDelegateLexicalThis");
+    DELEGATE_LEXICAL_ROOT = /* @__PURE__ */ Symbol("neoDelegateLexicalRoot");
     NonCatchableNSGetterRuntimeError = class extends NSGetterRuntimeError {
     };
     NativeFunctionDelegateUnavailableError = class extends NonCatchableNSGetterRuntimeError {
     };
     CorruptNeoScriptIRError = class extends NonCatchableNSGetterRuntimeError {
     };
+    NeoScriptResourceLimitError = class extends NonCatchableNSGetterRuntimeError {
+      constructor(message) {
+        super(message);
+        this.name = "NeoScriptResourceLimitError";
+      }
+    };
+    DEFAULT_NEO_SCRIPT_EXECUTION_BUDGET_LIMITS = Object.freeze({
+      workUnits: 1e5,
+      collectionVisits: 1e5,
+      producedCollectionEntries: 1e4,
+      constructedSessionRows: 1e3,
+      producedStringCharacters: 1024 * 1024
+    });
     liveListIndexesByProject = /* @__PURE__ */ new WeakMap();
     MAX_CONSTRUCTION_DEPTH = 64;
     MAX_LOOP_ITERATIONS = 1e4;
@@ -74281,6 +75725,58 @@ function compileAuthoredMemberBodies(args) {
   compileNSPropertyBodies(args);
   compileNSFunctionBody(args);
   compileMemberInitializerBody(args);
+  compileMemberDelegateDefault(args);
+}
+function compileDelegateClosureValue(code, signature) {
+  const compiled = compileNSGetter(`return ${code};`, {
+    project: signature.project,
+    projectFiles: signature.projectFiles ?? [],
+    members: [...signature.members],
+    classes: [...signature.classes],
+    enums: [...signature.enums],
+    interfaces: [...signature.interfaces ?? []],
+    constructors: [...signature.constructors ?? []],
+    thisClass: signature.thisClass,
+    returnTypeInfo: {
+      type: 25 /* NSDelegate */,
+      required: true,
+      returnTypeInfo: signature.returnTypeInfo,
+      argumentTypes: [...signature.argumentTypes]
+    },
+    functionName: signature.name
+  });
+  const instruction = compiled.instructions[0];
+  if (compiled.instructions.length !== 1 || instruction?.type !== "return" /* return */ || instruction.pointer?.type !== "value" /* value */) {
+    throw new Error(
+      `NeoDelegate closure "${signature.name}" did not compile to one closure literal.`
+    );
+  }
+  const value = instruction.pointer.value.value;
+  if (!value || typeof value !== "object" || !("action" in value)) {
+    throw new Error(
+      `NeoDelegate closure "${signature.name}" compiled without an action.`
+    );
+  }
+  const action = value.action;
+  if (!isNSFunctionWithReturnType(action)) {
+    throw new Error(
+      `NeoDelegate closure "${signature.name}" compiled an invalid action.`
+    );
+  }
+  return { code, action };
+}
+function compileMemberDelegateDefault(args) {
+  if (!isMemberDelegateBase(args.member)) return;
+  const defaultValue = args.member.defaultValue;
+  if (defaultValue === void 0 || !isLiteralValueContent(defaultValue) || !isNSDelegateClosureValueDraft(defaultValue.value)) {
+    return;
+  }
+  defaultValue.value = compileDelegateClosureValue(defaultValue.value.code, {
+    ...args,
+    returnTypeInfo: args.member.returnTypeInfo,
+    argumentTypes: args.member.argumentTypes,
+    name: args.member.name
+  });
 }
 function compileConstructorRecord(args) {
   const owner = args.classes.find(
@@ -74523,6 +76019,18 @@ function resolveMemberDeclaredTypeInfo(member, members) {
       enumId: resolved.enumId
     };
   }
+  if (isMemberDelegateBase(resolved)) {
+    return {
+      type: 25 /* NSDelegate */,
+      required: resolved.required,
+      returnTypeInfo: resolved.returnTypeInfo,
+      argumentTypes: resolved.argumentTypes.map((argument2) => {
+        const { name, ...typeInfo } = argument2;
+        void name;
+        return typeInfo;
+      })
+    };
+  }
   if (isMemberListBase(resolved) || isMemberDictionaryBase(resolved)) {
     const entry = members.find(
       (candidate) => candidate.id === resolved.entryMemberId
@@ -81029,7 +82537,7 @@ function verifyProjectSourceCommitAgainstStateV4(args) {
     );
   }
   auditAuthoredSeedRowIdentities(
-    status.staticValueSeeds,
+    status.authoredValueSeeds,
     args.stateRecords,
     assignments
   );
@@ -81048,7 +82556,7 @@ function verifyProjectSourceCommitAgainstStateV4(args) {
       expectedBaseContentHash: change.kind === "create" ? null : change.casBaseHash ?? null
     };
   });
-  const expectedSeeds = [...status.staticValueSeeds].map(
+  const expectedSeeds = [...status.authoredValueSeeds].map(
     ([memberId, seed]) => ({
       memberId: rewritePending(memberId, assignments, usedAssignments),
       value: rewritePending(seed.value, assignments, usedAssignments),
@@ -81092,7 +82600,7 @@ function verifyProjectSourceCommitAgainstStateV4(args) {
     return !isDerivedOnlyRefresh(change, args.stateRecords);
   });
   compareChanges(expectedChanges, verifiableChanges);
-  compareSeeds(expectedSeeds, args.staticValueSeeds);
+  compareSeeds(expectedSeeds, args.authoredValueSeeds);
 }
 function isDerivedOnlyRefresh(change, stateRecords) {
   if (change.operation !== "update") return false;
@@ -82325,7 +83833,7 @@ var init_general_function_call_ir_source_recompile = __esm({
 });
 
 // ../src/database/project-version-transaction-types.ts
-function isStaticMemberValueSeedInitContent(content) {
+function isAuthoredValueSeedInitContent(content) {
   return content.init !== void 0;
 }
 var init_project_version_transaction_types = __esm({
@@ -83932,10 +85440,10 @@ function prepareServerOwnedSchemaCommit(args) {
     requiresCompleteSweep,
     contentHashHeads: args.contentHashHeads
   });
-  materializeStaticValueSeeds({
+  materializeAuthoredValueSeeds({
     document: applyProjectVersionWriteChanges(postDocument, prepared),
     prepared,
-    staticValueSeeds: args.staticValueSeeds ?? []
+    authoredValueSeeds: args.authoredValueSeeds ?? []
   });
   prepareServerOwnedValueInitializerBodies({
     document: args.document,
@@ -83944,6 +85452,13 @@ function prepareServerOwnedSchemaCommit(args) {
     requiresCompleteSweep,
     contentHashHeads: args.contentHashHeads
   });
+  prepareServerOwnedDelegateValueBodies({
+    document: args.document,
+    postDocument,
+    prepared,
+    requiresCompleteSweep,
+    contentHashHeads: args.contentHashHeads
+  });
   const committedDocument = applyProjectVersionWriteChanges(
     args.document,
     prepared
@@ -84727,13 +86242,13 @@ function drainConstructedGraphValidations(args) {
     });
   }
 }
-function materializeStaticValueSeeds(args) {
+function materializeAuthoredValueSeeds(args) {
   const pendingGraphValidations = [];
   materializeStaticSeedBindingMembers(args);
   const seedByMemberId = new Map(
-    args.staticValueSeeds.map((seed) => [seed.memberId, seed])
+    args.authoredValueSeeds.map((seed) => [seed.memberId, seed])
   );
-  if (seedByMemberId.size !== args.staticValueSeeds.length) {
+  if (seedByMemberId.size !== args.authoredValueSeeds.length) {
     throw new Error("Schema commit contains duplicate member value seeds.");
   }
   const consumedSeedMemberIds = /* @__PURE__ */ new Set();
@@ -84891,9 +86406,9 @@ function materializeStaticValueSeeds(args) {
       });
     }
   }
-  for (const seed of args.staticValueSeeds) {
+  for (const seed of args.authoredValueSeeds) {
     if (consumedSeedMemberIds.has(seed.memberId)) continue;
-    materializeExistingStaticValueSeed({
+    materializeExistingAuthoredValueSeed({
       document: args.document,
       prepared: args.prepared,
       pendingGraphValidations,
@@ -84907,7 +86422,7 @@ function materializeStaticValueSeeds(args) {
     pending: pendingGraphValidations
   });
 }
-function materializeExistingStaticValueSeed(args) {
+function materializeExistingAuthoredValueSeed(args) {
   const member = args.document.members.find(
     (candidate) => candidate.id === args.seed.memberId
   );
@@ -85008,7 +86523,7 @@ function materializeExistingStaticValueSeed(args) {
   }
 }
 function materializeStaticSeedBindingMembers(args) {
-  const bindings = args.staticValueSeeds.flatMap(
+  const bindings = args.authoredValueSeeds.flatMap(
     (seed) => seed.bindingMembers ?? []
   );
   const ids = new Set(bindings.map((binding) => binding.id));
@@ -85329,14 +86844,14 @@ function materializeSeedLocalizableStringWrites(args) {
   return [...args.seededLocalizedTexts, ...generatedTexts];
 }
 function seedValueContent(seed) {
-  if (isStaticMemberValueSeedInitContent(seed)) return { init: seed.init };
+  if (isAuthoredValueSeedInitContent(seed)) return { init: seed.init };
   return {
     value: seed.value,
     ...seed.classId === null ? {} : { classId: seed.classId }
   };
 }
 function seedRootRow(member, seed, rootId) {
-  if (isStaticMemberValueSeedInitContent(seed)) {
+  if (isAuthoredValueSeedInitContent(seed)) {
     return { id: rootId, memberId: member.id, init: seed.init };
   }
   return {
@@ -85347,7 +86862,7 @@ function seedRootRow(member, seed, rootId) {
   };
 }
 function authoredSeedRowMatchesValue(row, value) {
-  if (isStaticMemberValueSeedInitContent(row)) {
+  if (isAuthoredValueSeedInitContent(row)) {
     return isInitValueContent(value) && value.init.code === row.init.code;
   }
   if (isInitValueContent(value)) return false;
@@ -85421,7 +86936,7 @@ function materializeAuthoredSeedRow(args) {
     );
   }
   if (args.authoredRows.has(args.row.id)) args.usedRows.add(args.row.id);
-  if (isStaticMemberValueSeedInitContent(args.row)) {
+  if (isAuthoredValueSeedInitContent(args.row)) {
     const initRow = {
       id: args.row.id,
       projectId: args.document.project.id,
@@ -85945,6 +87460,119 @@ function prepareServerOwnedValueInitializerBodies(args) {
     });
   }
 }
+function delegateValueRow(value) {
+  if (!isMemberValue(value) || !isLiteralValueContent(value)) return null;
+  if (!isNSDelegateClosureValueDraft(value.value) && !isNSDelegateClosureValue(value.value)) {
+    return null;
+  }
+  return typeof value.value.code === "string" ? value : null;
+}
+function prepareServerOwnedDelegateValueBodies(args) {
+  const explicitRows = /* @__PURE__ */ new Map();
+  for (let index = 0; index < args.prepared.length; index += 1) {
+    const change = args.prepared[index];
+    if (change?.recordKind !== "value" || change.operation === "delete") {
+      continue;
+    }
+    const row = delegateValueRow(change.nextData);
+    if (row !== null) explicitRows.set(index, row);
+  }
+  const sweepRows = args.requiresCompleteSweep ? args.postDocument.values.filter(
+    (value) => delegateValueRow(value) !== null && !args.prepared.some(
+      (change) => change.recordKind === "value" && change.recordId === value.id
+    )
+  ) : [];
+  if (explicitRows.size === 0 && sweepRows.length === 0) return;
+  const committedDocument = applyProjectVersionWriteChanges(
+    args.postDocument,
+    args.prepared
+  );
+  const targetIds = /* @__PURE__ */ new Set([
+    ...[...explicitRows.values()].map((row) => row.id),
+    ...sweepRows.map((row) => row.id)
+  ]);
+  const rootOwnerByValueId = /* @__PURE__ */ new Map();
+  const ownerByValueId = resolveOwnerMembersForValues(
+    committedDocument,
+    targetIds,
+    void 0,
+    rootOwnerByValueId
+  );
+  const compileOne = (document, row) => {
+    const member = ownerByValueId.get(row.id);
+    if (!isMemberDelegateBase(member)) {
+      throw new Error(
+        `Value "${row.id}" carries a NeoDelegate closure but no NeoDelegate member in this project version stores it.`
+      );
+    }
+    row.value = compileDelegateClosureValue(row.value.code, {
+      project: document.project,
+      projectFiles: document.projectFiles,
+      members: document.members,
+      classes: document.classes,
+      enums: document.enums,
+      interfaces: document.interfaces,
+      constructors: document.constructors ?? [],
+      thisClass: findSchemaPlacement(
+        rootOwnerByValueId.get(row.id)?.id ?? "",
+        document.classes
+      )?.ownerClass ?? null,
+      returnTypeInfo: member.returnTypeInfo,
+      argumentTypes: member.argumentTypes,
+      name: `${member.name} value`
+    });
+  };
+  for (const [index, row] of explicitRows) {
+    const compiled = { ...row, value: { ...row.value } };
+    compileOne(committedDocument, compiled);
+    const change = args.prepared[index];
+    if (change !== void 0) {
+      args.prepared[index] = { ...change, nextData: compiled };
+    }
+  }
+  if (sweepRows.length === 0) return;
+  const currentById = new Map(
+    args.document.values.map((value) => [value.id, value])
+  );
+  const hashById = new Map(
+    args.contentHashHeads.filter((head) => head.recordKind === "value" && !head.deleted).map((head) => [head.recordId, head.contentHash])
+  );
+  for (const row of sweepRows) {
+    const compiled = { ...row, value: { ...row.value } };
+    try {
+      compileOne(committedDocument, compiled);
+    } catch (postWriteError) {
+      const current2 = delegateValueRow(
+        structuredClone(currentById.get(row.id))
+      );
+      if (current2 === null) throw postWriteError;
+      try {
+        compileOne(args.document, current2);
+      } catch (preWriteError) {
+        if (sameCompileFailure(preWriteError, postWriteError)) continue;
+      }
+      throw postWriteError;
+    }
+    const current = currentById.get(row.id);
+    if (current === void 0 || canonicallyEqual2(current, compiled)) continue;
+    const contentHash = hashById.get(row.id);
+    if (contentHash === void 0) {
+      throw new Error(
+        `Cannot safely refresh the compiled NeoDelegate closure for value "${row.id}": its current content hash is unavailable.`
+      );
+    }
+    args.prepared.push({
+      recordKind: "value",
+      recordId: row.id,
+      operation: "update",
+      nextData: compiled,
+      intent: createProjectVersionIntent("value.update", {
+        source: "server-neoscript-recompile"
+      }),
+      expectedBaseContentHash: contentHash
+    });
+  }
+}
 function prepareServerOwnedConstructorBodies(args) {
   const currentById = new Map(
     (args.document.constructors ?? []).map((record3) => [record3.id, record3])
@@ -86234,6 +87862,7 @@ function cloneAndStripClientDerivedBodies(change) {
     if (nextData2 === null) return { ...change, nextData: change.nextData };
     const stripped = { ...nextData2 };
     stripInitializerCompanion(stripped, "init");
+    stripDelegateClosureCompanion(stripped, "value");
     return { ...change, nextData: stripped };
   }
   if (change.recordKind !== "member") {
@@ -86312,9 +87941,26 @@ function stripDerivedBodies(member) {
   if (member.kind === 23 /* NSFunction */) {
     delete next.action;
   }
+  if (member.kind === 25 /* NSDelegate */) {
+    stripDelegateClosureCompanion(next, "defaultValue");
+  }
   stripInitializerCompanion(next, "defaultValue");
   return next;
 }
+function stripDelegateClosureCompanion(record3, field) {
+  const container = field === "value" ? record3 : asRecord2(record3.defaultValue);
+  if (container === null) return;
+  const delegate = asRecord2(container.value);
+  if (delegate === null || typeof delegate.code !== "string") return;
+  if (!("action" in delegate)) return;
+  const authoredDelegate = { ...delegate };
+  delete authoredDelegate.action;
+  if (field === "value") {
+    record3.value = authoredDelegate;
+    return;
+  }
+  record3.defaultValue = { ...container, value: authoredDelegate };
+}
 function stripInitializerCompanion(record3, field) {
   const container = field === "init" ? record3 : asRecord2(record3.defaultValue);
   if (container === null) return;
@@ -89409,7 +91055,7 @@ function runServerPreparation(args) {
     document,
     contentHashHeads,
     changes: trustedChanges,
-    staticValueSeeds: args.staticValueSeeds,
+    authoredValueSeeds: args.authoredValueSeeds,
     // A CLI push is always a trusted-source commit, so the server always
     // expands read-only source conversions for it.
     expandReadOnlySourceConversions: true
@@ -89683,7 +91329,7 @@ import {
   readFileSync as readFileSync14
 } from "node:fs";
 import { dirname as dirname7, join as join17, relative as relative5, sep as sep5 } from "node:path";
-function assignPendingIds(changes, staticValueSeeds, reconstructed3) {
+function assignPendingIds(changes, authoredValueSeeds, reconstructed3) {
   const assigned = /* @__PURE__ */ new Map();
   const assign = (pendingId2) => {
     const existing = assigned.get(pendingId2);
@@ -89732,7 +91378,7 @@ function assignPendingIds(changes, staticValueSeeds, reconstructed3) {
     collect(change.recordId);
     collect(change.nextData);
   }
-  for (const [memberId, seed] of staticValueSeeds) {
+  for (const [memberId, seed] of authoredValueSeeds) {
     collect(memberId);
     collect(seed);
   }
@@ -89778,7 +91424,7 @@ function assignPendingIds(changes, staticValueSeeds, reconstructed3) {
     }
   }
   const rewrittenSeeds = /* @__PURE__ */ new Map();
-  for (const [memberId, seed] of staticValueSeeds) {
+  for (const [memberId, seed] of authoredValueSeeds) {
     const rewrittenId = rewrite(memberId);
     if (typeof rewrittenId !== "string") {
       throw new Error(
@@ -89840,7 +91486,7 @@ function assignPendingIds(changes, staticValueSeeds, reconstructed3) {
       reconstructed3.set(key, record3);
     }
   }
-  return { assigned, staticValueSeeds: rewrittenSeeds };
+  return { assigned, authoredValueSeeds: rewrittenSeeds };
 }
 function readAcceptedProjectVersionCommitResponse(value) {
   if (!isObjectRecord2(value) || value.kind !== "accepted") return null;
@@ -90310,7 +91956,7 @@ ${blockingErrors.map((error) => `  ${error.message}`).join("\n")}`
         type: "push-plan",
         dryRun: options.dryRun,
         changeCount: status.changes.length,
-        staticValueSeedCount: status.staticValueSeeds.size,
+        staticValueSeedCount: status.authoredValueSeeds.size,
         changes: status.changes.map((change) => ({
           kind: change.kind,
           recordKind: change.recordKind,
@@ -90335,9 +91981,9 @@ ${blockingErrors.map((error) => `  ${error.message}`).join("\n")}`
         }
       }
     }
-    if (status.staticValueSeeds.size > 0) {
+    if (status.authoredValueSeeds.size > 0) {
       console.log(
-        `  ${color.dim(`create ${status.staticValueSeeds.size} member value seed(s)`)}`
+        `  ${color.dim(`create ${status.authoredValueSeeds.size} member value seed(s)`)}`
       );
     }
   }
@@ -90403,7 +92049,7 @@ ${blockingErrors.map((error) => `  ${error.message}`).join("\n")}`
     {
       operation: transactionOperation,
       changes: transportChanges,
-      staticValueSeeds: transportSeeds,
+      authoredValueSeeds: transportSeeds,
       stagedFiles,
       sourceBundle: source.bundle,
       pendingIdAssignments: Object.fromEntries(pendingAssignment.assigned),
@@ -90617,11 +92263,11 @@ async function prepareLocalPushArtifactsV4(workspace, status) {
   const source = await createPendingProjectSourceBundleV4(
     workspace,
     status,
-    status.staticValueSeeds
+    status.authoredValueSeeds
   );
   const pendingAssignment = assignPendingIds(
     status.changes,
-    status.staticValueSeeds,
+    status.authoredValueSeeds,
     status.reconstructed
   );
   const operations = new Set(status.changes.map((change) => change.kind));
@@ -90635,7 +92281,7 @@ async function prepareLocalPushArtifactsV4(workspace, status) {
     intent: createNeoCliPushIntent(change),
     expectedBaseContentHash: change.kind === "create" ? null : change.casBaseHash ?? null
   }));
-  const transportSeeds = [...pendingAssignment.staticValueSeeds].map(
+  const transportSeeds = [...pendingAssignment.authoredValueSeeds].map(
     ([memberId, seed]) => ({ memberId, ...seed })
   );
   const preparedFiles = prepareProjectFilePushesV4({
@@ -90654,14 +92300,14 @@ async function prepareLocalPushArtifactsV4(workspace, status) {
     stateRecords: workspace.state.records,
     files: source.files,
     changes: transportChanges,
-    staticValueSeeds: transportSeeds,
+    authoredValueSeeds: transportSeeds,
     pendingIdAssignments: Object.fromEntries(pendingAssignment.assigned),
     stagedFiles: preparedFiles
   });
   assertServerPreparationSucceeds({
     workspace,
     changes: transportChanges,
-    staticValueSeeds: transportSeeds,
+    authoredValueSeeds: transportSeeds,
     sourceByRecord: status.reconstructed
   });
   return {
@@ -90725,7 +92371,7 @@ function cloneStatusForDryRun(status) {
   return {
     ...status,
     changes: structuredClone(status.changes),
-    staticValueSeeds: structuredClone(status.staticValueSeeds),
+    authoredValueSeeds: structuredClone(status.authoredValueSeeds),
     reconstructed: structuredClone(status.reconstructed)
   };
 }
@@ -90743,7 +92389,7 @@ function reportDryRunFailure(error, json) {
   }
   console.error(`Dry run failed: ${message}`);
 }
-async function createPendingProjectSourceBundleV4(workspace, status, staticValueSeeds) {
+async function createPendingProjectSourceBundleV4(workspace, status, authoredValueSeeds) {
   const records2 = /* @__PURE__ */ new Map();
   for (const [key, state] of Object.entries(workspace.state.records)) {
     records2.set(key, {
@@ -90783,7 +92429,7 @@ async function createPendingProjectSourceBundleV4(workspace, status, staticValue
     (record3) => record3.recordKind === "localization-config"
   );
   const mainLocale = isObjectRecord2(localizationConfig?.data) && typeof localizationConfig.data.mainLocale === "string" ? localizationConfig.data.mainLocale : "en-US";
-  for (const seed of staticValueSeeds.values()) {
+  for (const seed of authoredValueSeeds.values()) {
     for (const bindingMember of seed.bindingMembers ?? []) {
       records2.set(`member:${bindingMember.id}`, {
         recordKind: "member",