@neocompose/cli 0.79.1 → 0.81.0

package/dist/test-worker.mjs

@@ -1013,11 +1013,11 @@ var NeoWorldSystemClassKind = {
   ObjectCollider: "objectCollider",
   SortingGroup: "sortingGroup",
   LayerGroupBase: "layerGroupBase",
-  SpriteObject: "spriteObject",
   PlacementTile: "placementTile",
   TileLayerLink: "tileLayerLink",
   ObjectLayerLink: "objectLayerLink",
   Object: "object",
+  SpriteObject: "spriteObject",
   SmartTile: "smartTile",
   SmartTileRule: "smartTileRule",
   SmartTileNeighbor: "smartTileNeighbor",
@@ -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;
   }
@@ -7229,64 +7343,6 @@ var WORLD_SYSTEM_CLASS_DEFINITIONS = [
     modifier: 1 /* Abstract */,
     worldKind: "layerGroupBase"
   },
-  {
-    classId: "system_d48b66ab-4d59-47e7-a25a-591fe97062de",
-    name: "NeoSpriteObject",
-    extendsWorldKind: "objectBase",
-    schemaFields: [
-      {
-        memberId: "system_441cb790-a45f-4488-a5a9-6f375af6c369",
-        memberKind: "string",
-        defaultValue: "",
-        format: 1 /* Plain */,
-        distribution: 1 /* Packed */,
-        requirement: 1 /* Required */,
-        schemaKey: "Name"
-      },
-      {
-        memberId: "system_e9288ba9-f5a2-4485-8443-6afb155b31e0",
-        memberKind: "sprite",
-        defaultValue: { fileId: "", sliceIndex: 0 },
-        requirement: 1 /* Required */,
-        schemaKey: "Sprite"
-      },
-      {
-        memberId: "system_9fcab37a-9743-4e35-8eee-80cb560f1433",
-        memberKind: "bool",
-        defaultValue: false,
-        docsText: "Mirrors the sprite horizontally about its own centre. Maps to SpriteRenderer.flipX.",
-        requirement: 1 /* Required */,
-        schemaKey: "FlipX"
-      },
-      {
-        memberId: "system_ddd09f08-1656-4404-b36b-5570a4c01fcf",
-        memberKind: "bool",
-        defaultValue: false,
-        docsText: "Mirrors the sprite vertically about its own centre. Maps to SpriteRenderer.flipY.",
-        requirement: 1 /* Required */,
-        schemaKey: "FlipY"
-      },
-      {
-        memberId: "system_f2a8c86d-ace5-421b-9475-0f3f6f97b2a6",
-        memberKind: "enum",
-        defaultValue: ["system_9d607a4f-60c3-4347-94fc-f24b538bf468"],
-        docsText: "How this sprite reacts to sprite masks. Maps to SpriteRenderer.maskInteraction. The web canvas has no real sprite mask, so anything other than None previews as a distinguishable treatment rather than as the mask itself \u2014 only Unity renders the real thing.",
-        enumId: "system_4e6c4d6f-1d0b-402a-ad3a-be92242dceec",
-        requirement: 1 /* Required */,
-        schemaKey: "MaskInteraction"
-      },
-      {
-        memberId: "system_6f32f1f2-83ea-42fc-8647-34ed0946b7f1",
-        memberKind: "int",
-        defaultValue: null,
-        docsText: "Added to the object layer's sorting order; it does not replace it. The result competes with every renderer in the sorting layer, or in the enclosing sorting group, and among equal orders the renderer lower on screen draws in front. Leave unset to use the layer's order.",
-        minValue: -32768,
-        maxValue: 32767,
-        schemaKey: "SortingOrder"
-      }
-    ],
-    worldKind: "spriteObject"
-  },
   {
     classId: "system_ccc3330c-2db5-44dc-9c8e-5ebfe430dec9",
     name: "NeoPlacementTile",
@@ -7365,6 +7421,7 @@ var WORLD_SYSTEM_CLASS_DEFINITIONS = [
         memberId: "system_5a9ca1f5-a21b-4d4e-8c55-00341af594b4",
         memberKind: "list",
         defaultValue: [],
+        docsText: "The cells this object occupies, as offsets from its placement cell. An empty list occupies nothing: the object blocks no placement and answers no cell query, but a placed object still has a Cell.",
         entryMemberId: "system_96c7650a-1805-5b27-ae99-d1e49d3cb207",
         requirement: 1 /* Required */,
         schemaKey: "PlacementTiles"
@@ -7399,14 +7456,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 +7481,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 +7523,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 +7569,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"
       }
@@ -7501,6 +7606,64 @@ var WORLD_SYSTEM_CLASS_DEFINITIONS = [
     ],
     worldKind: "object"
   },
+  {
+    classId: "system_d48b66ab-4d59-47e7-a25a-591fe97062de",
+    name: "NeoSpriteObject",
+    extendsWorldKind: "object",
+    schemaFields: [
+      {
+        memberId: "system_441cb790-a45f-4488-a5a9-6f375af6c369",
+        memberKind: "string",
+        defaultValue: "",
+        format: 1 /* Plain */,
+        distribution: 1 /* Packed */,
+        requirement: 1 /* Required */,
+        schemaKey: "Name"
+      },
+      {
+        memberId: "system_e9288ba9-f5a2-4485-8443-6afb155b31e0",
+        memberKind: "sprite",
+        defaultValue: { fileId: "", sliceIndex: 0 },
+        requirement: 1 /* Required */,
+        schemaKey: "Sprite"
+      },
+      {
+        memberId: "system_9fcab37a-9743-4e35-8eee-80cb560f1433",
+        memberKind: "bool",
+        defaultValue: false,
+        docsText: "Mirrors the sprite horizontally about its own centre. Maps to SpriteRenderer.flipX.",
+        requirement: 1 /* Required */,
+        schemaKey: "FlipX"
+      },
+      {
+        memberId: "system_ddd09f08-1656-4404-b36b-5570a4c01fcf",
+        memberKind: "bool",
+        defaultValue: false,
+        docsText: "Mirrors the sprite vertically about its own centre. Maps to SpriteRenderer.flipY.",
+        requirement: 1 /* Required */,
+        schemaKey: "FlipY"
+      },
+      {
+        memberId: "system_f2a8c86d-ace5-421b-9475-0f3f6f97b2a6",
+        memberKind: "enum",
+        defaultValue: ["system_9d607a4f-60c3-4347-94fc-f24b538bf468"],
+        docsText: "How this sprite reacts to sprite masks. Maps to SpriteRenderer.maskInteraction. The web canvas has no real sprite mask, so anything other than None previews as a distinguishable treatment rather than as the mask itself \u2014 only Unity renders the real thing.",
+        enumId: "system_4e6c4d6f-1d0b-402a-ad3a-be92242dceec",
+        requirement: 1 /* Required */,
+        schemaKey: "MaskInteraction"
+      },
+      {
+        memberId: "system_6f32f1f2-83ea-42fc-8647-34ed0946b7f1",
+        memberKind: "int",
+        defaultValue: null,
+        docsText: "Added to the object layer's sorting order; it does not replace it. The result competes with every renderer in the sorting layer, or in the enclosing sorting group, and among equal orders the renderer lower on screen draws in front. Leave unset to use the layer's order.",
+        minValue: -32768,
+        maxValue: 32767,
+        schemaKey: "SortingOrder"
+      }
+    ],
+    worldKind: "spriteObject"
+  },
   {
     classId: "system_9f34deed-2616-43c9-b614-d812da89ee51",
     name: "NeoSmartTile",
@@ -9111,7 +9274,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,
@@ -11796,11 +11960,7 @@ function completeDefaultClassRecord(args) {
     if (!shouldMaterializeChildDefaultForRoot(
       args.constructorRoot,
       resolvedChildMember,
-      defaultSettlesConstruction2,
-      documentHasInitValueContent(
-        args.document,
-        resolvedChildMember.defaultValue
-      )
+      defaultSettlesConstruction2
     )) {
       continue;
     }
@@ -12228,11 +12388,6 @@ function shouldMaterializeChildDefault(member) {
   }
   return member.defaultValue !== void 0;
 }
-function shouldMaterializeConstructorChildDefault(member, isInitializer = isInitValueContent(member.defaultValue)) {
-  if (isInitializer) return true;
-  if (!isRequiredMember(member)) return false;
-  return shouldMaterializeChildDefault(member);
-}
 function skipProvidedConstructorSchemaKey(constructorRoot, schemaKey, member, defaultSettlesConstruction2, isInitializer = isInitValueContent(member.defaultValue)) {
   if (constructorRoot === void 0) return false;
   if (!constructorRoot.providedSchemaKeys.has(schemaKey)) return false;
@@ -12241,16 +12396,11 @@ function skipProvidedConstructorSchemaKey(constructorRoot, schemaKey, member, de
   }
   return !isInitializer && !defaultSettlesConstruction2;
 }
-function shouldMaterializeChildDefaultForRoot(constructorRoot, member, defaultSettlesConstruction2, isInitializer = isInitValueContent(member.defaultValue)) {
-  if (constructorRoot === void 0)
-    return shouldMaterializeChildDefault(member);
-  if (constructorRoot.omitMissingRequired === true && !defaultSettlesConstruction2) {
+function shouldMaterializeChildDefaultForRoot(constructorRoot, member, defaultSettlesConstruction2) {
+  if (constructorRoot?.omitMissingRequired === true && !defaultSettlesConstruction2) {
     return false;
   }
-  if (constructorRoot.runsMemberInitializers === true) {
-    return shouldMaterializeChildDefault(member);
-  }
-  return shouldMaterializeConstructorChildDefault(member, isInitializer);
+  return shouldMaterializeChildDefault(member);
 }
 function primitiveFallbackValue(document2, member) {
   if (isMemberBoolBase(member)) return { value: false };
@@ -12507,6 +12657,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 +13188,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 +13587,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 +14366,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 +15075,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 +15994,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 +16006,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 +16041,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;
   }
@@ -15898,7 +16236,11 @@ function buildIndex(source) {
         }
         const placement = {
           valueId,
-          isNeoObject: kinds.get(row.classId) === NeoWorldSystemClassKind.Object,
+          isNeoObject: classInheritsWorldKind(
+            row.classId,
+            NeoWorldSystemClassKind.Object,
+            relations.classesById
+          ),
           classId: row.classId,
           gridId: root.id,
           layerId,
@@ -16584,6 +16926,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 +17654,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 +18054,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 +18174,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 +18214,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 +18253,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 +18289,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 +18389,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 +18922,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 +19300,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 +20502,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 +20525,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 +20563,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 +20575,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 +20587,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 +20596,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 +20616,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 +20654,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 +20676,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 +20742,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 +20878,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 +20941,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 +21011,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 +21060,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 +21162,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 +21198,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 +21327,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 +21369,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 +21378,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 +21434,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 +21447,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 +21542,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 +21611,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 +21686,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 +21722,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 +21748,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 +22020,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 +22041,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 +22065,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 +22134,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 +22202,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 +22219,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 +22678,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 +22748,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 +22764,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 +23583,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 +23615,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 +23631,8 @@ function evaluateSystemNative(memberId, receiver, args, ctx) {
           placement,
           offsets,
           ctx.worldQueryDependencies,
-          shift
+          shift,
+          accepts
         );
         return { handled: true, value };
       }
@@ -22997,7 +23640,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 +23797,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 +24237,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 +24487,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 +24564,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 +24799,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 +24809,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 +25249,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 +26550,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 +28156,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 +28868,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 +28897,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 +28967,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 +29750,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 +29904,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 +36313,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 +36715,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 +39144,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 +39376,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 +39407,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 +39419,8 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
           scope,
           expression.pos,
           expected,
-          receiverValue
+          receiverValue,
+          expression.typeArguments
         );
       }
       case "new": {
@@ -39066,6 +39784,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 +39800,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 +39822,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 +39845,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 +39879,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 +39912,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 +39924,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 +40126,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 +41792,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 +41810,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 +41826,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 +41853,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 +41876,9 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
           argumentsList2,
           scope,
           pos,
-          false
+          false,
+          false,
+          typeArguments
         );
       const target = this.resolveImplicitCallTarget(callee.name, scope, pos);
       if (target)
@@ -41111,7 +41888,9 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
           argumentsList2,
           scope,
           pos,
-          false
+          false,
+          false,
+          typeArguments
         );
       throw new CompileError(`Unknown function '${callee.name}'`, pos);
     }
@@ -41123,6 +41902,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 +41939,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 +41997,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 +42022,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 +42054,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 +42073,9 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
           argumentsList2,
           scope,
           pos,
-          optional2
+          optional2,
+          false,
+          typeArguments
         );
       }
       if (callee.name === "Clone" && type?.kind === "class") {
@@ -42089,81 +42876,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 +42919,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 +42939,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 +42961,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 +42984,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 +43029,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 +43218,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 +44239,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 +44262,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 +44274,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 +44332,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 +44357,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 +44399,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 +44445,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 +46082,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 +46126,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 +46774,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 +46850,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 +46894,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 +48811,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 +48850,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 +49336,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 +49760,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 +49954,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 +50477,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 +50488,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") {
@@ -52812,7 +53759,6 @@ var TILE_CLASS_LEVEL_KEYS = worldSystemSchemaFieldsForKind(
 ).flatMap(
   (field) => field.mutability === 1 /* ReadOnly */ ? [field.schemaKey] : []
 );
-var WORLD_PLACEMENT_ASSET_KIND = /* @__PURE__ */ new Map([[NeoWorldSystemClassKind.Object, NeoWorldSystemClassKind.Object]]);
 
 // ../src/database/general-function-call-ir-source-recompile.ts
 var VOID_ACTION_TYPE_INFO = {
@@ -52986,6 +53932,7 @@ var SCHEMA_DOCUMENT_FIELD_CONTRACTS = {
       "setterCode",
       "returnTypeInfo",
       "argumentTypes",
+      "genericParams",
       "dispatch",
       "bodyMode",
       "effect",
@@ -53060,6 +54007,7 @@ var SCHEMA_DOCUMENT_FIELD_CONTRACTS = {
       code: "nullIsAbsentOnFullMember",
       templateId: "nullIsAbsentOnFullMember",
       setterCode: "nullIsAbsentOnFullMember",
+      genericParams: "nullOrEmptyArrayIsAbsent",
       dispatch: {
         kind: "absentMeansDefault",
         defaultValue: 0
@@ -53457,6 +54405,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 +55645,10 @@ function schemaTypeOptionsAtDepth(depth) {
       ownerClassId: nonEmptyString,
       genericParamId: nonEmptyString
     }),
+    nullableTypeSchema("functionGeneric", {
+      ownerMemberId: nonEmptyString,
+      index: pipe(number(), integer2(), minValue(0))
+    }),
     nullableTypeSchema("enum", {
       enumId: nonEmptyString
     }),
@@ -54935,10 +55894,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 +55988,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 +56456,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 +56750,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 +56902,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 +56970,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 +57115,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 +57167,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 +57846,7 @@ function interfaceFromDocument(record4, context) {
             record4,
             source.span
           ),
+          ...documentGenericParamsToManifest(member.genericParams, record4),
           deferred: ordinalValue(
             member.dispatch ?? 0,
             ["synchronous", "asynchronous"],
@@ -56848,6 +57883,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 +58796,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.81.0",
   projectFileUploadBatchSize: 32,
   documentRecords: {
     member: {
@@ -57806,6 +58846,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 +58891,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 +60637,7 @@ var SCRIPT_COLLECTION_READERS = {
 };
 
 // ../src/models/exports/unity-codegen-revision.ts
-var UNITY_CODEGEN_REVISION = "49b24ee52b3e40b147f73d6d58f5c01eacc9f304463b8689d3d92ae57b14aef0";
+var UNITY_CODEGEN_REVISION = "d4026a3848848c8507d45dd54b6d31c1a0588b17b64c35e3fe9b25c89eb2fc05";
 
 // src/export-cache.ts
 var CACHE_BUILD = JSON.stringify([
@@ -60042,23 +61084,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;