@neocompose/cli 0.79.1 → 0.80.0

package/dist/test-worker.mjs

@@ -2966,9 +2966,21 @@ function isNSTypeInfoInterface(value) {
   if (typeof v.interfaceId !== "string") return false;
   return v.interfaceId.length > 0;
 }
+function isClassGenericParamTypeInfo(value) {
+  return "ownerClassId" in value;
+}
 function isNSTypeInfoGenericParam(value) {
   if (!isNSTypeInfoBase(value)) return false;
   if (value.type !== 21 /* Generic */) return false;
+  if ("ownerMemberId" in value) {
+    if ("ownerClassId" in value) return false;
+    if ("genericParamId" in value) return false;
+    const v2 = value;
+    if (typeof v2.ownerMemberId !== "string") return false;
+    if (typeof v2.index !== "number") return false;
+    return Number.isInteger(v2.index) && v2.index >= 0;
+  }
+  if ("index" in value) return false;
   const v = value;
   if (typeof v.ownerClassId !== "string") return false;
   if (v.ownerClassId.length === 0) return false;
@@ -3116,6 +3128,86 @@ function hasValidParameterDefault(value) {
       return false;
   }
 }
+function isFunctionGenericParams(value, isValidName) {
+  if (!Array.isArray(value) || value.length === 0) return false;
+  const names = /* @__PURE__ */ new Set();
+  let defaulted = false;
+  for (const entry of value) {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry))
+      return false;
+    const v = entry;
+    for (const key of Object.keys(v)) {
+      if (key !== "name" && key !== "constraint" && key !== "defaultType")
+        return false;
+    }
+    if (!isValidName(v.name)) return false;
+    const name = v.name;
+    if (names.has(name)) return false;
+    names.add(name);
+    if (v.constraint !== void 0) {
+      const constraint = v.constraint;
+      if (!isNSTypeInfoClass(constraint) && !isNSTypeInfoEnum(constraint))
+        return false;
+      if (constraint.required !== true) return false;
+      if (typeInfoContainsFunctionGeneric(constraint, /* @__PURE__ */ new Set()))
+        return false;
+    }
+    if (v.defaultType === void 0) {
+      if (defaulted) return false;
+      continue;
+    }
+    defaulted = true;
+    if (!isNSTypeInfo(v.defaultType)) return false;
+    if (v.defaultType.required !== true) return false;
+    if (v.defaultType.type === NS_TYPE_UNKNOWN) return false;
+    if (typeInfoContainsGeneric(v.defaultType, /* @__PURE__ */ new Set())) return false;
+  }
+  return true;
+}
+function typeInfoContainsFunctionGeneric(value, ancestors) {
+  return typeInfoSome(
+    value,
+    (type) => type.type === 21 /* Generic */ && "ownerMemberId" in type,
+    ancestors
+  );
+}
+function typeInfoContainsGeneric(value, ancestors) {
+  return typeInfoSome(
+    value,
+    (type) => type.type === 21 /* Generic */,
+    ancestors
+  );
+}
+function typeInfoSome(value, predicate, ancestors) {
+  if (predicate(value)) return true;
+  if (ancestors.has(value)) return true;
+  ancestors.add(value);
+  try {
+    switch (value.type) {
+      case 6 /* List */:
+      case 28 /* Set */:
+      case 5 /* Dictionary */:
+      case 9 /* Lookup */:
+        return typeInfoSome(value.entryTypeInfo, predicate, ancestors);
+      case 25 /* NSDelegate */:
+        return value.returnTypeInfo.type !== NS_TYPE_VOID && typeInfoSome(value.returnTypeInfo, predicate, ancestors) || value.argumentTypes.some(
+          (argument2) => typeInfoSome(argument2, predicate, ancestors)
+        );
+      case 26 /* NSAction */:
+        return value.argumentTypes.some(
+          (argument2) => typeInfoSome(argument2, predicate, ancestors)
+        );
+      case 7 /* Class */:
+        return Object.values(value.typeArguments ?? {}).some(
+          (argument2) => typeInfoSome(argument2, predicate, ancestors)
+        );
+      default:
+        return false;
+    }
+  } finally {
+    ancestors.delete(value);
+  }
+}
 function typeInfoContainsUnknown(value, ancestors) {
   if (value.type === NS_TYPE_UNKNOWN) return true;
   if (ancestors.has(value)) return true;
@@ -3336,7 +3428,9 @@ function isNSPointerCallFunction(value) {
   if (v.missingMemberFallback === "valueEquality" && (!hasMemberKey || v.receiver?.kind !== "instance" || v.args.length !== 1)) {
     return false;
   }
-  return true;
+  if (v.typeArguments === void 0) return true;
+  if (!Array.isArray(v.typeArguments)) return false;
+  return v.typeArguments.every(isNSTypeInfo);
 }
 function isNSPointerObjectInitializer(value) {
   if (typeof value !== "object" || value === null) return false;
@@ -4135,6 +4229,9 @@ function typeInfosInvariantlyEqual(left, right) {
     return left.interfaceId === right.interfaceId;
   }
   if (left.type === 21 /* Generic */ && right.type === 21 /* Generic */) {
+    if ("index" in left || "index" in right) {
+      return "index" in left && "index" in right && left.index === right.index;
+    }
     return left.ownerClassId === right.ownerClassId && left.genericParamId === right.genericParamId;
   }
   if (left.type === 8 /* Enum */ && right.type === 8 /* Enum */) {
@@ -4767,6 +4864,7 @@ function isMemberFunctionBase(value) {
   if (!Array.isArray(v.argumentTypes)) return false;
   if (v.dispatch !== void 0 && v.dispatch !== 0 /* Synchronous */ && v.dispatch !== 1 /* Asynchronous */)
     return false;
+  if (!hasValidFunctionGenericParams(v)) return false;
   const names = /* @__PURE__ */ new Set();
   const argumentTypes = [];
   for (const arg of v.argumentTypes) {
@@ -4782,6 +4880,13 @@ function isMemberFunctionBase(value) {
     v.dispatch === 1 /* Asynchronous */
   );
 }
+function hasValidFunctionGenericParams(value) {
+  if (value.genericParams === void 0) return true;
+  return isFunctionGenericParams(
+    value.genericParams,
+    isValidSchemaBindingIdentifier
+  );
+}
 function hasValidParameterDefaults(argumentTypes, deferred) {
   if (deferred && hasAnyParameterDefault(argumentTypes)) return false;
   return validateParameterDefaults(argumentTypes).length === 0;
@@ -4835,6 +4940,7 @@ function isMemberNSFunctionBase(value) {
   if (v.action !== void 0 && v.action !== null) return false;
   if (v.bodyMode !== void 0 && v.bodyMode !== 0 /* Code */ && v.bodyMode !== 1 /* UI */)
     return false;
+  if (!hasValidFunctionGenericParams(v)) return false;
   const names = /* @__PURE__ */ new Set();
   const argumentTypes = [];
   for (const argument2 of v.argumentTypes) {
@@ -5108,6 +5214,13 @@ function hasValidEffectField(v) {
   if (!isFunctionEffectKind(v.effect)) return false;
   return v.kind === 13 /* Function */ || v.kind === 23 /* NSFunction */;
 }
+function hasValidOverrideGenericParams(v) {
+  if (v.genericParams === void 0) return true;
+  if (v.kind !== 13 /* Function */ && v.kind !== 23 /* NSFunction */) {
+    return false;
+  }
+  return hasValidFunctionGenericParams(v);
+}
 function hasValidDistributionField(v) {
   if (v.distribution === void 0) return true;
   if (!isNeoSubtreeDistributionKind(v.distribution)) return false;
@@ -5246,6 +5359,7 @@ function isMemberOverrideBase(value) {
   if (!hasValidStorageField(v, false)) return false;
   if (!hasValidDistributionField(v)) return false;
   if (!hasValidEffectField(v)) return false;
+  if (!hasValidOverrideGenericParams(v)) return false;
   if (v.defaultValue !== void 0 && v.defaultValue !== null && !isMemberValueBase(v.defaultValue)) {
     return false;
   }
@@ -7399,14 +7513,15 @@ var WORLD_SYSTEM_CLASS_DEFINITIONS = [
       {
         memberId: "system_f5ca386c-990c-54a1-8473-2d49d2cd887d",
         memberKind: "function",
-        docsText: "Objects at the cells around this placement, shifted by offset, in pattern order. Use GetObjects<T>(pattern, offset) to filter by class. A repeated footprint can appear more than once.",
+        docsText: "Objects of type T at the cells around this placement, shifted by offset, in pattern order. A repeated footprint can appear more than once.",
         returnTypeInfo: {
           type: 6,
           required: true,
           entryTypeInfo: {
-            type: 7,
+            type: 21,
             required: true,
-            classId: "system_f671535d-0eb6-4139-9caf-5c5276febd31"
+            ownerMemberId: "system_f5ca386c-990c-54a1-8473-2d49d2cd887d",
+            index: 0
           }
         },
         argumentTypes: [
@@ -7423,17 +7538,33 @@ var WORLD_SYSTEM_CLASS_DEFINITIONS = [
             defaultValue: { value: null }
           }
         ],
+        genericParams: [
+          {
+            name: "T",
+            constraint: {
+              type: 7,
+              required: true,
+              classId: "system_f671535d-0eb6-4139-9caf-5c5276febd31"
+            },
+            defaultType: {
+              type: 7,
+              required: true,
+              classId: "system_f671535d-0eb6-4139-9caf-5c5276febd31"
+            }
+          }
+        ],
         dispatch: 0 /* Synchronous */,
         schemaKey: "GetObjects"
       },
       {
         memberId: "system_593e6208-e2ca-505e-9933-04b17102b6d2",
         memberKind: "function",
-        docsText: "The first tile found in pattern order around this placement, shifted by offset, or null. Each cell uses the grid layer precedence.",
+        docsText: "The first tile of type T found in pattern order around this placement, shifted by offset, or null. Each cell uses the grid layer precedence.",
         returnTypeInfo: {
-          type: 7,
+          type: 21,
           required: false,
-          classId: "system_d7fa161b-b269-4bf1-9ec9-3aebec67e6e0"
+          ownerMemberId: "system_593e6208-e2ca-505e-9933-04b17102b6d2",
+          index: 0
         },
         argumentTypes: [
           {
@@ -7449,20 +7580,36 @@ var WORLD_SYSTEM_CLASS_DEFINITIONS = [
             defaultValue: { value: null }
           }
         ],
+        genericParams: [
+          {
+            name: "T",
+            constraint: {
+              type: 7,
+              required: true,
+              classId: "system_d7fa161b-b269-4bf1-9ec9-3aebec67e6e0"
+            },
+            defaultType: {
+              type: 7,
+              required: true,
+              classId: "system_d7fa161b-b269-4bf1-9ec9-3aebec67e6e0"
+            }
+          }
+        ],
         dispatch: 0 /* Synchronous */,
         schemaKey: "GetTile"
       },
       {
         memberId: "system_5a41d36a-bcd9-4867-9e46-d743f6e09582",
         memberKind: "function",
-        docsText: "The tiles at the cells around this placement, shifted by offset, in pattern order. Each cell uses the grid layer precedence and empty cells are skipped.",
+        docsText: "The tiles of type T at the cells around this placement, shifted by offset, in pattern order. Each cell uses the grid layer precedence and empty cells are skipped.",
         returnTypeInfo: {
           type: 6,
           required: true,
           entryTypeInfo: {
-            type: 7,
+            type: 21,
             required: true,
-            classId: "system_d7fa161b-b269-4bf1-9ec9-3aebec67e6e0"
+            ownerMemberId: "system_5a41d36a-bcd9-4867-9e46-d743f6e09582",
+            index: 0
           }
         },
         argumentTypes: [
@@ -7479,6 +7626,21 @@ var WORLD_SYSTEM_CLASS_DEFINITIONS = [
             defaultValue: { value: null }
           }
         ],
+        genericParams: [
+          {
+            name: "T",
+            constraint: {
+              type: 7,
+              required: true,
+              classId: "system_d7fa161b-b269-4bf1-9ec9-3aebec67e6e0"
+            },
+            defaultType: {
+              type: 7,
+              required: true,
+              classId: "system_d7fa161b-b269-4bf1-9ec9-3aebec67e6e0"
+            }
+          }
+        ],
         dispatch: 0 /* Synchronous */,
         schemaKey: "GetTiles"
       }
@@ -9111,7 +9273,8 @@ function callableBindingMember(memberId, slotName, members) {
   return binding;
 }
 function mapGenericTypeInfo(typeInfo, close) {
-  if (typeInfo.type === 21 /* Generic */) return close(typeInfo);
+  if (typeInfo.type === 21 /* Generic */)
+    return isClassGenericParamTypeInfo(typeInfo) ? close(typeInfo) : typeInfo;
   if (typeInfo.type === 6 /* List */ || typeInfo.type === 28 /* Set */ || typeInfo.type === 5 /* Dictionary */ || typeInfo.type === 9 /* Lookup */) {
     return {
       ...typeInfo,
@@ -12507,6 +12670,14 @@ function validateAudioMemberValue(document2, member, body) {
   }
 }
 
+// ../packages/models/src/members/list-index-values.ts
+function normalizeListIndexKey(value, kind) {
+  if (kind === "enum") {
+    return Array.isArray(value) && typeof value[0] === "string" ? value[0] : null;
+  }
+  return typeof value === "string" ? value : null;
+}
+
 // ../packages/models/src/members/list-indexes.ts
 function validateListIndexDefinitions(ctx, listMember) {
   const errors = [];
@@ -13030,6 +13201,109 @@ function classImplementsInterface(classId, interfaceId, classes, interfaces) {
   );
 }
 
+// ../packages/models/src/neoscript/function-type-arguments.ts
+function functionGenericParamsOf(member) {
+  const kind = getField(member, "kind");
+  if (kind !== 13 /* Function */ && kind !== 23 /* NSFunction */) {
+    return void 0;
+  }
+  const params = getField(member, "genericParams");
+  return isFunctionGenericParams(params, isValidSchemaBindingIdentifier) ? params : void 0;
+}
+function firstFunctionGenericReference(typeInfo, matches) {
+  switch (typeInfo.type) {
+    case 21 /* Generic */:
+      if (isClassGenericParamTypeInfo(typeInfo)) return null;
+      return matches(typeInfo) ? typeInfo : null;
+    case 6 /* List */:
+    case 28 /* Set */:
+    case 5 /* Dictionary */:
+    case 9 /* Lookup */:
+      return firstFunctionGenericReference(typeInfo.entryTypeInfo, matches);
+    case 25 /* NSDelegate */:
+      return firstInList(
+        [typeInfo.returnTypeInfo, ...typeInfo.argumentTypes],
+        matches
+      );
+    case 26 /* NSAction */:
+      return firstInList(typeInfo.argumentTypes, matches);
+    case 7 /* Class */:
+      return firstInList(Object.values(typeInfo.typeArguments ?? {}), matches);
+    default:
+      return null;
+  }
+}
+function firstInList(list, matches) {
+  for (const entry of list) {
+    const found = firstFunctionGenericReference(entry, matches);
+    if (found !== null) return found;
+  }
+  return null;
+}
+function typeInfoHasFunctionGeneric(typeInfo) {
+  return firstFunctionGenericReference(typeInfo, () => true) !== null;
+}
+function bindFunctionTypeArguments(typeInfo, table) {
+  switch (typeInfo.type) {
+    case 21 /* Generic */: {
+      if (isClassGenericParamTypeInfo(typeInfo)) return typeInfo;
+      const bound = table[typeInfo.index];
+      if (bound === void 0) return typeInfo;
+      return { ...bound, required: bound.required && typeInfo.required };
+    }
+    case 6 /* List */:
+    case 28 /* Set */:
+    case 5 /* Dictionary */:
+    case 9 /* Lookup */: {
+      const entry = bindFunctionTypeArguments(typeInfo.entryTypeInfo, table);
+      return entry === typeInfo.entryTypeInfo ? typeInfo : { ...typeInfo, entryTypeInfo: entry };
+    }
+    case 25 /* NSDelegate */: {
+      const returnTypeInfo = bindFunctionTypeArguments(
+        typeInfo.returnTypeInfo,
+        table
+      );
+      const argumentTypes = bindTypeInfoList(typeInfo.argumentTypes, table);
+      return returnTypeInfo === typeInfo.returnTypeInfo && argumentTypes === typeInfo.argumentTypes ? typeInfo : { ...typeInfo, returnTypeInfo, argumentTypes };
+    }
+    case 26 /* NSAction */: {
+      const argumentTypes = bindTypeInfoList(typeInfo.argumentTypes, table);
+      return argumentTypes === typeInfo.argumentTypes ? typeInfo : { ...typeInfo, argumentTypes };
+    }
+    case 7 /* Class */: {
+      if (!typeInfo.typeArguments) return typeInfo;
+      let typeArguments;
+      for (const [key, argument2] of Object.entries(typeInfo.typeArguments)) {
+        const bound = bindFunctionTypeArguments(argument2, table);
+        if (bound === argument2) continue;
+        typeArguments ??= { ...typeInfo.typeArguments };
+        typeArguments[key] = bound;
+      }
+      return typeArguments === void 0 ? typeInfo : { ...typeInfo, typeArguments };
+    }
+    default:
+      return typeInfo;
+  }
+}
+function bindArgumentTypeArguments(argument2, table) {
+  const bound = bindFunctionTypeArguments(argument2, table);
+  if (bound === argument2) return argument2;
+  if (argument2.defaultValue === void 0) {
+    return { ...bound, name: argument2.name };
+  }
+  return { ...bound, name: argument2.name, defaultValue: { value: null } };
+}
+function bindTypeInfoList(list, table) {
+  let bound;
+  for (let index = 0; index < list.length; index++) {
+    const entry = bindFunctionTypeArguments(list[index], table);
+    if (entry === list[index]) continue;
+    bound ??= [...list];
+    bound[index] = entry;
+  }
+  return bound ?? list;
+}
+
 // ../packages/manifest/src/value-comparison.ts
 function isObjectRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -13326,6 +13600,9 @@ import { createHash as createHash2, randomUUID } from "node:crypto";
 import { isDeepStrictEqual } from "node:util";
 
 // ../packages/neoscript-language/src/project.ts
+function functionTypeParameterId(memberId, index) {
+  return `${memberId}#${index}`;
+}
 function neoScriptMemberLookupType(type) {
   if (type.kind !== "typeParameter") return type;
   const visited = /* @__PURE__ */ new Set();
@@ -14102,6 +14379,61 @@ var UncompiledInitializerRuntimeError = class extends NSGetterRuntimeError {
   valueId;
 };
 
+// ../packages/neoscript-runtime/src/neoscript/runtime-set.ts
+var RuntimeSet = class {
+  constructor(source, reference, enumEntries) {
+    this.source = source;
+    this.reference = reference;
+    this.enumEntries = enumEntries;
+  }
+  source;
+  reference;
+  enumEntries;
+  entries = /* @__PURE__ */ new Map();
+  validations = /* @__PURE__ */ new Map();
+  snapshot;
+  get size() {
+    return this.entries.size;
+  }
+  has(key) {
+    return this.entries.has(key);
+  }
+  add(key, raw, reference) {
+    if (this.entries.has(key)) return;
+    this.entries.set(key, { raw, reference });
+    for (const check2 of this.validations.values())
+      if (!check2.test(raw)) check2.invalid.add(key);
+    this.snapshot = void 0;
+  }
+  remove(key) {
+    if (this.entries.delete(key)) {
+      this.snapshot = void 0;
+      for (const check2 of this.validations.values()) check2.invalid.delete(key);
+    }
+  }
+  clear() {
+    this.entries.clear();
+    for (const check2 of this.validations.values()) check2.invalid.clear();
+    this.snapshot = void 0;
+  }
+  matches(type, test) {
+    let check2 = this.validations.get(type);
+    if (check2 === void 0) {
+      check2 = { test, invalid: /* @__PURE__ */ new Set() };
+      for (const [key, entry] of this.entries)
+        if (!test(entry.raw)) check2.invalid.add(key);
+      this.validations.set(type, check2);
+    }
+    return check2.invalid.size === 0;
+  }
+  membership() {
+    return this.snapshot ??= [...this.entries.values()];
+  }
+  toArray() {
+    return this.membership().map((entry) => entry.raw);
+  }
+};
+
 // ../packages/neoscript-runtime/src/listener-write-index.ts
 var indexes = /* @__PURE__ */ new WeakMap();
 var empty = /* @__PURE__ */ new Map();
@@ -14756,6 +15088,10 @@ var NEO_CELL_PATTERN_PURE_NATIVE_MEMBER_IDS = /* @__PURE__ */ new Set([
 ]);
 var NEO_OBJECT_CLASS_ID = "system_f671535d-0eb6-4139-9caf-5c5276febd31";
 
+// ../packages/neoscript-language/src/tile-conversion.ts
+var NEO_TILE_CONVERT_MEMBER_ID = "system_54ecc5a7-874d-54ed-92f4-38100a4b7465";
+var NEO_TILE_CLASS_ID = "system_d7fa161b-b269-4bf1-9ec9-3aebec67e6e0";
+
 // ../packages/neoscript-runtime/src/neoscript/cell-pattern.ts
 function integer(value, name) {
   if (typeof value !== "number" || !Number.isInteger(value)) {
@@ -15671,8 +16007,11 @@ var WorldGridQueryIndex = class {
       );
     return matches[0];
   }
-  /** `shift` moves the whole pattern; null queries around the placement cell. */
-  objects(placement, offsets, reads, shift = null) {
+  /**
+   * `shift` moves the whole pattern; null queries around the placement cell.
+   * `accepts` (P110 §6) keeps only objects of a class; every cell is still read.
+   */
+  objects(placement, offsets, reads, shift = null, accepts) {
     reads?.add({ kind: "placement", valueId: placement.valueId });
     const origin = shiftedOrigin(placement, shift);
     const result = [];
@@ -15680,24 +16019,34 @@ var WorldGridQueryIndex = class {
       const cell = translated2(origin, offset);
       reads?.add({ kind: "objects", gridId: placement.gridId, cell });
       for (const item of this.objectsAt(placement.gridId, cell)) {
-        result.push(item.valueId);
+        if (accepts === void 0 || accepts(item.classId)) {
+          result.push(item.valueId);
+        }
       }
     }
     return result;
   }
-  tile(placement, offsets, reads, shift = null) {
+  /** The first cell's winner that `accepts` keeps, in pattern order. */
+  tile(placement, offsets, reads, shift = null, accepts) {
     reads?.add({ kind: "placement", valueId: placement.valueId });
     const origin = shiftedOrigin(placement, shift);
     let result = null;
     for (const offset of offsets) {
       const cell = translated2(origin, offset);
       reads?.add({ kind: "tile", gridId: placement.gridId, cell });
-      result ??= this.tileAt(placement.gridId, cell);
+      if (result !== null) continue;
+      const tile = this.tileAt(placement.gridId, cell);
+      if (tile !== null && (accepts === void 0 || accepts(tile.classId))) {
+        result = tile;
+      }
     }
     return result;
   }
-  /** One tile per occupied pattern cell, in pattern order. */
-  tiles(placement, offsets, reads, shift = null) {
+  /**
+   * One tile per occupied pattern cell, in pattern order. `accepts` filters
+   * each cell's winner; it never looks under a winner.
+   */
+  tiles(placement, offsets, reads, shift = null, accepts) {
     reads?.add({ kind: "placement", valueId: placement.valueId });
     const origin = shiftedOrigin(placement, shift);
     const result = [];
@@ -15705,7 +16054,9 @@ var WorldGridQueryIndex = class {
       const cell = translated2(origin, offset);
       reads?.add({ kind: "tile", gridId: placement.gridId, cell });
       const tile = this.tileAt(placement.gridId, cell);
-      if (tile !== null) result.push(tile.placementValueId);
+      if (tile !== null && (accepts === void 0 || accepts(tile.classId))) {
+        result.push(tile.placementValueId);
+      }
     }
     return result;
   }
@@ -16584,6 +16935,9 @@ var NeoScriptScope = class {
 // ../packages/neoscript-runtime/src/neoscript/evaluateNSGetter.ts
 var DELEGATE_LEXICAL_THIS = /* @__PURE__ */ Symbol("neoDelegateLexicalThis");
 var DELEGATE_LEXICAL_ROOT = /* @__PURE__ */ Symbol("neoDelegateLexicalRoot");
+var DELEGATE_LEXICAL_TYPE_ARGUMENTS = /* @__PURE__ */ Symbol(
+  "neoDelegateLexicalTypeArguments"
+);
 var NonCatchableNSGetterRuntimeError = class extends NSGetterRuntimeError {
 };
 var NativeFunctionDelegateUnavailableError = class extends NonCatchableNSGetterRuntimeError {
@@ -17309,6 +17663,7 @@ function forgetLocalListIndexes(ctx, list) {
   ctx.__indexes?.declaredListByArray.delete(list);
 }
 function trackedRowForValueReference(value, ctx) {
+  if (value instanceof RuntimeSet) value = value.source;
   if (typeof value !== "object" || value === null) return null;
   const indexes3 = evaluatorIndexes(ctx);
   const indexed = indexes3.rowByValueReference.get(value) ?? indexes3.baseRowByValueReference?.get(value) ?? ctx.vm.databaseVM?.rowForValueReference?.(value) ?? null;
@@ -17708,6 +18063,10 @@ function evaluateNSGetterWithEffects(getter, ctx, argumentValues = [], options =
       if (getter.typeInfo.type === 20 /* Decimal */ && typeof result.value === "number") {
         result.value = coerceDecimalOperand(result.value, "return");
       }
+      if (ownsInvocationState) {
+        flushRuntimeSets(runtimeCtx);
+        result.value = exportRuntimeSetValue(result.value, runtimeCtx);
+      }
       const initializerResult = options.initializerResult;
       if (initializerResult !== void 0 && result.value !== null && isMemberWithEntries(initializerResult.member) && findKnownRowIdByValueReference(result.value, runtimeCtx) === null) {
         const createdValues = createdSessionValuesSince(runtimeCtx, creationCheckpoint);
@@ -17824,6 +18183,10 @@ function evaluateNSFunction(action, ctx, args) {
       runtimeArgs,
       action.typeInfo.type === 0 /* Null */
     );
+    if (ownsInvocationState) {
+      flushRuntimeSets(runtimeCtx);
+      value = exportRuntimeSetValue(value, runtimeCtx);
+    }
     exported = prepareSessionValueExport(
       runtimeCtx,
       creationCheckpoint,
@@ -17860,10 +18223,18 @@ function evaluateNSFunction(action, ctx, args) {
 }
 function evaluateNSDelegate(value, ctx, args = []) {
   const runtimeCtx = withEvaluationRuntime(ctx, []);
-  return preserveReadOnlyReturnIdentity(
-    invokeDelegateValue(value, args, runtimeCtx),
-    runtimeCtx
-  );
+  try {
+    const result = preserveReadOnlyReturnIdentity(
+      invokeDelegateValue(value, args, runtimeCtx),
+      runtimeCtx
+    );
+    if (ctx.__executionState !== void 0) return result;
+    flushRuntimeSets(runtimeCtx);
+    return exportRuntimeSetValue(result, runtimeCtx);
+  } finally {
+    if (ctx.__executionState === void 0)
+      runtimeCtx.__dirtyRuntimeSets?.clear();
+  }
 }
 function bindNeoScriptDelegateToContext(value, ctx) {
   if (!isNSDelegateClosureValue(value)) return value;
@@ -17891,6 +18262,8 @@ function withEvaluationRuntime(ctx, writes) {
   if (ctx.__runtimeSessionValues !== void 0 && ctx.__executionState !== void 0 && ctx.__valueOverlay !== void 0) {
     ctx.__unorderedListProjections ??= createUnorderedListProjectionCache();
     ctx.__setEntryIndexes ??= /* @__PURE__ */ new WeakMap();
+    ctx.__runtimeSets ??= /* @__PURE__ */ new WeakMap();
+    ctx.__dirtyRuntimeSets ??= /* @__PURE__ */ new Set();
     ctx.__runtimeClassOverrides ??= /* @__PURE__ */ new Map();
     ctx.__getterSubscriptions ??= getterSubscriptionsFor(ctx);
     return ctx;
@@ -17925,6 +18298,8 @@ function withEvaluationRuntime(ctx, writes) {
     __valueOverlay: overlay,
     __unorderedListProjections: ctx.__unorderedListProjections ?? createUnorderedListProjectionCache(),
     __setEntryIndexes: ctx.__setEntryIndexes ?? /* @__PURE__ */ new WeakMap(),
+    __runtimeSets: ctx.__runtimeSets ?? /* @__PURE__ */ new WeakMap(),
+    __dirtyRuntimeSets: ctx.__dirtyRuntimeSets ?? /* @__PURE__ */ new Set(),
     __runtimeReferenceRemap: referenceRemap,
     __executionState: ctx.__executionState ?? {
       writes,
@@ -18023,6 +18398,7 @@ function cleanupRowDatabase(ctx, session, groupByRowId) {
 }
 function finalizeConstructorAllocations(ctx, returnValue, ownsInvocationState, returnTypeInfo, retainListenerReceivers = true) {
   if (!ownsInvocationState) return;
+  ctx.__dirtyRuntimeSets?.clear();
   const state = ctx.__executionState;
   const session = ctx.__runtimeSessionValues;
   if (state === void 0 || session === void 0) return;
@@ -18555,7 +18931,7 @@ function executeCompiledFunction(action, ctx, args, allowFallthroughReturn, runt
   for (let index = 0; index < filledArgs.length; index += 1) {
     const parameter3 = action.parameters[index + 2];
     const runtimeTypeInfo = runtimeArgumentTypes[index];
-    const value2 = filledArgs[index];
+    const value2 = asDeclaredRuntimeSet(filledArgs[index], runtimeTypeInfo, ctx);
     if (!runtimeValueMatchesType(value2, runtimeTypeInfo, ctx)) {
       throw new NSGetterRuntimeError(
         `NSFunction argument ${index + 1} does not match its declared runtime type.`
@@ -18933,6 +19309,7 @@ function evalInstructions(instructions, scope, ctx, options) {
           if (ins.variable.typeInfo.type === 20 /* Decimal */ && typeof value === "number") {
             value = coerceDecimalOperand(value, "variable initialization");
           }
+          value = asDeclaredRuntimeSet(value, ins.variable.typeInfo, ctx);
           scope.setLocal(ins.variable.id, value);
           break;
         }
@@ -20134,7 +20511,7 @@ function evalCollectionMutationInstruction(ins, scope, ctx, options) {
     }
     writableStaticBindingMap(member, ctx);
   }
-  const targetValue = evalPointer(ins.target.pointer, scope, ctx);
+  let targetValue = evalPointer(ins.target.pointer, scope, ctx);
   const variablePointer = ins.target.pointer.type === "variable" /* variable */ ? ins.target.pointer : null;
   const unorderedContainerValueId = unorderedListProjectionContainerId(
     targetValue,
@@ -20157,6 +20534,14 @@ function evalCollectionMutationInstruction(ins, scope, ctx, options) {
   const args = ins.args.map((arg) => evalPointer(arg, scope, ctx));
   const setEntryMember = mutatesLocalVariable ? null : storedSetEntryMember(targetValue, ctx);
   const isLookupSet = setEntryMember === null && ins.target.typeInfo.type === 9 /* Lookup */;
+  if (isLookupSet && Array.isArray(targetValue)) {
+    targetValue = runtimeSet(
+      targetValue,
+      ins.reference === true,
+      ins.target.typeInfo.type === 9 /* Lookup */ && (ins.target.typeInfo.entryTypeInfo.type === 8 /* Enum */ || ins.target.typeInfo.entryTypeInfo.type === 18 /* DialogueLookup */),
+      ctx
+    );
+  }
   const setMatch = setEntryMember !== null && Array.isArray(targetValue) && (ins.mutation === "Add" /* Add */ || ins.mutation === "Remove" /* Remove */) ? findStoredSetEntry(targetValue, args[0], setEntryMember, ctx) : null;
   if (ins.mutation === "Add" /* Add */ && setMatch !== null) return;
   if (ins.mutation === "Remove" /* Remove */ && setEntryMember !== null && setMatch === null) {
@@ -20187,7 +20572,7 @@ function evalCollectionMutationInstruction(ins, scope, ctx, options) {
   }
   validateCollectionMutation(targetValue, ins.mutation, args);
   const overlayArgs = [...args];
-  if ((ins.mutation === "Add" /* Add */ || ins.mutation === "Remove" /* Remove */) && Array.isArray(targetValue)) {
+  if ((ins.mutation === "Add" /* Add */ || ins.mutation === "Remove" /* Remove */) && isArrayCollection(targetValue)) {
     if (setMatch !== null) overlayArgs[0] = setMatch.entry;
     else if (isLookupSet)
       overlayArgs[0] = lookupSetSelectionValue(
@@ -20199,10 +20584,10 @@ function evalCollectionMutationInstruction(ins, scope, ctx, options) {
       overlayArgs[0] = findKnownRowIdByValueReference(args[0], ctx) ?? args[0];
   } else if (ins.mutation === "Insert" /* Insert */) {
     overlayArgs[1] = findKnownRowIdByValueReference(args[1], ctx) ?? args[1];
-  } else if (ins.mutation === "Add" /* Add */ && !Array.isArray(targetValue)) {
+  } else if (ins.mutation === "Add" /* Add */ && !isArrayCollection(targetValue)) {
     overlayArgs[1] = findKnownRowIdByValueReference(args[1], ctx) ?? args[1];
   }
-  if (ins.mutation === "Add" /* Add */ && Array.isArray(targetValue) && unorderedContainerValueId !== null && !isLookupSet && findKnownRowIdByValueReference(args[0], ctx) === null) {
+  if (ins.mutation === "Add" /* Add */ && isArrayCollection(targetValue) && unorderedContainerValueId !== null && !isLookupSet && findKnownRowIdByValueReference(args[0], ctx) === null) {
     overlayArgs[0] = createUnorderedScalarProjectionEntry(
       unorderedContainerValueId,
       args[0],
@@ -20211,7 +20596,7 @@ function evalCollectionMutationInstruction(ins, scope, ctx, options) {
   }
   const unorderedEntriesBeforeMutation = unorderedContainerValueId === null || !Array.isArray(targetValue) || ins.mutation === "Add" /* Add */ ? null : [...targetValue];
   if ((ins.mutation === "Add" /* Add */ || ins.mutation === "Insert" /* Insert */) && !isLookupSet) {
-    const attachedValue = Array.isArray(targetValue) && ins.mutation !== "Insert" /* Insert */ ? args[0] : args[1];
+    const attachedValue = isArrayCollection(targetValue) && ins.mutation !== "Insert" /* Insert */ ? args[0] : args[1];
     const attachedValueId = findKnownRowIdByValueReference(attachedValue, ctx);
     const parentId = findKnownRowIdByValueReference(targetValue, ctx);
     if (attachedValueId !== null && parentId !== null) {
@@ -20220,8 +20605,8 @@ function evalCollectionMutationInstruction(ins, scope, ctx, options) {
         unorderedContainerValueId ?? void 0
       );
       let slot = `slot:${String(args[0])}`;
-      if (Array.isArray(targetValue)) {
-        const insertionIndex = ins.mutation === "Insert" /* Insert */ ? args[0] : targetValue.length;
+      if (isArrayCollection(targetValue)) {
+        const insertionIndex = ins.mutation === "Insert" /* Insert */ ? args[0] : collectionLength(targetValue);
         slot = `index:${insertionIndex}`;
       }
       assertOwnedValueAttachable(
@@ -20240,7 +20625,7 @@ function evalCollectionMutationInstruction(ins, scope, ctx, options) {
     overlayArgs,
     ctx,
     isLookupSet,
-    ins.reference !== true && ins.mutation === "Remove" /* Remove */ && Array.isArray(targetValue) && unorderedContainerValueId !== null && !isLookupSet && findKnownRowIdByValueReference(args[0], ctx) === null,
+    ins.reference !== true && ins.mutation === "Remove" /* Remove */ && isArrayCollection(targetValue) && setEntryMember === null && !isLookupSet && findKnownRowIdByValueReference(args[0], ctx) === null,
     ins.reference === true
   );
   updateCollectionReferenceProvenance(
@@ -20278,7 +20663,7 @@ function evalCollectionMutationInstruction(ins, scope, ctx, options) {
       });
       return;
     case "Add" /* Add */:
-      if (Array.isArray(targetValue)) {
+      if (isArrayCollection(targetValue)) {
         options.writes.push({
           kind: "add",
           target: ins.target,
@@ -20300,7 +20685,7 @@ function evalCollectionMutationInstruction(ins, scope, ctx, options) {
       });
       return;
     case "Remove" /* Remove */:
-      if (Array.isArray(targetValue)) {
+      if (isArrayCollection(targetValue)) {
         options.writes.push({
           kind: "remove",
           target: ins.target,
@@ -20366,6 +20751,101 @@ function storedSetEntryMember(collection, ctx) {
     ctx.vm.members
   );
 }
+function flushRuntimeSets(ctx) {
+  for (const set of ctx.__dirtyRuntimeSets ?? [])
+    exportRuntimeSetValue(set, ctx);
+  ctx.__dirtyRuntimeSets?.clear();
+  for (const write of ctx.__executionState?.writes ?? []) {
+    if ("value" in write) write.value = exportRuntimeSetValue(write.value, ctx);
+  }
+}
+function exportRuntimeSetValue(value, ctx, seen = /* @__PURE__ */ new Map()) {
+  if (typeof value !== "object" || value === null) return value;
+  if (seen.has(value)) return seen.get(value);
+  if (value instanceof RuntimeSet) {
+    seen.set(value, value.source);
+    const entries = value.membership();
+    value.source.length = entries.length;
+    const references = /* @__PURE__ */ new Set();
+    for (let index = 0; index < entries.length; index++) {
+      value.source[index] = exportRuntimeSetValue(
+        entries[index].raw,
+        ctx,
+        seen
+      );
+      if (entries[index].reference) references.add(index);
+    }
+    unorderedListProjectionCache(ctx).referenceEntryIndexesByArray.set(
+      value.source,
+      references
+    );
+    ctx.__dirtyRuntimeSets?.delete(value);
+    return value.source;
+  }
+  if (Array.isArray(value)) {
+    const copy = [];
+    seen.set(value, copy);
+    let changed = false;
+    for (const entry of value) {
+      const exported = exportRuntimeSetValue(entry, ctx, seen);
+      copy.push(exported);
+      changed ||= exported !== entry;
+    }
+    const result = changed ? copy : value;
+    seen.set(value, result);
+    return result;
+  }
+  if (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null) {
+    const copy = {};
+    seen.set(value, copy);
+    let changed = false;
+    for (const [key, entry] of Object.entries(value)) {
+      const exported = exportRuntimeSetValue(entry, ctx, seen);
+      setOwnField(copy, key, exported);
+      changed ||= exported !== entry;
+    }
+    const result = changed ? copy : value;
+    seen.set(value, result);
+    return result;
+  }
+  return value;
+}
+function isArrayCollection(value) {
+  return Array.isArray(value) || value instanceof RuntimeSet;
+}
+function asDeclaredRuntimeSet(value, type, ctx) {
+  if (type.type !== 9 /* Lookup */ || !Array.isArray(value) || storedSetEntryMember(value, ctx) !== null)
+    return value;
+  const entry = type.entryTypeInfo.type;
+  return runtimeSet(
+    value,
+    entry === 7 /* Class */ || entry === 22 /* Interface */ || entry === 6 /* List */ || entry === 5 /* Dictionary */ || entry === 9 /* Lookup */,
+    entry === 8 /* Enum */ || entry === 18 /* DialogueLookup */,
+    ctx
+  );
+}
+function runtimeSetKey(value, set, ctx) {
+  if (set.enumEntries && Array.isArray(value) && value.length === 1)
+    value = value[0];
+  return toSetEntryKey(value, null, set.reference, ctx);
+}
+function runtimeSet(array2, reference, enumEntries, ctx) {
+  const sets = ctx.__runtimeSets ??= /* @__PURE__ */ new WeakMap();
+  ctx.__dirtyRuntimeSets ??= /* @__PURE__ */ new Set();
+  const existing = sets.get(array2);
+  if (existing !== void 0) return existing;
+  const set = new RuntimeSet(array2, reference, enumEntries);
+  for (let index = 0; index < array2.length; index++) {
+    const raw = array2[index];
+    const resolves = collectionEntryUsesReferenceResolution(array2, index, ctx);
+    const value = resolves ? resolveValueIfId(raw, ctx) : raw;
+    const key = runtimeSetKey(value, set, ctx);
+    set.add(key, enumEntries ? key : raw, !enumEntries && resolves);
+  }
+  sets.set(array2, set);
+  (ctx.__dirtyRuntimeSets ??= /* @__PURE__ */ new Set()).add(set);
+  return set;
+}
 function storedSetEntryMatch(raw, entryMember, ctx) {
   const byIdentity = entryMember.kind === 7 /* Class */;
   const row = byIdentity || typeof raw !== "string" ? null : evalValueById(ctx, raw, ctx.__runtimeSessionValues, ctx.__valueOverlay);
@@ -20407,7 +20887,29 @@ function findStoredSetEntry(set, value, entryMember, ctx) {
   if (key === null) return null;
   return storedSetEntries(set, entryMember, ctx).get(key) ?? null;
 }
-function applyLocalCollectionMutation(targetValue, mutation, args, ctx, unique = false, resolveJoinedRemovalEntries = false, reference = false) {
+function applyLocalCollectionMutation(targetValue, mutation, args, ctx, unique = false, resolveRemovalEntries = false, reference = false) {
+  if (targetValue instanceof RuntimeSet) {
+    (ctx.__dirtyRuntimeSets ??= /* @__PURE__ */ new Set()).add(targetValue);
+    switch (mutation) {
+      case "Add" /* Add */:
+        targetValue.add(
+          runtimeSetKey(args[0], targetValue, ctx),
+          args[0],
+          targetValue.reference
+        );
+        return null;
+      case "Remove" /* Remove */:
+        targetValue.remove(runtimeSetKey(args[0], targetValue, ctx));
+        return null;
+      case "Clear" /* Clear */:
+        targetValue.clear();
+        return null;
+      default:
+        throw new NSGetterRuntimeError(
+          "Set only supports Add, Remove, and Clear."
+        );
+    }
+  }
   validateCollectionMutation(targetValue, mutation, args);
   switch (mutation) {
     case "Insert" /* Insert */: {
@@ -20448,7 +20950,7 @@ function applyLocalCollectionMutation(targetValue, mutation, args, ctx, unique =
           }
           const referenceEntry = ctx.__unorderedListProjections?.referenceEntryIndexesByArray.get(targetValue)?.has(candidate) === true;
           if (jsEqual(
-            resolveJoinedRemovalEntries || referenceEntry ? resolveValueIfId(entry, ctx) : entry,
+            resolveRemovalEntries || referenceEntry ? resolveCollectionEntry(targetValue, entry, candidate, ctx) : entry,
             args[0]
           )) {
             index = candidate;
@@ -20518,6 +21020,7 @@ function lookupSetSelectionValue(value, typeInfo, ctx) {
   return findKnownRowIdByValueReference(value, ctx) ?? value;
 }
 function validateCollectionMutation(targetValue, mutation, args) {
+  if (targetValue instanceof RuntimeSet) return;
   if (mutation === "Insert" /* Insert */) {
     const list = listArg(targetValue, "Insert target");
     const index = numberArg(args[0], "Insert index");
@@ -20566,6 +21069,7 @@ function listIndexError(index, length) {
   return `List index out of bounds: ${String(index)}; list length is ${length}. Use an index from 0 to ${length - 1}.`;
 }
 function listArg(value, name) {
+  if (value instanceof RuntimeSet) return value.toArray();
   if (Array.isArray(value)) return value;
   throw new NSGetterRuntimeError(`${name} must be a list`);
 }
@@ -20667,7 +21171,8 @@ function evalStaticMember(memberId, ctx) {
 }
 function evalPointer(pointer, scope, ctx, resultUsage = "value") {
   try {
-    return pointer.source ? evalPointerAtSource(pointer, scope, ctx, resultUsage) : evalPointerCore(pointer, scope, ctx, resultUsage);
+    const value = pointer.source ? evalPointerAtSource(pointer, scope, ctx, resultUsage) : evalPointerCore(pointer, scope, ctx, resultUsage);
+    return Array.isArray(value) ? ctx.__runtimeSets?.get(value) ?? value : value;
   } catch (error) {
     if (error instanceof NSGetterRuntimeError) {
       error.at(pointer);
@@ -20702,7 +21207,10 @@ function evalPointerCore(pointer, scope, ctx, resultUsage = "value") {
         return {
           ...value,
           ...ctx.thisValue === null || ctx.thisValue === void 0 ? {} : { [DELEGATE_LEXICAL_THIS]: ctx.thisValue },
-          [DELEGATE_LEXICAL_ROOT]: ctx.rootValue
+          [DELEGATE_LEXICAL_ROOT]: ctx.rootValue,
+          ...ctx.__functionTypeArguments === void 0 ? {} : {
+            [DELEGATE_LEXICAL_TYPE_ARGUMENTS]: ctx.__functionTypeArguments
+          }
         };
       }
       if (isMemberDelegateTarget(value) && value.valueId === null) {
@@ -20828,15 +21336,27 @@ function evalPointerCore(pointer, scope, ctx, resultUsage = "value") {
       }
       const args = fillCallableCallSiteArguments(suppliedArgs, member, ctx);
       const interceptedMemberId = member?.id ?? pointer.memberId ?? pointer.memberKey ?? pointer.callSiteId;
+      const typeArguments = member === null ? void 0 : calleeTypeArguments(pointer.typeArguments, member, ctx);
       checkDeadline(ctx);
       const intercepted = ctx.callInterceptor?.({
         resultUsage,
         memberId: interceptedMemberId,
         member,
         receiver: innerThis,
-        args,
+        get args() {
+          return args.map((value) => exportRuntimeSetValue(value, ctx));
+        },
         callSiteId: pointer.callSiteId,
-        invokeDelegate: (delegate, delegateArgs = []) => invokeDelegateValue(delegate, delegateArgs, ctx, pointer.callSiteId)
+        typeArguments,
+        invokeDelegate: (delegate, delegateArgs = []) => exportRuntimeSetValue(
+          invokeDelegateValue(
+            delegate,
+            delegateArgs,
+            ctx,
+            pointer.callSiteId
+          ),
+          ctx
+        )
       });
       if (intercepted?.handled === true)
         return hostCallResult(member, intercepted.value, ctx);
@@ -20858,7 +21378,8 @@ function evalPointerCore(pointer, scope, ctx, resultUsage = "value") {
           member.id,
           innerThis,
           args,
-          ctx
+          ctx,
+          typeArguments
         );
         if (systemResult.handled) return systemResult.value;
         const hosted = ctx.unavailableNativeHandler?.({
@@ -20866,13 +21387,18 @@ function evalPointerCore(pointer, scope, ctx, resultUsage = "value") {
           memberId: member.id,
           member,
           receiver: innerThis,
-          args,
+          get args() {
+            return args.map((value) => exportRuntimeSetValue(value, ctx));
+          },
           callSiteId: pointer.callSiteId,
-          invokeDelegate: (delegate, delegateArgs = []) => invokeDelegateValue(
-            delegate,
-            delegateArgs,
-            ctx,
-            pointer.callSiteId
+          invokeDelegate: (delegate, delegateArgs = []) => exportRuntimeSetValue(
+            invokeDelegateValue(
+              delegate,
+              delegateArgs,
+              ctx,
+              pointer.callSiteId
+            ),
+            ctx
           )
         });
         if (hosted?.handled === true)
@@ -20917,7 +21443,12 @@ function evalPointerCore(pointer, scope, ctx, resultUsage = "value") {
           `NSFunction call stack exceeded 64 frames: ${chain.join(" -> ")}.`
         );
       }
-      const runtimeSignature = pointer.receiver.kind === "static" ? signature : substituteCallableSignatureForReceiver(signature, innerThis, ctx);
+      const boundSignature = typeArguments === void 0 ? signature : bindSignatureTypeArguments(signature, typeArguments);
+      const runtimeSignature = pointer.receiver.kind === "static" ? boundSignature : substituteCallableSignatureForReceiver(
+        boundSignature,
+        innerThis,
+        ctx
+      );
       state.functionStack.push({
         name: member.name,
         deferred: signature.deferred
@@ -20925,7 +21456,7 @@ function evalPointerCore(pointer, scope, ctx, resultUsage = "value") {
       try {
         return executeCompiledFunction(
           action,
-          bindThisValue(ctx, innerThis),
+          withFrameTypeArguments(bindThisValue(ctx, innerThis), typeArguments),
           args,
           runtimeSignature.returnTypeInfo.type === NS_TYPE_VOID,
           runtimeSignature
@@ -21020,7 +21551,8 @@ function evalPointerCore(pointer, scope, ctx, resultUsage = "value") {
           (capture) => evalPointer(capture, scope, ctx)
         ),
         ...ctx.thisValue === null || ctx.thisValue === void 0 ? {} : { [DELEGATE_LEXICAL_THIS]: ctx.thisValue },
-        [DELEGATE_LEXICAL_ROOT]: ctx.rootValue
+        [DELEGATE_LEXICAL_ROOT]: ctx.rootValue,
+        ...ctx.__functionTypeArguments === void 0 ? {} : { [DELEGATE_LEXICAL_TYPE_ARGUMENTS]: ctx.__functionTypeArguments }
       };
     case "toBool" /* toBool */: {
       const v = evalPointer(pointer.pointer, scope, ctx);
@@ -21088,7 +21620,8 @@ function invokeDelegateValue(value, args, ctx, callSiteId, ownerReceiver, result
       {
         ...ctx,
         thisValue,
-        rootValue: closure[DELEGATE_LEXICAL_ROOT] ?? ctx.rootValue
+        rootValue: closure[DELEGATE_LEXICAL_ROOT] ?? ctx.rootValue,
+        __functionTypeArguments: closure[DELEGATE_LEXICAL_TYPE_ARGUMENTS]
       },
       [...args, ...captures],
       value.action.typeInfo.type === 0 /* Null */
@@ -21162,9 +21695,15 @@ function invokeDelegateValue(value, args, ctx, callSiteId, ownerReceiver, result
     memberId: member.id,
     member,
     receiver,
-    args,
+    get args() {
+      return args.map((value2) => exportRuntimeSetValue(value2, ctx));
+    },
     callSiteId,
-    invokeDelegate: (delegate, delegateArgs = []) => invokeDelegateValue(delegate, delegateArgs, ctx, callSiteId)
+    typeArguments: calleeTypeArguments(void 0, member, ctx),
+    invokeDelegate: (delegate, delegateArgs = []) => exportRuntimeSetValue(
+      invokeDelegateValue(delegate, delegateArgs, ctx, callSiteId),
+      ctx
+    )
   });
   if (onCompleted === void 0) {
     const intercepted = intercept();
@@ -21192,9 +21731,14 @@ function invokeDelegateValue(value, args, ctx, callSiteId, ownerReceiver, result
           memberId: member.id,
           member,
           receiver,
-          args,
+          get args() {
+            return args.map((value2) => exportRuntimeSetValue(value2, ctx));
+          },
           callSiteId,
-          invokeDelegate: (delegate, delegateArgs = []) => invokeDelegateValue(delegate, delegateArgs, ctx, callSiteId)
+          invokeDelegate: (delegate, delegateArgs = []) => exportRuntimeSetValue(
+            invokeDelegateValue(delegate, delegateArgs, ctx, callSiteId),
+            ctx
+          )
         });
         if (hosted?.handled === true)
           return hostCallResult(member, hosted.value, ctx);
@@ -21213,11 +21757,17 @@ function invokeDelegateValue(value, args, ctx, callSiteId, ownerReceiver, result
             `NeoDelegate target NSFunction '${member.name}' has no valid compiled body.`
           );
         }
-        const runtimeSignature = receiver === null ? signature : substituteCallableSignatureForReceiver(signature, receiver, ctx);
+        const typeArguments = calleeTypeArguments(void 0, member, ctx);
+        const boundSignature = typeArguments === void 0 ? signature : bindSignatureTypeArguments(signature, typeArguments);
+        const runtimeSignature = receiver === null ? boundSignature : substituteCallableSignatureForReceiver(
+          boundSignature,
+          receiver,
+          ctx
+        );
         try {
           return executeCompiledFunction(
             action,
-            bindThisValue(ctx, receiver),
+            withFrameTypeArguments(bindThisValue(ctx, receiver), typeArguments),
             args,
             runtimeSignature.returnTypeInfo.type === NS_TYPE_VOID,
             runtimeSignature
@@ -21479,8 +22029,8 @@ function resolveCallableSignature(memberId, memberKind, ctx) {
   return resolved;
 }
 function substituteCallableSignatureForReceiver(signature, receiver, ctx) {
-  if (!typeInfoContainsGeneric(signature.returnTypeInfo) && !signature.argumentTypes.some(
-    (typeInfo) => typeInfoContainsGeneric(typeInfo)
+  if (!typeInfoContainsGeneric2(signature.returnTypeInfo) && !signature.argumentTypes.some(
+    (typeInfo) => typeInfoContainsGeneric2(typeInfo)
   )) {
     return signature;
   }
@@ -21500,7 +22050,7 @@ function substituteCallableSignatureForReceiver(signature, receiver, ctx) {
         ctx
       ),
       argumentTypes: signature.argumentTypes.map((argument2) => {
-        if (!typeInfoContainsGeneric(argument2)) return argument2;
+        if (!typeInfoContainsGeneric2(argument2)) return argument2;
         const substituted = substituteRuntimeTypeInfo(argument2, env, ctx);
         if (substituted.type === NS_TYPE_VOID) {
           throw new NSGetterRuntimeError(
@@ -21524,7 +22074,66 @@ function substituteCallableSignatureForReceiver(signature, receiver, ctx) {
     );
   }
 }
-function typeInfoContainsGeneric(typeInfo, visited = /* @__PURE__ */ new Set()) {
+function calleeTypeArguments(written, member, ctx) {
+  const parameters = member.genericParams;
+  if (parameters === void 0) return void 0;
+  if (written !== void 0 && written.length === parameters.length && !typeArgumentsForward(written)) {
+    return written;
+  }
+  return parameters.map((parameter3, index) => {
+    const argument2 = written?.[index];
+    if (argument2 !== void 0) {
+      return ctx.__functionTypeArguments === void 0 ? argument2 : bindFunctionTypeArguments(argument2, ctx.__functionTypeArguments);
+    }
+    if (parameter3.defaultType !== void 0) return parameter3.defaultType;
+    throw new NSGetterRuntimeError(
+      `Call to '${member.name}' supplies no type argument for '${parameter3.name}', and it has no default.`
+    );
+  });
+}
+var FORWARDING_TYPE_ARGUMENTS = /* @__PURE__ */ new WeakMap();
+function typeArgumentsForward(written) {
+  let forwards = FORWARDING_TYPE_ARGUMENTS.get(written);
+  if (forwards === void 0) {
+    forwards = written.some(typeInfoHasFunctionGeneric);
+    FORWARDING_TYPE_ARGUMENTS.set(written, forwards);
+  }
+  return forwards;
+}
+function withFrameTypeArguments(ctx, table) {
+  if (ctx.__functionTypeArguments === table) return ctx;
+  return { ...ctx, __functionTypeArguments: table };
+}
+function functionTypeArgument(typeInfo, ctx) {
+  const bound = ctx.__functionTypeArguments?.[typeInfo.index];
+  if (bound !== void 0) return bound;
+  const owner = evalMemberById(ctx.vm, typeInfo.ownerMemberId);
+  const parameter3 = functionGenericParamsOf(owner)?.[typeInfo.index];
+  if (parameter3?.defaultType !== void 0) return parameter3.defaultType;
+  throw new NSGetterRuntimeError(
+    `Type parameter ${typeInfo.index} of function '${owner?.name ?? typeInfo.ownerMemberId}' has no type argument in this frame and no default.`
+  );
+}
+function bindSignatureTypeArguments(signature, table) {
+  const returnTypeInfo = bindFunctionTypeArguments(
+    signature.returnTypeInfo,
+    table
+  );
+  let argumentTypes;
+  for (let index = 0; index < signature.argumentTypes.length; index++) {
+    const argument2 = signature.argumentTypes[index];
+    const bound = bindArgumentTypeArguments(argument2, table);
+    if (bound === argument2) continue;
+    argumentTypes ??= [...signature.argumentTypes];
+    argumentTypes[index] = bound;
+  }
+  return returnTypeInfo === signature.returnTypeInfo && argumentTypes === void 0 ? signature : {
+    ...signature,
+    returnTypeInfo,
+    argumentTypes: argumentTypes ?? signature.argumentTypes
+  };
+}
+function typeInfoContainsGeneric2(typeInfo, visited = /* @__PURE__ */ new Set()) {
   if (visited.has(typeInfo)) {
     throw new NSGetterRuntimeError(
       "Corrupt NSFunction signature contains a cyclic type-info graph."
@@ -21534,11 +22143,11 @@ function typeInfoContainsGeneric(typeInfo, visited = /* @__PURE__ */ new Set())
   nextVisited.add(typeInfo);
   if (typeInfo.type === 21 /* Generic */) return true;
   if (typeInfo.type === 6 /* List */ || typeInfo.type === 28 /* Set */ || typeInfo.type === 5 /* Dictionary */ || typeInfo.type === 9 /* Lookup */) {
-    return typeInfoContainsGeneric(typeInfo.entryTypeInfo, nextVisited);
+    return typeInfoContainsGeneric2(typeInfo.entryTypeInfo, nextVisited);
   }
   if (typeInfo.type !== 7 /* Class */) return false;
   return Object.values(typeInfo.typeArguments ?? {}).some(
-    (argument2) => typeInfoContainsGeneric(argument2, nextVisited)
+    (argument2) => typeInfoContainsGeneric2(argument2, nextVisited)
   );
 }
 function runtimeGenericEnvForValueRow(row, ctx, visited = /* @__PURE__ */ new Set(), readRow) {
@@ -21602,7 +22211,7 @@ function overlayConcreteGenericEntries(target, source) {
 }
 function genericParametersConcretelyBound(typeInfo, env) {
   if (typeInfo.type === 21 /* Generic */) {
-    return env.get(typeInfo.genericParamId)?.kind === "member";
+    return isClassGenericParamTypeInfo(typeInfo) && env.get(typeInfo.genericParamId)?.kind === "member";
   }
   if (typeInfo.type === 6 /* List */ || typeInfo.type === 28 /* Set */ || typeInfo.type === 5 /* Dictionary */ || typeInfo.type === 9 /* Lookup */) {
     return genericParametersConcretelyBound(typeInfo.entryTypeInfo, env);
@@ -21619,6 +22228,10 @@ function genericParametersConcretelyBound(typeInfo, env) {
   return true;
 }
 function substituteRuntimeTypeInfo(typeInfo, env, ctx) {
+  if (typeInfo.type === 21 /* Generic */ && !isClassGenericParamTypeInfo(typeInfo)) {
+    const bound = functionTypeArgument(typeInfo, ctx);
+    return { ...bound, required: bound.required && typeInfo.required };
+  }
   if (typeInfo.type === 21 /* Generic */) {
     const binding = env.get(typeInfo.genericParamId);
     if (binding?.kind !== "member") {
@@ -22074,6 +22687,20 @@ function runtimeTypeCheck(value, checkType, ctx, seenCollections = /* @__PURE__
     case 6 /* List */:
     case 28 /* Set */:
     case 9 /* Lookup */: {
+      if (value instanceof RuntimeSet) {
+        if (seenCollections.has(value)) return false;
+        const seen2 = new Set(seenCollections);
+        seen2.add(value);
+        return value.matches(
+          checkType,
+          (entry) => runtimeCollectionEntryMatchesType(
+            value.enumEntries && typeof entry === "string" ? [entry] : entry,
+            checkType.entryTypeInfo,
+            ctx,
+            seen2
+          )
+        );
+      }
       if (!Array.isArray(value)) return false;
       if (seenCollections.has(value)) return false;
       if (checkType.type === 9 /* Lookup */ && (checkType.entryTypeInfo.type === 8 /* Enum */ || checkType.entryTypeInfo.type === 18 /* DialogueLookup */)) {
@@ -22130,6 +22757,14 @@ function runtimeTypeCheck(value, checkType, ctx, seenCollections = /* @__PURE__
       );
     }
     case 21 /* Generic */:
+      if (!isClassGenericParamTypeInfo(checkType)) {
+        return runtimeTypeCheck(
+          value,
+          functionTypeArgument(checkType, ctx),
+          ctx,
+          seenCollections
+        );
+      }
       return true;
     default:
       return false;
@@ -22138,7 +22773,7 @@ function runtimeTypeCheck(value, checkType, ctx, seenCollections = /* @__PURE__
 function runtimeValueMatchesType(value, typeInfo, ctx, seenCollections = /* @__PURE__ */ new Set()) {
   if (typeInfo.type === NS_TYPE_UNKNOWN) return true;
   if (value === null || value === void 0) {
-    return typeInfo.type === 0 /* Null */ || typeInfo.type === 21 /* Generic */ || !typeInfo.required;
+    return typeInfo.type === 0 /* Null */ || typeInfo.type === 21 /* Generic */ && isClassGenericParamTypeInfo(typeInfo) || !typeInfo.required;
   }
   return runtimeTypeCheck(value, typeInfo, ctx, seenCollections);
 }
@@ -22957,7 +23592,21 @@ function readGridQueryOffset(value) {
   }
   return value;
 }
-function evaluateSystemNative(memberId, receiver, args, ctx) {
+function gridQueryClassFilter(typeArgument, ctx) {
+  if (typeArgument === void 0) return void 0;
+  if (typeArgument.type !== 7 /* Class */) {
+    throw new NSGetterRuntimeError(
+      `Grid query type argument must be a class, not member kind ${typeArgument.type}.`
+    );
+  }
+  const classId = typeArgument.classId;
+  if (classId === NEO_OBJECT_CLASS_ID || classId === NEO_TILE_CLASS_ID) {
+    return void 0;
+  }
+  const schema = evaluatorSchemaIndex(ctx);
+  return (candidate) => schema.classIsOrExtends(candidate, classId);
+}
+function evaluateSystemNative(memberId, receiver, args, ctx, typeArguments) {
   try {
     if (memberId === NEO_OBJECT_GRID_MEMBER_IDS.GetCell || memberId === NEO_OBJECT_GRID_MEMBER_IDS.GetObjects || memberId === NEO_OBJECT_GRID_MEMBER_IDS.GetTile || memberId === NEO_OBJECT_GRID_MEMBER_IDS.GetTiles) {
       const receiverRow = trackedRowForValueReference(receiver, ctx);
@@ -22975,12 +23624,14 @@ function evaluateSystemNative(memberId, receiver, args, ctx) {
         return { handled: true, value: { ...placement.cell } };
       const offsets = readCellPattern(args[0], ctx);
       const shift = readGridQueryOffset(args[1]);
+      const accepts = gridQueryClassFilter(typeArguments?.[0], ctx);
       if (memberId === NEO_OBJECT_GRID_MEMBER_IDS.GetObjects) {
         const value = index.objects(
           placement,
           offsets,
           ctx.worldQueryDependencies,
-          shift
+          shift,
+          accepts
         );
         return { handled: true, value };
       }
@@ -22989,7 +23640,8 @@ function evaluateSystemNative(memberId, receiver, args, ctx) {
           placement,
           offsets,
           ctx.worldQueryDependencies,
-          shift
+          shift,
+          accepts
         );
         return { handled: true, value };
       }
@@ -22997,7 +23649,8 @@ function evaluateSystemNative(memberId, receiver, args, ctx) {
         placement,
         offsets,
         ctx.worldQueryDependencies,
-        shift
+        shift,
+        accepts
       );
       if (tile === null) return { handled: true, value: null };
       const row = evalValueById(
@@ -23153,12 +23806,41 @@ function applyArithmetic(op, operands, decimal, ctx, numeric) {
   }
 }
 function hostCallResult(member, value, ctx) {
-  if (typeof value !== "number" || member === null) return value;
+  if (member === null || typeof value !== "number" && !Array.isArray(value))
+    return value;
   if (member.kind !== 13 /* Function */ && member.kind !== 23 /* NSFunction */) {
     return value;
   }
   const signature = resolveCallableSignature(member.id, member.kind, ctx);
-  return signature?.returnTypeInfo.type === 4 /* Float */ ? Math.fround(value) : value;
+  if (signature?.returnTypeInfo.type === 9 /* Lookup */)
+    return asDeclaredRuntimeSet(value, signature.returnTypeInfo, ctx);
+  return signature?.returnTypeInfo.type === 4 /* Float */ && typeof value === "number" ? Math.fround(value) : value;
+}
+function narrowGenericCallResult(value, member, typeArguments, ctx) {
+  if (member.kind !== 13 /* Function */ && member.kind !== 23 /* NSFunction */) {
+    return { value };
+  }
+  const signature = resolveCallableSignature(member.id, member.kind, ctx);
+  if (signature === null) return { value };
+  const returnType = bindFunctionTypeArguments(
+    signature.returnTypeInfo,
+    typeArguments
+  );
+  if (returnType === signature.returnTypeInfo) return { value };
+  if (returnType.type === NS_TYPE_VOID) return { value };
+  if (value === null || value === void 0) {
+    return returnType.required ? { mismatch: returnType } : { value: null };
+  }
+  if (returnType.type === 6 /* List */ && Array.isArray(value)) {
+    const entryType = returnType.entryTypeInfo;
+    return {
+      value: value.filter(
+        (entry) => runtimeCollectionEntryMatchesType(entry, entryType, ctx, /* @__PURE__ */ new Set())
+      )
+    };
+  }
+  if (runtimeTypeCheck(value, returnType, ctx)) return { value };
+  return returnType.required ? { mismatch: returnType } : { value: null };
 }
 function coerceAssignmentValue(value, targetTypeInfo, context) {
   if (targetTypeInfo.type === 8 /* Enum */ && typeof value === "string") {
@@ -23564,7 +24246,7 @@ function evalDeclaredListIndex(info, scope, ctx) {
       }
       const childId = row.value[info.schemaKey];
       const rawKey = resolveValueIfId(childId, ctx);
-      const normalizedKey = info.keyKind === "enum" ? Array.isArray(rawKey) && typeof rawKey[0] === "string" ? rawKey[0] : null : typeof rawKey === "string" ? rawKey : null;
+      const normalizedKey = normalizeListIndexKey(rawKey, info.keyKind);
       if (normalizedKey === null) continue;
       if (info.unique) {
         const existing = index.get(normalizedKey);
@@ -23814,7 +24496,7 @@ function callbackBodyMayAddInvocationLocals(instructions, parameterIds) {
   });
 }
 function isListCollection(collection) {
-  if (Array.isArray(collection)) return true;
+  if (isArrayCollection(collection)) return true;
   if (typeof collection === "object" && collection !== null) return false;
   throw new NSGetterRuntimeError(
     "Collection callback receiver must be a present List or Dictionary value."
@@ -23891,7 +24573,12 @@ function evalCollectionQuery(info, scope, ctx) {
         output,
         references
       );
-    return output;
+    return info.op === "ToSet" ? runtimeSet(
+      output,
+      info.reference === true,
+      info.enumEntries === true,
+      ctx
+    ) : output;
   };
   if (info.op === "OrderBy" || info.op === "OrderByDescending") {
     let entries = [];
@@ -24121,7 +24808,7 @@ function evalFunction(fn, scope, ctx) {
       return count;
     }
     case "contains" /* contains */: {
-      const c = evalPointer(fn.info.collectionPointer, scope, ctx);
+      let c = evalPointer(fn.info.collectionPointer, scope, ctx);
       const target = evalPointer(fn.info.valuePointer, scope, ctx);
       if (typeof c === "string") {
         if (typeof target !== "string") {
@@ -24131,6 +24818,17 @@ function evalFunction(fn, scope, ctx) {
         }
         return c.includes(target);
       }
+      if (Array.isArray(c)) {
+        const row = trackedRowForValueReference(c, ctx);
+        const member = row === null ? null : memberForValueRow(row, ctx);
+        if (member !== null && (member.kind === 9 /* Lookup */ || member.kind === 8 /* Enum */ || member.kind === 18 /* DialogueLookup */))
+          c = asDeclaredRuntimeSet(
+            c,
+            runtimeTypeInfoForMember(member, /* @__PURE__ */ new Map(), ctx, /* @__PURE__ */ new Set()),
+            ctx
+          );
+      }
+      if (c instanceof RuntimeSet) return c.has(runtimeSetKey(target, c, ctx));
       const setEntryMember = storedSetEntryMember(c, ctx);
       if (setEntryMember !== null) {
         return findStoredSetEntry(
@@ -24560,7 +25258,7 @@ function receiverClosedTypeArguments(typeArguments, ctx) {
   let env = null;
   let closed = null;
   for (const [parameterId, typeInfo] of Object.entries(typeArguments)) {
-    if (!typeInfoContainsGeneric(typeInfo)) continue;
+    if (!typeInfoContainsGeneric2(typeInfo)) continue;
     if (env === null) {
       const row = ctx.thisValueRowId ? readNeoScriptRuntimeRow(ctx, ctx.thisValueRowId) : trackedRowForValueReference(ctx.thisValue, ctx);
       if (row) {
@@ -25861,6 +26559,7 @@ function encodeLookupInitializerResult(member, value, created, ctx) {
 function encodeLookupInitializerSelection(member, value, created, ctx) {
   if (value === null) return null;
   if (value === void 0) return null;
+  if (value instanceof RuntimeSet) value = value.toArray();
   if (Array.isArray(value)) {
     if (isMultiSelectionMember(member) !== true && value.length > 1) {
       throw new NSGetterRuntimeError(
@@ -27466,6 +28165,8 @@ function cloneConstructorLiteralValue(value) {
   );
 }
 function materializeConstructorArgumentValue(args) {
+  if (args.value instanceof RuntimeSet)
+    args = { ...args, value: args.value.toArray() };
   const trackedValueId = findKnownRowIdByValueReference(args.value, args.ctx);
   if (args.value === null && !isRequiredMember(args.member) && isMemberWithEntries(args.member)) {
     return registerConstructorArgumentRow(args, null);
@@ -28176,6 +28877,7 @@ function collectionEntriesOrEmpty(value, ctx) {
   }
 }
 function collectionLength(c) {
+  if (c instanceof RuntimeSet) return c.size;
   if (Array.isArray(c)) return c.length;
   if (typeof c === "object" && c !== null) {
     return Object.keys(c).length;
@@ -28204,6 +28906,17 @@ function snapshotCollectionMembership(collection, ctx) {
   );
 }
 function forEachRawCollectionEntry(c, callback) {
+  if (c instanceof RuntimeSet) {
+    for (const [key, entry] of c.membership().entries()) {
+      if (callback({
+        raw: entry.raw,
+        key,
+        valueId: entry.reference && typeof entry.raw === "string" ? entry.raw : null
+      }) === 1 /* Break */)
+        break;
+    }
+    return true;
+  }
   if (Array.isArray(c)) {
     for (let key = 0; key < c.length; key += 1) {
       const raw = c[key];
@@ -28263,6 +28976,8 @@ function resolveCollectionEntry(collection, raw, key, ctx) {
   return collectionEntryUsesReferenceResolution(collection, key, ctx) ? resolveValueIfId(raw, ctx) : raw;
 }
 function collectionEntryUsesReferenceResolution(collection, key, ctx) {
+  if (collection instanceof RuntimeSet && typeof key === "number")
+    return collection.membership()[key]?.reference === true;
   if (!Array.isArray(collection) || typeof key !== "number") return true;
   const referenceIndexes = ctx.__unorderedListProjections?.referenceEntryIndexesByArray.get(
     collection
@@ -29044,6 +29759,7 @@ var MaterializedValueGraphContext = class {
   }
   resolveTypeInfo(rawTypeInfo, env) {
     if (rawTypeInfo.type === 21 /* Generic */) {
+      if (!isClassGenericParamTypeInfo(rawTypeInfo)) return null;
       const binding = env.get(rawTypeInfo.genericParamId);
       if (binding === void 0 || binding.kind !== "member") return null;
       const member = this.membersById.get(binding.memberId);
@@ -29197,6 +29913,7 @@ function rowGenericEnvironment(document2, row, contextualRootMember) {
 }
 function tryResolveTypeInfo(document2, rawTypeInfo, env) {
   if (rawTypeInfo.type === 21 /* Generic */) {
+    if (!isClassGenericParamTypeInfo(rawTypeInfo)) return null;
     const binding = env.get(rawTypeInfo.genericParamId);
     if (binding === void 0 || binding.kind !== "member") return null;
     const member = document2.members.find(
@@ -35605,18 +36322,42 @@ function sourcePositionMapper(source) {
   };
 }
 
+// ../packages/neoscript-language/src/system-record-id.ts
+var SYSTEM_RECORD_ID_PREFIX2 = "system_";
+
 // ../packages/neoscript-language/src/type-substitution.ts
 function substituteTypeParameters(member, receiver, declaring) {
-  const parameters = declaring.typeParameters ?? [];
-  const argumentsList2 = receiver.typeArguments ?? [];
+  const bindings = classTypeBindings({ type: receiver, declaring });
+  return substituteBindings(
+    member,
+    (type) => type.ownerMemberId === void 0 ? bindings.get(type.id) : void 0
+  );
+}
+function substituteCallTypeArguments(member, functionArguments, typeParameters, receiver) {
+  const classBindings = receiver && classTypeBindings(receiver);
+  const declared = typeParameters?.[0]?.type;
+  const owner = declared?.kind === "typeParameter" ? declared.ownerMemberId : void 0;
+  return substituteBindings(member, (type) => {
+    if (type.ownerMemberId === void 0) return classBindings?.get(type.id);
+    if (type.ownerMemberId !== owner) return void 0;
+    if (type.index === void 0) return void 0;
+    return functionArguments[type.index];
+  });
+}
+function classTypeBindings(receiver) {
+  const parameters = receiver.declaring.typeParameters ?? [];
+  const argumentsList2 = receiver.type.typeArguments ?? [];
   const bindings = /* @__PURE__ */ new Map();
   parameters.forEach((parameter3, index) => {
     const value = argumentsList2[index];
     if (value) bindings.set(parameter3.id ?? parameter3.name, value);
   });
+  return bindings;
+}
+function substituteBindings(member, bindingOf) {
   const visit = (type) => {
     if (type.kind === "typeParameter") {
-      const binding = bindings.get(type.id);
+      const binding = bindingOf(type);
       return binding && type.nullable ? { ...binding, nullable: true } : binding ?? type;
     }
     if (type.kind === "named" && type.typeArguments) {
@@ -35983,10 +36724,6 @@ var UserSafeTypeCheck = class {
   }
 };
 
-// ../packages/neoscript-language/src/tile-conversion.ts
-var NEO_TILE_CONVERT_MEMBER_ID = "system_54ecc5a7-874d-54ed-92f4-38100a4b7465";
-var NEO_TILE_CLASS_ID = "system_d7fa161b-b269-4bf1-9ec9-3aebec67e6e0";
-
 // ../packages/neoscript-language/src/strict-resolver.ts
 var CONSTRUCTING_FUNCTION_KINDS = /* @__PURE__ */ new Set(
   [
@@ -38416,13 +39153,17 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         type
       };
     }
-    return this.resolveExpression(expression, scope);
+    return this.resolveMemberTargetReceiver(expression, scope);
   }
   requireActionListenerSignature(symbol, owner, receiverType, expected, pos) {
-    const substitute = (type) => {
-      if (receiverType?.kind !== "named" || owner === void 0) return type;
-      return substituteTypeParameters(type, receiverType, owner);
-    };
+    const listenerArguments = methodGroupTypeArguments(symbol, false, pos);
+    const receiver = callReceiver(receiverType, owner);
+    const substitute = (type) => substituteCallTypeArguments(
+      type,
+      listenerArguments,
+      symbol.typeParameters,
+      receiver
+    );
     const signature = actionListenerSignature(symbol);
     if (signature === null) {
       throw new CompileError(
@@ -38644,15 +39385,6 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
           );
           if (conversion !== null) return conversion;
         }
-        if (expression.typeArguments && expression.callee.kind === "member" && expression.callee.name === "GetObjects") {
-          return this.resolveGridObjectQuery(
-            expression.callee,
-            expression.args,
-            expression.typeArguments,
-            scope,
-            expression.pos
-          );
-        }
         if (expression.typeArguments && expression.callee.kind === "member" && expression.callee.receiver.kind === "ident" && expression.callee.receiver.name === NEOSCRIPT_LIST_TYPE_NAME) {
           if (expression.callee.name !== NEOSCRIPT_LIST_REPEAT_NAME) {
             throw new CompileError(
@@ -38684,12 +39416,6 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
             expression.pos
           );
         }
-        if (expression.typeArguments) {
-          throw new CompileError(
-            "Type arguments are not supported for this call. Remove the explicit type arguments.",
-            expression.pos
-          );
-        }
         if (expression.argumentNames) {
           throw new CompileError(
             "Named arguments are not supported for this call. Pass arguments in declaration order, without names.",
@@ -38702,7 +39428,8 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
           scope,
           expression.pos,
           expected,
-          receiverValue
+          receiverValue,
+          expression.typeArguments
         );
       }
       case "new": {
@@ -39066,6 +39793,9 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     }
     return void 0;
   }
+  resolveMemberTargetReceiver(expression, scope) {
+    return expression.kind === "ident" && expression.name === "this" ? this.resolveIdentifier("this", scope, expression.pos, "member-target") : this.resolveExpression(expression, scope);
+  }
   resolveDelegateMethodGroup(expression, expected, scope, options = {}) {
     let symbol;
     let receiver = null;
@@ -39079,7 +39809,12 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       owner = implicit.owner;
       receiver = symbol.static === true ? { kind: "static", memberId: symbol.id } : {
         kind: "instance",
-        expression: this.resolveIdentifier("this", scope, expression.pos)
+        expression: this.resolveIdentifier(
+          "this",
+          scope,
+          expression.pos,
+          "member-target"
+        )
       };
     } else if (expression.kind === "member") {
       if (expression.receiver.kind === "ident" && !this.hasValueReceiver(expression.receiver.name, scope)) {
@@ -39096,7 +39831,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         }
         receiver = { kind: "static", memberId: symbol.id };
       } else {
-        const receiverExpression = this.resolveExpression(
+        const receiverExpression = this.resolveMemberTargetReceiver(
           expression.receiver,
           scope
         );
@@ -39119,17 +39854,29 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     }
     if (owner !== void 0)
       this.assertMemberAccessible(owner, symbol, expression.pos);
-    let returnType = symbol.returnType ?? symbol.type;
-    let parameterTypes = (symbol.parameters ?? []).map(
-      (parameter3) => parameter3.type
+    const methodGroupArguments = methodGroupTypeArguments(
+      symbol,
+      options.mockTarget === true,
+      expression.pos
+    );
+    const bound = callReceiver(
+      receiver?.kind === "instance" ? receiver.expression.type : void 0,
+      owner
+    );
+    const returnType = substituteCallTypeArguments(
+      symbol.returnType ?? symbol.type,
+      methodGroupArguments,
+      symbol.typeParameters,
+      bound
+    );
+    const parameterTypes = (symbol.parameters ?? []).map(
+      (parameter3) => substituteCallTypeArguments(
+        parameter3.type,
+        methodGroupArguments,
+        symbol.typeParameters,
+        bound
+      )
     );
-    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) => {
@@ -39141,7 +39888,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         expression.pos
       );
     }
-    if (receiver?.kind === "instance" && options.allowUnboundInstanceTarget !== true && (receiver.expression.pointer.type !== "variable" /* Variable */ || receiver.expression.pointer.variableId !== this.thisVariable.id)) {
+    if (receiver?.kind === "instance" && options.mockTarget !== true && (receiver.expression.pointer.type !== "variable" /* Variable */ || receiver.expression.pointer.variableId !== this.thisVariable.id)) {
       throw new CompileError(
         "NeoDelegate method groups currently require the current 'this' receiver.",
         expression.pos
@@ -39174,10 +39921,10 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         );
         if (symbol === void 0 || symbol.static !== true) return null;
       } else {
-        const receiver = this.resolveExpression(expression.receiver, scope);
-        if (receiver.type.kind !== "named") return null;
-        receiverType = receiver.type;
-        owner = this.project.typeById.get(receiver.type.typeId);
+        const receiver2 = this.resolveExpression(expression.receiver, scope);
+        if (receiver2.type.kind !== "named") return null;
+        receiverType = receiver2.type;
+        owner = this.project.typeById.get(receiver2.type.typeId);
         symbol = owner?.members.find(
           (candidate) => candidate.name === expression.name && (candidate.kind === "function" || candidate.kind === "method")
         );
@@ -39186,16 +39933,26 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     } else {
       return null;
     }
-    let returnType = symbol.returnType ?? symbol.type;
-    let parameterTypes = (symbol.parameters ?? []).map(
-      (parameter3) => parameter3.type
+    const mockArguments = methodGroupTypeArguments(
+      symbol,
+      true,
+      expression.pos
+    );
+    const receiver = callReceiver(receiverType, owner);
+    const returnType = substituteCallTypeArguments(
+      symbol.returnType ?? symbol.type,
+      mockArguments,
+      symbol.typeParameters,
+      receiver
+    );
+    const parameterTypes = (symbol.parameters ?? []).map(
+      (parameter3) => substituteCallTypeArguments(
+        parameter3.type,
+        mockArguments,
+        symbol.typeParameters,
+        receiver
+      )
     );
-    if (receiverType?.kind === "named" && owner !== void 0) {
-      returnType = substituteTypeParameters(returnType, receiverType, owner);
-      parameterTypes = parameterTypes.map(
-        (parameter3) => substituteTypeParameters(parameter3, receiverType, owner)
-      );
-    }
     return { kind: "delegate", returnType, parameterTypes };
   }
   resolveInterpolatedString(parts, scope) {
@@ -39378,7 +40135,13 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       type
     };
   }
-  resolveIdentifier(name, scope, pos) {
+  resolveIdentifier(name, scope, pos, usage = "value") {
+    if (name === "this" && this.context.kind === "initializer" && this.delegateCaptureContexts.length === 0 && usage === "value") {
+      throw new CompileError(
+        "'this' is unavailable while an initializer runs. Defer instance access with a lambda or method group.",
+        pos
+      );
+    }
     if (name === "base") {
       throw new CompileError(
         "'base' can only qualify a function call or getter read inside an override body.",
@@ -41038,7 +41801,14 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       return result.value;
     };
   }
-  resolveCall(callee, argumentsList2, scope, pos, expected, receiverValue = this.callReceiver(callee, scope)) {
+  resolveCall(callee, argumentsList2, scope, pos, expected, receiverValue = this.callReceiver(callee, scope), typeArguments) {
+    const rejectTypeArguments = () => {
+      if (typeArguments === void 0) return;
+      throw new CompileError(
+        "Type arguments are not supported for this call. Remove the explicit type arguments.",
+        pos
+      );
+    };
     if (callee.kind === "member" && callee.receiver.kind === "ident" && callee.receiver.name === "Debug" && this.resolveDebugStatement(
       { kind: "call", callee, args: [...argumentsList2], pos },
       scope
@@ -41049,7 +41819,14 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       );
     }
     if (callee.kind === "member" && callee.receiver.kind === "ident" && callee.receiver.name === "base") {
-      return this.resolveBaseCall(callee, argumentsList2, scope, pos);
+      return this.resolveBaseCall(
+        callee,
+        argumentsList2,
+        scope,
+        pos,
+        false,
+        typeArguments
+      );
     }
     const variantCall = this.resolveVariantCall(
       callee,
@@ -41058,12 +41835,16 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       pos,
       receiverValue
     );
-    if (variantCall !== null) return variantCall;
+    if (variantCall !== null) {
+      rejectTypeArguments();
+      return variantCall;
+    }
     const callable2 = this.resolveCallableValueCallee(
       callee,
       scope,
       receiverValue
     );
+    if (callable2 !== null) rejectTypeArguments();
     if (callable2?.type.kind === "delegate") {
       return this.resolveDelegateCall(
         callable2,
@@ -41081,9 +41862,12 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     }
     if (callee.kind === "ident") {
       const vector3 = vectorKind(callee.name);
-      if (vector3)
+      if (vector3) {
+        rejectTypeArguments();
         return this.resolveVectorConstructor(vector3, argumentsList2, scope, pos);
+      }
       if (callee.name === "VisitCount" || callee.name === "HasVisited") {
+        rejectTypeArguments();
         return this.resolveDialogueMemoryRead(
           callee.name,
           argumentsList2,
@@ -41101,7 +41885,9 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
           argumentsList2,
           scope,
           pos,
-          false
+          false,
+          false,
+          typeArguments
         );
       const target = this.resolveImplicitCallTarget(callee.name, scope, pos);
       if (target)
@@ -41111,7 +41897,9 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
           argumentsList2,
           scope,
           pos,
-          false
+          false,
+          false,
+          typeArguments
         );
       throw new CompileError(`Unknown function '${callee.name}'`, pos);
     }
@@ -41123,6 +41911,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     }
     if (callee.receiver.kind === "ident" && !this.hasValueReceiver(callee.receiver.name, scope)) {
       if (callee.receiver.name === MATH_NAMESPACE_NAME) {
+        rejectTypeArguments();
         if (callee.optional) {
           throw new CompileError(
             `Optional chaining is not valid on builtin namespace '${MATH_NAMESPACE_NAME}'.`,
@@ -41159,41 +41948,44 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
             pos
           );
         }
-        const member = staticType.members.find(
+        const member2 = staticType.members.find(
           (candidate) => candidate.name === callee.name
         );
-        if (!member) {
+        if (!member2) {
           throw new CompileError(
             `Class '${staticType.name}' has no static callable member '${callee.name}'.`,
             pos
           );
         }
-        this.assertMemberAccessible(staticType, member, pos);
-        if (member.static !== true) {
+        this.assertMemberAccessible(staticType, member2, pos);
+        if (member2.static !== true) {
           throw new CompileError(
             `Member '${staticType.name}.${callee.name}' requires an instance receiver.`,
             pos
           );
         }
-        if (member.kind !== "function" && member.kind !== "method") {
+        if (member2.kind !== "function" && member2.kind !== "method") {
           throw new CompileError(
             `Static member '${staticType.name}.${callee.name}' is not callable.`,
             pos
           );
         }
         return this.resolveSymbolCall(
-          member,
-          { kind: "static", memberId: member.id },
+          member2,
+          { kind: "static", memberId: member2.id },
           argumentsList2,
           scope,
           pos,
-          false
+          false,
+          false,
+          typeArguments
         );
       }
     }
     const receiver = receiverValue();
     const optional2 = callee.optional === true;
     if (receiver.dialogues !== void 0) {
+      rejectTypeArguments();
       if (optional2) {
         throw new CompileError(
           `\`?.\` is not valid on ${receiver.dialogues.path}; it is never null.`,
@@ -41214,6 +42006,12 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         pos
       );
     }
+    const memberReceiverType = neoScriptMemberLookupType(receiver.type);
+    const namedType2 = memberReceiverType.kind === "named" ? this.project.typeById.get(memberReceiverType.typeId) : void 0;
+    const member = namedType2?.members.find(
+      (candidate) => (candidate.kind === "function" || candidate.kind === "method") && candidate.name === callee.name
+    );
+    if (member === void 0) rejectTypeArguments();
     if (isPrimitive(receiver.type, "NeoDialogueReference") && isDialogueRequestName(callee.name)) {
       return this.resolveDialogueReferenceCall(
         receiver,
@@ -41233,7 +42031,6 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         pos
       );
     }
-    const memberReceiverType = neoScriptMemberLookupType(receiver.type);
     if (callee.name === "Equals" && memberReceiverType.kind === "typeParameter") {
       if (optional2) {
         throw new CompileError(
@@ -41266,10 +42063,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       };
     }
     if (memberReceiverType.kind === "named") {
-      const type = this.project.typeById.get(memberReceiverType.typeId);
-      const member = type?.members.find(
-        (candidate) => (candidate.kind === "function" || candidate.kind === "method") && candidate.name === callee.name
-      );
+      const type = namedType2;
       if (member) {
         this.validateFunctionReceiver(receiver, callee.name, optional2, pos);
         if (type !== void 0) this.assertMemberAccessible(type, member, pos);
@@ -41288,7 +42082,9 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
           argumentsList2,
           scope,
           pos,
-          optional2
+          optional2,
+          false,
+          typeArguments
         );
       }
       if (callee.name === "Clone" && type?.kind === "class") {
@@ -42089,81 +42885,6 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       type: { kind: "primitive", name: "bool" }
     };
   }
-  resolveGridObjectQuery(callee, args, typeArguments, scope, pos) {
-    const receiver = this.resolveExpression(callee.receiver, scope);
-    const owner = receiver.type.kind === "named" ? this.project.typeById.get(receiver.type.typeId) : void 0;
-    const symbol = owner?.members.find((member) => member.name === callee.name);
-    if (symbol?.id !== NEO_OBJECT_GRID_MEMBER_IDS.GetObjects)
-      throw new CompileError(
-        "Only NeoObject.GetObjects accepts a class filter type argument.",
-        pos
-      );
-    if (callee.optional || isNullable(receiver.type))
-      throw new CompileError(
-        "GetObjects<T> requires a non-null placed object receiver.",
-        pos
-      );
-    if (typeArguments.length !== 1)
-      throw new CompileError(
-        "GetObjects<T> requires exactly one object class type argument.",
-        pos
-      );
-    const target = this.resolveType(requiredAt(typeArguments, 0));
-    if (target.kind !== "named" || this.project.typeById.get(target.typeId)?.kind !== "class" || target.nullable || !isNeoScriptTypeAssignable(
-      target,
-      { kind: "named", typeId: NEO_OBJECT_CLASS_ID },
-      this.project
-    ))
-      throw new CompileError(
-        "GetObjects<T> requires a non-null NeoObject class or a derived class.",
-        pos
-      );
-    this.assertMemberAccessible(owner, symbol, pos);
-    const queried = this.resolveSymbolCall(
-      symbol,
-      { kind: "instance", expression: receiver },
-      args,
-      scope,
-      pos,
-      false
-    );
-    if (queried.type.kind !== "list")
-      throw new CompileError("NeoObject.GetObjects must return a list.", pos);
-    const item = variable(
-      "__grid_query_item__",
-      queried.type.elementType,
-      void 0,
-      this.project
-    );
-    const predicate = {
-      compilerRevision: NEOSCRIPT_COMPILER_REVISION,
-      source: {
-        name: this.debugSource.name,
-        uri: this.debugSource.uri,
-        coordinateSpace: this.debugSource.coordinateSpace
-      },
-      parameters: [item],
-      instructions: [
-        {
-          type: "return" /* Return */,
-          pointer: {
-            type: "isCheck" /* IsCheck */,
-            pointer: {
-              type: "variable" /* Variable */,
-              variableId: item.id
-            },
-            checkType: toWireType(target, this.project)
-          }
-        }
-      ],
-      typeInfo: toWireType({ kind: "primitive", name: "bool" }, this.project)
-    };
-    return intrinsic(
-      "where" /* Where */,
-      { collectionPointer: queried.pointer, function: predicate },
-      { kind: "list", elementType: target, readOnly: true }
-    );
-  }
   resolveBaseMember(name, scope, pos, optional2) {
     const baseClass = this.context.baseClass;
     if (baseClass?.kind !== "named" || this.context.staticMember === true || this.context.thisClass === void 0) {
@@ -42207,7 +42928,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       }
     };
   }
-  resolveBaseCall(callee, args, scope, pos, allowVoid = false) {
+  resolveBaseCall(callee, args, scope, pos, allowVoid = false, typeArguments) {
     const { symbol, receiver } = this.resolveBaseMember(
       callee.name,
       scope,
@@ -42227,17 +42948,19 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       scope,
       pos,
       false,
-      allowVoid
+      allowVoid,
+      typeArguments
     );
   }
-  resolveSymbolCall(symbol, receiver, argumentsList2, scope, pos, optional2, allowVoid = false) {
+  resolveSymbolCall(symbol, receiver, argumentsList2, scope, pos, optional2, allowVoid = false, typeArguments) {
     this.validateCallableInContext(symbol, pos);
     const resolvedCall = this.resolveCallableArguments(
       symbol,
       receiver,
       argumentsList2,
       scope,
-      pos
+      pos,
+      typeArguments
     );
     const call = {
       type: "callFunction" /* CallFunction */,
@@ -42247,6 +42970,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         pointer: receiver?.expression.pointer ?? this.thisVariable.pointer
       },
       args: resolvedCall.args,
+      ...resolvedCall.typeArguments ? { typeArguments: resolvedCall.typeArguments } : {},
       ...receiver?.kind === "instance" && receiver.dispatch === "base" ? { dispatch: "base" } : {},
       ...optional2 ? { optional: true } : {},
       callSiteId: this.nextCallSite(pos)
@@ -42269,8 +42993,18 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
    * whose type depends on the supplied value or method group. The special
    * cases are unreachable unless the host injected the test prelude.
    */
-  resolveCallableArguments(symbol, receiver, argumentsList2, scope, pos) {
-    const signature = this.callableSignatureForReceiver(symbol, receiver);
+  resolveCallableArguments(symbol, receiver, argumentsList2, scope, pos, typeArguments) {
+    const signature = this.callableSignatureForReceiver(
+      symbol,
+      receiver,
+      typeArguments,
+      pos
+    );
+    const wireTypeArguments = signature.typeArguments.length ? {
+      typeArguments: signature.typeArguments.map(
+        (argument2) => toWireType(argument2, this.project)
+      )
+    } : {};
     if (symbol.id === NEO_TEST_IDS.expect) {
       requireArgCount(symbol.name, argumentsList2, 1, pos);
       const argument2 = requiredAt(argumentsList2, 0);
@@ -42304,7 +43038,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         scope,
         // Mock targets are member-identity metadata. They are never invoked as
         // delegates, and mockHandle.on(receiver) owns receiver scoping.
-        { allowUnboundInstanceTarget: true }
+        { mockTarget: true }
       );
       if (target === null) {
         throw new CompileError(
@@ -42493,23 +43227,100 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         );
       }
     }
-    return { args, returnType: signature.returnType };
+    return { args, returnType: signature.returnType, ...wireTypeArguments };
+  }
+  callableSignatureForReceiver(symbol, receiver, typeArguments, pos) {
+    const bound = this.genericCallReceiver(receiver);
+    const functionArguments = this.resolveFunctionTypeArguments(
+      symbol,
+      typeArguments,
+      (type) => substituteCallTypeArguments(type, [], void 0, bound),
+      pos
+    );
+    const bind = (type) => substituteCallTypeArguments(
+      type,
+      functionArguments,
+      symbol.typeParameters,
+      bound
+    );
+    return {
+      parameters: (symbol.parameters ?? []).map((parameter3) => ({
+        ...parameter3,
+        type: bind(parameter3.type)
+      })),
+      returnType: bind(symbol.returnType ?? symbol.type),
+      typeArguments: functionArguments
+    };
   }
-  callableSignatureForReceiver(symbol, receiver) {
-    let parameters = symbol.parameters ?? [];
-    let returnType = symbol.returnType ?? symbol.type;
-    if (receiver?.kind !== "instance") return { parameters, returnType };
+  /** The instance receiver whose class type arguments a call binds, if any. */
+  genericCallReceiver(receiver) {
+    if (receiver?.kind !== "instance") return void 0;
     const receiverType = receiver.expression.type;
-    if (receiverType.kind !== "named") return { parameters, returnType };
-    if (!receiverType.typeArguments?.length) return { parameters, returnType };
-    const declaring = this.project.typeById.get(receiverType.typeId);
-    if (declaring === void 0) return { parameters, returnType };
-    parameters = parameters.map((parameter3) => ({
-      ...parameter3,
-      type: substituteTypeParameters(parameter3.type, receiverType, declaring)
-    }));
-    returnType = substituteTypeParameters(returnType, receiverType, declaring);
-    return { parameters, returnType };
+    if (receiverType.kind !== "named") return void 0;
+    if (!receiverType.typeArguments?.length) return void 0;
+    return callReceiver(
+      receiverType,
+      this.project.typeById.get(receiverType.typeId)
+    );
+  }
+  /**
+   * P110 §2. The callee's full positional type-argument list: written
+   * arguments, then defaults. Each written argument is non-nullable and
+   * satisfies its param's constraint.
+   */
+  resolveFunctionTypeArguments(symbol, typeArguments, substitute, pos) {
+    const parameters = symbol.typeParameters ?? [];
+    if (parameters.length === 0) {
+      if (typeArguments === void 0) return [];
+      throw new CompileError(
+        `Function '${symbol.name}' is not generic; remove the type arguments.`,
+        pos
+      );
+    }
+    const written = typeArguments ?? [];
+    if (written.length > parameters.length) {
+      throw new CompileError(
+        `Function '${symbol.name}' takes ${parameters.length} type argument${parameters.length === 1 ? "" : "s"} but got ${written.length}.`,
+        pos
+      );
+    }
+    return parameters.map((parameter3, index) => {
+      const declared = parameter3.type;
+      if (declared.kind !== "typeParameter") {
+        throw new Error(
+          `Function '${symbol.name}' type parameter '${parameter3.name}' has no type parameter type.`
+        );
+      }
+      const authored = written[index];
+      if (authored === void 0) {
+        if (declared.defaultType !== void 0) return declared.defaultType;
+        throw new CompileError(
+          `'${symbol.name}' needs a type argument for '${parameter3.name}'.`,
+          pos
+        );
+      }
+      const argument2 = this.resolveType(authored);
+      if (argument2.nullable === true) {
+        throw new CompileError(
+          `Type argument '${this.describe(argument2)}' cannot be nullable; declare '${parameter3.name}?' in the signature instead.`,
+          authored.pos
+        );
+      }
+      if (symbol.native === true && !symbol.id.startsWith(SYSTEM_RECORD_ID_PREFIX2) && argument2.kind === "named" && (argument2.typeArguments?.length ?? 0) > 0) {
+        throw new CompileError(
+          `Native function '${symbol.name}' takes a non-generic class type argument; '${this.describe(argument2)}' is generic.`,
+          authored.pos
+        );
+      }
+      const constraint = declared.constraint === void 0 ? void 0 : substitute(declared.constraint);
+      if (constraint !== void 0 && !isNeoScriptTypeAssignable(argument2, constraint, this.project)) {
+        throw new CompileError(
+          `Type argument '${this.describe(argument2)}' does not satisfy '${parameter3.name} extends ${this.describe(constraint)}' on '${symbol.name}'.`,
+          authored.pos
+        );
+      }
+      return argument2;
+    });
   }
   delegateTypeFromMockHandle(type) {
     if (type.kind !== "named" || type.typeId !== NEO_TEST_IDS.mockHandleType || type.typeArguments?.[0]?.kind !== "delegate") {
@@ -43437,8 +44248,10 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
   resolveFunctionStatement(expression, scope) {
     if (expression.kind !== "call") return null;
     const receiverValue = this.callReceiver(expression.callee, scope);
-    if (expression.typeArguments) return null;
     if (expression.argumentNames) return null;
+    const typeArguments = expression.typeArguments;
+    if (typeArguments !== void 0 && expression.callee.kind === "member" && expression.callee.receiver.kind === "ident" && expression.callee.receiver.name === NEOSCRIPT_LIST_TYPE_NAME)
+      return null;
     if (expression.callee.kind === "member" && expression.callee.name === "TryConvert") {
       const conversion = this.resolveTileConversion(
         expression.callee,
@@ -43458,7 +44271,8 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         expression.args,
         scope,
         expression.pos,
-        true
+        true,
+        typeArguments
       );
       if (result.pointer.type !== "callFunction" /* CallFunction */)
         throw new Error("Base call did not produce a function call.");
@@ -43469,6 +44283,12 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       scope,
       receiverValue
     );
+    if (callable2 !== null && typeArguments !== void 0) {
+      throw new CompileError(
+        "Type arguments are not supported for this call. Remove the explicit type arguments.",
+        expression.pos
+      );
+    }
     if (callable2?.type.kind === "action") {
       return this.resolveActionCall(callable2, callable2.type, expression, scope);
     }
@@ -43521,13 +44341,15 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
           null,
           expression.args,
           scope,
-          expression.pos
+          expression.pos,
+          typeArguments
         );
         return {
           type: "callFunction" /* CallFunction */,
           memberId: global.id,
           receiver: { kind: "static", memberId: global.id },
           args: resolved2.args,
+          ...resolved2.typeArguments ? { typeArguments: resolved2.typeArguments } : {},
           callSiteId: this.nextCallSite(expression.pos)
         };
       }
@@ -43544,7 +44366,8 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         scope,
         expression.pos,
         false,
-        true
+        true,
+        typeArguments
       );
       if (result.pointer.type !== "callFunction" /* CallFunction */)
         throw new Error("Bare call did not produce a function call.");
@@ -43585,13 +44408,15 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
           { kind: "static", memberId: symbol2.id },
           expression.args,
           scope,
-          expression.pos
+          expression.pos,
+          typeArguments
         );
         return {
           type: "callFunction" /* CallFunction */,
           memberId: symbol2.id,
           receiver: { kind: "static", memberId: symbol2.id },
           args: resolved2.args,
+          ...resolved2.typeArguments ? { typeArguments: resolved2.typeArguments } : {},
           callSiteId: this.nextCallSite(expression.pos)
         };
       }
@@ -43629,13 +44454,15 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       },
       expression.args,
       scope,
-      expression.pos
+      expression.pos,
+      typeArguments
     );
     return {
       type: "callFunction" /* CallFunction */,
       ...type?.kind === "interface" ? { memberKey: symbol.schemaKey ?? symbol.name } : { memberId: symbol.id },
       receiver: { kind: "instance", pointer: receiver.pointer },
       args: resolved.args,
+      ...resolved.typeArguments ? { typeArguments: resolved.typeArguments } : {},
       ...expression.callee.optional ? { optional: true } : {},
       callSiteId: this.nextCallSite(expression.pos)
     };
@@ -45264,6 +46091,14 @@ function toWireType(type, project) {
       };
     }
     case "typeParameter":
+      if (type.ownerMemberId !== void 0 && type.index !== void 0) {
+        return {
+          type: 21 /* Generic */,
+          required,
+          ownerMemberId: type.ownerMemberId,
+          index: type.index
+        };
+      }
       return {
         type: 21 /* Generic */,
         required,
@@ -45300,6 +46135,16 @@ function fromWireType(type) {
   if (type.type === 8 /* Enum */)
     return { kind: "named", typeId: type.enumId, nullable: nullable2 };
   if (type.type === 21 /* Generic */) {
+    if ("ownerMemberId" in type) {
+      return {
+        kind: "typeParameter",
+        id: functionTypeParameterId(type.ownerMemberId, type.index),
+        name: `T${type.index}`,
+        ownerMemberId: type.ownerMemberId,
+        index: type.index,
+        nullable: nullable2
+      };
+    }
     return {
       kind: "typeParameter",
       id: type.genericParamId,
@@ -45938,9 +46783,8 @@ function resolveNeoScriptType(type, context, project) {
       }
       const declaringTypeRef = context.declaringType === void 0 ? context.thisClass : context.declaringType;
       const declaringType = declaringTypeRef?.kind === "named" ? project.typeById.get(declaringTypeRef.typeId) : void 0;
-      const typeParameter2 = declaringType?.typeParameters?.find(
-        (candidate) => candidate.name === type.name
-      );
+      const byName = (candidate) => candidate.name === type.name;
+      const typeParameter2 = context.typeParameters?.find(byName) ?? declaringType?.typeParameters?.find(byName);
       if (typeParameter2?.type.kind === "typeParameter") {
         resolved = typeParameter2.type;
         break;
@@ -46015,6 +46859,20 @@ function resolveNeoScriptType(type, context, project) {
   }
   return { ...resolved, nullable: !type.required };
 }
+function methodGroupTypeArguments(symbol, mockTarget, pos) {
+  return (symbol.typeParameters ?? []).map((parameter3) => {
+    const declared = parameter3.type;
+    const fallback = declared.kind === "typeParameter" ? declared.defaultType : void 0;
+    if (fallback !== void 0) return fallback;
+    if (!mockTarget) {
+      throw new CompileError(
+        `Function '${symbol.name}' can be a delegate target only when every type parameter has a default; '${parameter3.name}' has none.`,
+        pos
+      );
+    }
+    return declared.kind === "typeParameter" && declared.constraint ? declared.constraint : { kind: "primitive", name: "unknown" };
+  });
+}
 function wrappedTypeParameterMessage(target, project) {
   for (const argument2 of target.typeArguments ?? []) {
     if (argument2.kind === "typeParameter") continue;
@@ -46045,6 +46903,11 @@ function intersectCollectionWritability(left, right) {
   const writable = (value) => value === "local" /* Local */ || value === "save" /* Save */ || value === "session" /* Session */ || value === "runtime" /* Runtime */;
   return writable(left) && writable(right) ? "runtime" /* Runtime */ : "readOnly" /* ReadOnly */;
 }
+function callReceiver(receiverType, declaring) {
+  if (receiverType?.kind !== "named") return void 0;
+  if (declaring === void 0) return void 0;
+  return { type: receiverType, declaring };
+}
 
 // ../packages/neoscript-language/src/compiler.ts
 function compileNeoScriptStrict(document2, context, options = {}) {
@@ -47957,15 +48820,30 @@ function isInterfaceFunctionMember(member) {
 function interfacePropertyIsSettable(member) {
   return member.accessors === 1 /* GetSet */;
 }
-function containsForbiddenMemberTypeInfo(typeInfo) {
+function containsForbiddenMemberTypeInfo(typeInfo, own) {
   if (typeInfo.type === NS_TYPE_UNKNOWN) return true;
-  if (typeInfo.type === 21 /* Generic */) return true;
+  if (typeInfo.type === 21 /* Generic */) {
+    if (isClassGenericParamTypeInfo(typeInfo)) return true;
+    if (own === null) return true;
+    if (typeInfo.ownerMemberId !== own.ownerMemberId) return true;
+    return typeInfo.index >= own.count;
+  }
   if (typeInfo.type === 6 /* List */ || typeInfo.type === 28 /* Set */ || typeInfo.type === 5 /* Dictionary */ || typeInfo.type === 9 /* Lookup */) {
-    return containsForbiddenMemberTypeInfo(typeInfo.entryTypeInfo);
+    return containsForbiddenMemberTypeInfo(typeInfo.entryTypeInfo, own);
+  }
+  if (typeInfo.type === 25 /* NSDelegate */) {
+    return containsForbiddenMemberTypeInfo(typeInfo.returnTypeInfo, own) || typeInfo.argumentTypes.some(
+      (argument2) => containsForbiddenMemberTypeInfo(argument2, own)
+    );
+  }
+  if (typeInfo.type === 26 /* NSAction */) {
+    return typeInfo.argumentTypes.some(
+      (argument2) => containsForbiddenMemberTypeInfo(argument2, own)
+    );
   }
   if (typeInfo.type === 7 /* Class */ && typeInfo.typeArguments) {
     return Object.values(typeInfo.typeArguments).some(
-      containsForbiddenMemberTypeInfo
+      (argument2) => containsForbiddenMemberTypeInfo(argument2, own)
     );
   }
   return false;
@@ -47981,17 +48859,23 @@ function isNeoInterfaceMember(value) {
   if (member.kind === void 0 || member.kind === 0 /* Property */) {
     const property2 = value;
     if (!isNSTypeInfo(property2.typeInfo)) return false;
-    if (containsForbiddenMemberTypeInfo(property2.typeInfo)) return false;
+    if (containsForbiddenMemberTypeInfo(property2.typeInfo, null)) return false;
     return property2.accessors === void 0 || property2.accessors === 0 /* Get */ || property2.accessors === 1 /* GetSet */;
   }
   if (member.kind !== 1 /* Function */) return false;
   const fn = value;
   if (!isNSFunctionReturnTypeInfo(fn.returnTypeInfo)) return false;
-  if (containsForbiddenMemberTypeInfo(fn.returnTypeInfo)) return false;
+  if (fn.genericParams !== void 0 && !isFunctionGenericParams(fn.genericParams, isValidSchemaBindingIdentifier))
+    return false;
+  const own = {
+    ownerMemberId: member.id,
+    count: fn.genericParams?.length ?? 0
+  };
+  if (containsForbiddenMemberTypeInfo(fn.returnTypeInfo, own)) return false;
   if (!Array.isArray(fn.argumentTypes)) return false;
   for (const argumentType of fn.argumentTypes) {
     if (!isNSFunctionArgumentTypeInfo(argumentType)) return false;
-    if (containsForbiddenMemberTypeInfo(argumentType)) return false;
+    if (containsForbiddenMemberTypeInfo(argumentType, own)) return false;
   }
   if (fn.dispatch !== void 0 && fn.dispatch !== 0 /* Synchronous */ && fn.dispatch !== 1 /* Asynchronous */)
     return false;
@@ -48461,6 +49345,11 @@ function createNeoScriptDocumentContextInScope(context, projectOverride) {
     ...baseClass ? { baseClass } : {},
     ...returnType ? { returnType } : {},
     ...parameters ? { parameters } : {},
+    ...context.memberId === void 0 || documentKind !== "function" ? {} : functionTypeParameterSymbols(
+      context.memberId,
+      declaredFunctionGenericParams(context, context.memberId),
+      context
+    ),
     ...context.functionDeferred !== void 0 ? { deferred: context.functionDeferred } : {},
     ...functionName ? { functionName } : {},
     ...context.dialogueContext ? {
@@ -48880,6 +49769,11 @@ function memberToSymbol(record4, schemaKey, containingClass, ownerClassId, index
       kind: authoredCallable.kind === 23 /* NSFunction */ ? "function" : "method",
       type: returnType,
       returnType,
+      ...functionTypeParameterSymbols(
+        record4.id,
+        authoredCallable.genericParams,
+        context
+      ),
       parameters: authoredCallable.argumentTypes.map(
         (argument2, argumentIndex) => ({
           id: `${record4.id}:argument:${argumentIndex}`,
@@ -49069,6 +49963,7 @@ function interfaceMemberToSymbol(neoInterface, key, member, context, inherited)
       kind: "function",
       type: returnType,
       returnType,
+      ...functionTypeParameterSymbols(member.id, member.genericParams, context),
       parameters: member.argumentTypes.map((argument2, index) => ({
         id: `${neoInterface.id}:member:${key}:argument:${index}`,
         name: argument2.name,
@@ -49591,6 +50486,9 @@ function toLanguageType(type, context, genericEnvironment) {
         nullable: false
       };
     case 21 /* Generic */:
+      if (!isClassGenericParamTypeInfo(type)) {
+        return functionGenericLanguageType(type, required, context);
+      }
       return genericParameterLanguageType(
         type.genericParamId,
         required,
@@ -49599,6 +50497,64 @@ function toLanguageType(type, context, genericEnvironment) {
       );
   }
 }
+var INTERFACE_FUNCTION_GENERICS = /* @__PURE__ */ new WeakMap();
+function declaredFunctionGenericParams(context, ownerMemberId) {
+  const member = analyzerMemberById(context, ownerMemberId);
+  if (member !== null) return functionGenericParamsOf(member);
+  const interfaces = context.vm.interfaces ?? [];
+  let byMember = INTERFACE_FUNCTION_GENERICS.get(interfaces);
+  if (byMember === void 0) {
+    const index = /* @__PURE__ */ new Map();
+    for (const neoInterface of interfaces) {
+      for (const interfaceMember of Object.values(neoInterface.members)) {
+        if (!isInterfaceFunctionMember(interfaceMember)) continue;
+        if (interfaceMember.genericParams === void 0) continue;
+        index.set(interfaceMember.id, interfaceMember.genericParams);
+      }
+    }
+    byMember = index;
+    INTERFACE_FUNCTION_GENERICS.set(interfaces, byMember);
+  }
+  return byMember.get(ownerMemberId);
+}
+function functionGenericLanguageType(type, required, context) {
+  return functionTypeParameterRef(
+    type.ownerMemberId,
+    type.index,
+    declaredFunctionGenericParams(context, type.ownerMemberId)?.[type.index],
+    required,
+    context
+  );
+}
+function functionTypeParameterRef(ownerMemberId, index, parameter3, required, context) {
+  const id = functionTypeParameterId(ownerMemberId, index);
+  return {
+    kind: "typeParameter",
+    id,
+    name: parameter3?.name ?? id,
+    ownerMemberId,
+    index,
+    ...parameter3?.constraint ? { constraint: toLanguageType(parameter3.constraint, context) } : {},
+    ...parameter3?.defaultType ? { defaultType: toLanguageType(parameter3.defaultType, context) } : {},
+    nullable: !required
+  };
+}
+function functionTypeParameterSymbols(ownerMemberId, parameters, context) {
+  if (parameters === void 0) return {};
+  return {
+    typeParameters: parameters.map((parameter3, index) => ({
+      id: functionTypeParameterId(ownerMemberId, index),
+      name: parameter3.name,
+      type: functionTypeParameterRef(
+        ownerMemberId,
+        index,
+        parameter3,
+        true,
+        context
+      )
+    }))
+  };
+}
 function genericParameterLanguageType(genericParamId, required, context, genericEnvironment, visiting = /* @__PURE__ */ new Set()) {
   const environmentEntry = genericEnvironment?.get(genericParamId);
   if (environmentEntry?.kind === "member") {
@@ -52986,6 +53942,7 @@ var SCHEMA_DOCUMENT_FIELD_CONTRACTS = {
       "setterCode",
       "returnTypeInfo",
       "argumentTypes",
+      "genericParams",
       "dispatch",
       "bodyMode",
       "effect",
@@ -53060,6 +54017,7 @@ var SCHEMA_DOCUMENT_FIELD_CONTRACTS = {
       code: "nullIsAbsentOnFullMember",
       templateId: "nullIsAbsentOnFullMember",
       setterCode: "nullIsAbsentOnFullMember",
+      genericParams: "nullOrEmptyArrayIsAbsent",
       dispatch: {
         kind: "absentMeansDefault",
         defaultValue: 0
@@ -53457,6 +54415,13 @@ function normalizeDocumentFields(recordKind, value) {
         normalizeTypeInfoBindings(argument2);
       }
     }
+    if (Array.isArray(normalized.genericParams)) {
+      for (const parameter3 of normalized.genericParams) {
+        if (!isRecord2(parameter3)) continue;
+        normalizeTypeInfoBindings(parameter3.constraint);
+        normalizeTypeInfoBindings(parameter3.defaultType);
+      }
+    }
     stripCompiledInitializer(normalized.defaultValue);
   }
   if (recordKind === "constructor") {
@@ -54690,6 +55655,10 @@ function schemaTypeOptionsAtDepth(depth) {
       ownerClassId: nonEmptyString,
       genericParamId: nonEmptyString
     }),
+    nullableTypeSchema("functionGeneric", {
+      ownerMemberId: nonEmptyString,
+      index: pipe(number(), integer2(), minValue(0))
+    }),
     nullableTypeSchema("enum", {
       enumId: nonEmptyString
     }),
@@ -54935,10 +55904,21 @@ var schemaListColumnSchema = strictObject({
   frozen: boolean2(),
   wrapContent: boolean2()
 });
+var schemaFunctionGenericParameterSchema = strictObject({
+  name: nonEmptyString,
+  constraint: nullable(schemaTypeSchema),
+  default: nullable(schemaTypeSchema)
+});
 var callableEntries = {
   returnType: schemaFunctionReturnTypeSchema,
   arguments: array(schemaFunctionArgumentSchema)
 };
+var genericCallableEntries = {
+  ...callableEntries,
+  genericParams: optional(
+    pipe(array(schemaFunctionGenericParameterSchema), minLength(1))
+  )
+};
 var functionEffectSchema = optional(picklist(["none", "auto"]));
 var schemaMemberSchema = variant("kind", [
   ...simpleMemberSchemas,
@@ -55018,12 +55998,12 @@ var schemaMemberSchema = variant("kind", [
     templateId: nullableId
   }),
   memberSchema("function", {
-    ...callableEntries,
+    ...genericCallableEntries,
     deferred: boolean2(),
     effect: functionEffectSchema
   }),
   memberSchema("scriptFunction", {
-    ...callableEntries,
+    ...genericCallableEntries,
     deferred: boolean2(),
     effect: functionEffectSchema,
     bodyMode: optional(literal2("ui")),
@@ -55486,6 +56466,10 @@ function memberFromDocument(record4, members, owners, classNames, context) {
         record4,
         source.span
       ),
+      ...documentGenericParamsToManifest(
+        field("genericParams", void 0),
+        record4
+      ),
       deferred: ordinalValue(
         field("dispatch", 0),
         FUNCTION_DISPATCH,
@@ -55776,6 +56760,11 @@ function memberToDocumentFields(member, baseData) {
       fields.returnTypeInfo = manifestReturnTypeToDocument(member.returnType);
       fields.argumentTypes = member.arguments.map(manifestArgumentToDocument);
     }
+    if (member.genericParams !== void 0) {
+      fields.genericParams = manifestGenericParamsToDocument(
+        member.genericParams
+      );
+    }
     if (member.deferred || isOverride) {
       fields.dispatch = member.deferred ? 1 : 0;
     }
@@ -55923,6 +56912,32 @@ function optionalDocumentType(value, record4, path) {
   if (value === null || value === void 0) return null;
   return documentTypeToManifest(value, record4, path);
 }
+function documentGenericParamsToManifest(value, record4) {
+  if (value === void 0) return {};
+  if (!Array.isArray(value)) {
+    throw invalidDocument(record4, "genericParams", "must be an array");
+  }
+  return {
+    genericParams: value.map((entry, index) => {
+      const path = `genericParams[${index}]`;
+      if (!isRecord3(entry))
+        throw invalidDocument(record4, path, "must be an object");
+      return {
+        name: requiredStringValue(entry.name, record4, `${path}.name`),
+        constraint: optionalDocumentType(
+          entry.constraint,
+          record4,
+          `${path}.constraint`
+        ),
+        default: optionalDocumentType(
+          entry.defaultType,
+          record4,
+          `${path}.defaultType`
+        )
+      };
+    })
+  };
+}
 function documentReturnTypeToManifest(value, record4, path) {
   if (isRecord3(value) && value.type === "Void") {
     return { kind: "void", nullable: false };
@@ -55965,6 +56980,18 @@ function documentTypeToManifest(value, record4, path) {
       )
     };
   }
+  if (kind === MEMBER_KIND.Generic && "ownerMemberId" in typeInfo) {
+    return {
+      kind: "functionGeneric",
+      nullable: nullable2,
+      ownerMemberId: requiredStringValue(
+        typeInfo.ownerMemberId,
+        record4,
+        `${path}.ownerMemberId`
+      ),
+      index: requiredNumberValue(typeInfo.index, record4, `${path}.index`)
+    };
+  }
   if (kind === MEMBER_KIND.Generic) {
     return {
       kind: "generic",
@@ -56098,6 +57125,15 @@ function documentTypeToManifest(value, record4, path) {
     `unsupported type-info discriminator ${kind}`
   );
 }
+function manifestGenericParamsToDocument(params) {
+  return params.map(
+    (parameter3) => omitUndefined({
+      name: parameter3.name,
+      constraint: parameter3.constraint ? manifestTypeToDocument(parameter3.constraint) : void 0,
+      defaultType: parameter3.default ? manifestTypeToDocument(parameter3.default) : void 0
+    })
+  );
+}
 function manifestArgumentToDocument(argument2) {
   return {
     name: argument2.name,
@@ -56141,6 +57177,14 @@ function manifestTypeToDocument(type) {
       genericParamId: type.genericParamId
     };
   }
+  if (type.kind === "functionGeneric") {
+    return {
+      type: MEMBER_KIND.Generic,
+      required,
+      ownerMemberId: type.ownerMemberId,
+      index: type.index
+    };
+  }
   if (type.kind === "enum") {
     return { type: MEMBER_KIND.Enum, required, enumId: type.enumId };
   }
@@ -56812,6 +57856,7 @@ function interfaceFromDocument(record4, context) {
             record4,
             source.span
           ),
+          ...documentGenericParamsToManifest(member.genericParams, record4),
           deferred: ordinalValue(
             member.dispatch ?? 0,
             ["synchronous", "asynchronous"],
@@ -56848,6 +57893,11 @@ function interfaceToDocument(neoInterface) {
         ...member.docsText === void 0 ? {} : { docsText: member.docsText },
         returnTypeInfo: manifestReturnTypeToDocument(member.returnType),
         argumentTypes: member.arguments.map(manifestArgumentToDocument),
+        ...member.genericParams === void 0 ? {} : {
+          genericParams: manifestGenericParamsToDocument(
+            member.genericParams
+          )
+        },
         ...member.deferred ? { dispatch: 1 } : {},
         ...accessToDocument(member.accessModifier)
       };
@@ -57756,7 +58806,7 @@ var INITIALIZER_KEY_PLACEHOLDER = new RegExp(
 
 // ../packages/manifest/schema-contract/registry.mjs
 var PROJECT_SCHEMA_CONTRACT = Object.freeze({
-  cliVersion: "0.79.1",
+  cliVersion: "0.80.0",
   projectFileUploadBatchSize: 32,
   documentRecords: {
     member: {
@@ -57806,6 +58856,7 @@ var PROJECT_SCHEMA_CONTRACT = Object.freeze({
         "setterCode",
         "returnTypeInfo",
         "argumentTypes",
+        "genericParams",
         "dispatch",
         "bodyMode",
         // P97 §1.1. No normalization rule, like `distribution`: absence means
@@ -57850,6 +58901,7 @@ var PROJECT_SCHEMA_CONTRACT = Object.freeze({
         code: "nullIsAbsentOnFullMember",
         templateId: "nullIsAbsentOnFullMember",
         setterCode: "nullIsAbsentOnFullMember",
+        genericParams: "nullOrEmptyArrayIsAbsent",
         dispatch: { kind: "absentMeansDefault", defaultValue: 0 },
         bodyMode: { kind: "absentMeansDefault", defaultValue: 0 },
         uiAction: "nullIsAbsentOnFullMember"
@@ -59595,7 +60647,7 @@ var SCRIPT_COLLECTION_READERS = {
 };
 
 // ../src/models/exports/unity-codegen-revision.ts
-var UNITY_CODEGEN_REVISION = "49b24ee52b3e40b147f73d6d58f5c01eacc9f304463b8689d3d92ae57b14aef0";
+var UNITY_CODEGEN_REVISION = "edfd4061dffcd1a747b234cd135b99beca6f4cf1958cb69715029c5935dd7f1b";
 
 // src/export-cache.ts
 var CACHE_BUILD = JSON.stringify([
@@ -60042,23 +61094,53 @@ function mockResponse(environment, mock, selected, call) {
   if (selected.kind === "throw") {
     throw new NSGetterRuntimeError(selected.message);
   }
-  if (selected.kind === "implementation") {
-    return {
-      handled: true,
-      value: call.invokeDelegate(
-        bindNeoScriptDelegateToContext(
-          selected.delegate,
-          environment.context
-        ),
-        mock.isStatic ? call.args : [call.receiver, ...call.args]
-      )
-    };
-  }
   return {
     handled: true,
-    value: selected.kind === "return" ? selected.value : null
+    value: narrowMockResult(
+      environment,
+      mock,
+      call,
+      mockValue(environment, mock, selected, call)
+    )
   };
 }
+function mockValue(environment, mock, selected, call) {
+  if (selected.kind === "implementation") {
+    return call.invokeDelegate(
+      bindNeoScriptDelegateToContext(
+        selected.delegate,
+        environment.context
+      ),
+      mock.isStatic ? call.args : [call.receiver, ...call.args]
+    );
+  }
+  return selected.kind === "return" ? selected.value : null;
+}
+function narrowMockResult(environment, mock, call, value) {
+  if (call.typeArguments === void 0 || call.member === null) return value;
+  const narrowed = narrowGenericCallResult(
+    value,
+    call.member,
+    call.typeArguments,
+    environment.context
+  );
+  if ("value" in narrowed) return narrowed.value;
+  const typeArguments = call.typeArguments.map((typeInfo) => typeArgumentLabel(environment, typeInfo)).join(", ");
+  throw new NeoTestAssertionError(
+    `Mock for Function '${mock.memberId}' returned a value that isn't the return type of '${call.member.name}<${typeArguments}>'.`
+  );
+}
+function typeArgumentLabel(environment, typeInfo) {
+  const vm = environment.context.vm;
+  if (typeInfo.type === 7 /* Class */) {
+    return vm.classes.find((schemaClass2) => schemaClass2.id === typeInfo.classId)?.name ?? typeInfo.classId;
+  }
+  if (typeInfo.type === 8 /* Enum */) {
+    return vm.enums.find((e) => e.id === typeInfo.enumId)?.name ?? typeInfo.enumId;
+  }
+  if (typeInfo.type === NS_TYPE_UNKNOWN) return NS_TYPE_UNKNOWN;
+  return MemberKind[typeInfo.type];
+}
 function partialObjectMatch(actual, expected) {
   if (!isRecord4(expected)) return isDeepStrictEqual(actual, expected);
   if (!isRecord4(actual)) return false;