@neocompose/cli 0.76.0 → 0.76.2

package/dist/test-worker.mjs

@@ -1936,6 +1936,7 @@ var NEOSCRIPT_OPERATORS = [
 var STRING_TYPE2 = { kind: "primitive", name: "string" };
 var INT_TYPE2 = { kind: "primitive", name: "int" };
 var FLOAT_TYPE = { kind: "primitive", name: "float" };
+var DECIMAL_TYPE = { kind: "primitive", name: "decimal" };
 var BOOL_TYPE2 = { kind: "primitive", name: "bool" };
 var IMAGE_REF_TYPE = {
   kind: "primitive",
@@ -1945,6 +1946,7 @@ var SPRITE_INFO_TYPE = {
   kind: "primitive",
   name: "SpriteInfo"
 };
+var VECTOR2_TYPE = { kind: "primitive", name: "Vector2" };
 var FLOAT_OPTIONAL_TYPE = {
   kind: "primitive",
   name: "float",
@@ -2123,6 +2125,156 @@ var NEOSCRIPT_GLOBALS = [
     "Returns whether a dialogue pointer has been visited."
   )
 ];
+function scalarMethod(receiver, name, returnType, parameters, documentation) {
+  return {
+    id: `builtin:${receiver}:${name}`,
+    name,
+    kind: "method",
+    type: returnType,
+    returnType,
+    parameters,
+    documentation
+  };
+}
+var NEOSCRIPT_SCALAR_METHODS = {
+  string: [
+    scalarMethod(
+      "string",
+      "Contains",
+      BOOL_TYPE2,
+      [parameter("substring", STRING_TYPE2)],
+      "Returns true when the string contains the substring."
+    ),
+    scalarMethod(
+      "string",
+      "Replace",
+      STRING_TYPE2,
+      [parameter("search", STRING_TYPE2), parameter("replacement", STRING_TYPE2)],
+      "Returns a new string with every non-overlapping occurrence replaced using ordinal, case-sensitive matching. An empty search throws an error."
+    ),
+    scalarMethod(
+      "string",
+      "ToLower",
+      STRING_TYPE2,
+      [],
+      "Returns the string converted to lowercase."
+    ),
+    scalarMethod(
+      "string",
+      "ToUpper",
+      STRING_TYPE2,
+      [],
+      "Returns the string converted to uppercase."
+    ),
+    scalarMethod(
+      "string",
+      "Trim",
+      STRING_TYPE2,
+      [],
+      "Returns the string without leading and trailing whitespace."
+    ),
+    scalarMethod(
+      "string",
+      "StartsWith",
+      BOOL_TYPE2,
+      [parameter("prefix", STRING_TYPE2)],
+      "Returns true when the string starts with the prefix."
+    ),
+    scalarMethod(
+      "string",
+      "EndsWith",
+      BOOL_TYPE2,
+      [parameter("suffix", STRING_TYPE2)],
+      "Returns true when the string ends with the suffix."
+    )
+  ],
+  decimal: [
+    scalarMethod(
+      "decimal",
+      "ToFloat",
+      FLOAT_TYPE,
+      [],
+      "Returns the nearest float to this decimal."
+    ),
+    scalarMethod(
+      "decimal",
+      "Round",
+      DECIMAL_TYPE,
+      [parameter("digits", INT_TYPE2)],
+      "Returns this decimal rounded half-to-even to the given number of fractional digits."
+    ),
+    scalarMethod(
+      "decimal",
+      "Divide",
+      DECIMAL_TYPE,
+      [parameter("divisor", DECIMAL_TYPE), parameter("digits", INT_TYPE2)],
+      "Returns this decimal divided by the divisor, rounded half-to-even to the given number of fractional digits."
+    )
+  ],
+  float: [
+    scalarMethod(
+      "float",
+      "ToDecimal",
+      DECIMAL_TYPE,
+      [parameter("digits", INT_TYPE2)],
+      "Returns this float as a decimal with the given number of fractional digits."
+    )
+  ],
+  ImageRef: [
+    scalarMethod(
+      "ImageRef",
+      "Slice",
+      SPRITE_INFO_TYPE,
+      [parameter("index", INT_TYPE2)],
+      "Returns the sprite at the given slice index of this image."
+    )
+  ]
+};
+var NEOSCRIPT_CLASS_ID_MEMBER = "Id";
+var NEOSCRIPT_ON_CHANGED_MEMBER = "OnChanged";
+var NEOSCRIPT_CLASS_ID_SYMBOL = property(
+  "class",
+  NEOSCRIPT_CLASS_ID_MEMBER,
+  STRING_TYPE2,
+  "The stable id of this class value."
+);
+function neoScriptScalarMethod(receiver, name) {
+  return NEOSCRIPT_SCALAR_METHODS[receiver]?.find(
+    (method2) => method2.name === name
+  );
+}
+var NEOSCRIPT_PRIMITIVE_DERIVED_MEMBERS = {
+  SpriteInfo: [
+    property("SpriteInfo", "FileName", STRING_TYPE2, "Asset file name."),
+    property("SpriteInfo", "Name", STRING_TYPE2, "Sprite name."),
+    property("SpriteInfo", "Size", VECTOR2_TYPE, "Sprite size."),
+    property("SpriteInfo", "Pivot", VECTOR2_TYPE, "Sprite pivot."),
+    property(
+      "SpriteInfo",
+      "Slices",
+      { kind: "list", elementType: SPRITE_INFO_TYPE, readOnly: true },
+      "All slices in the source asset."
+    )
+  ],
+  AudioClipInfo: [
+    property("AudioClipInfo", "FileId", STRING_TYPE2, "Asset file id."),
+    property("AudioClipInfo", "Name", STRING_TYPE2, "Audio clip name."),
+    property(
+      "AudioClipInfo",
+      "DurationSeconds",
+      FLOAT_OPTIONAL_TYPE,
+      "Audio duration in seconds when known."
+    )
+  ],
+  NeoDialogueReference: [
+    property("NeoDialogueReference", "id", STRING_TYPE2, "Dialogue id.")
+  ]
+};
+function neoScriptPrimitiveDerivedMember(receiver, name) {
+  return NEOSCRIPT_PRIMITIVE_DERIVED_MEMBERS[receiver]?.find(
+    (member) => member.name === name
+  );
+}
 function property(owner, name, type, documentation, writable = false) {
   return {
     id: `builtin:${owner}:property:${name}`,
@@ -2187,53 +2339,21 @@ var NEOSCRIPT_BUILTIN_TYPE_SYMBOLS = [
       // `FileId` and `SliceIndex` come from the field table above — they are
       // the writable, addressable fields, not derived properties (D11).
       ...structuredLeafFieldProperties("SpriteInfo"),
-      property("SpriteInfo", "FileName", STRING_TYPE2, "Asset file name."),
-      property("SpriteInfo", "Name", STRING_TYPE2, "Sprite name."),
-      property(
-        "SpriteInfo",
-        "Size",
-        { kind: "named", typeId: "builtin:Vector2" },
-        "Sprite size."
-      ),
-      property(
-        "SpriteInfo",
-        "Pivot",
-        { kind: "named", typeId: "builtin:Vector2" },
-        "Sprite pivot."
-      ),
-      property(
-        "SpriteInfo",
-        "Slices",
-        {
-          kind: "list",
-          elementType: { kind: "named", typeId: "builtin:SpriteInfo" },
-          readOnly: true
-        },
-        "All slices in the source asset."
-      )
+      ...NEOSCRIPT_PRIMITIVE_DERIVED_MEMBERS.SpriteInfo
     ]
   },
   {
     id: "builtin:AudioClipInfo",
     name: "AudioClipInfo",
     kind: "builtin",
-    members: [
-      property("AudioClipInfo", "FileId", STRING_TYPE2, "Asset file id."),
-      property("AudioClipInfo", "Name", STRING_TYPE2, "Audio clip name."),
-      property(
-        "AudioClipInfo",
-        "DurationSeconds",
-        FLOAT_OPTIONAL_TYPE,
-        "Audio duration in seconds when known."
-      )
-    ]
+    members: NEOSCRIPT_PRIMITIVE_DERIVED_MEMBERS.AudioClipInfo
   },
   {
     id: "builtin:NeoDialogueReference",
     name: "NeoDialogueReference",
     kind: "builtin",
     members: [
-      property("NeoDialogueReference", "id", STRING_TYPE2, "Dialogue id."),
+      ...NEOSCRIPT_PRIMITIVE_DERIVED_MEMBERS.NeoDialogueReference,
       ...neoScriptDialogueReferenceMethods("builtin:NeoDialogueReference")
     ]
   },
@@ -5295,6 +5415,9 @@ var ProjectSchemaIndex = class {
     for (const schemaClass2 of source.classes) {
       this.classesById.set(schemaClass2.id, schemaClass2);
       append(this.classesByName, schemaClass2.name, schemaClass2);
+      if (schemaClass2.extendsClassId) {
+        append(this.subclassesById, schemaClass2.extendsClassId, schemaClass2);
+      }
       for (const [schemaKey, memberId] of Object.entries(schemaClass2.schema)) {
         append(this.schemaPlacementsByMemberId, memberId, {
           ownerClass: schemaClass2,
@@ -5339,6 +5462,8 @@ var ProjectSchemaIndex = class {
   source;
   classesById = /* @__PURE__ */ new Map();
   classesByName = /* @__PURE__ */ new Map();
+  /** Direct subclasses by the class they extend. */
+  subclassesById = /* @__PURE__ */ new Map();
   membersById = /* @__PURE__ */ new Map();
   membersByName = /* @__PURE__ */ new Map();
   enumsById = /* @__PURE__ */ new Map();
@@ -5523,6 +5648,9 @@ function indexSchema(classes, members) {
 function classIndexFor(classes) {
   return indexClasses(classes).classesById;
 }
+function subclassIndexFor(classes) {
+  return indexClasses(classes).subclassesById;
+}
 function memberIndexFor(members) {
   return projectSchemaIndexFor({ classes: NO_CLASSES, members }).membersById;
 }
@@ -5724,15 +5852,7 @@ function resolveMemberWithIndex(member, memberIndex) {
   return Object.freeze(merged);
 }
 function descendantClassIds(classId, allClasses) {
-  const childrenByClassId = /* @__PURE__ */ new Map();
-  for (const schemaClass2 of allClasses) {
-    if (!schemaClass2.extendsClassId) continue;
-    const children = childrenByClassId.get(schemaClass2.extendsClassId);
-    if (children === void 0) {
-      childrenByClassId.set(schemaClass2.extendsClassId, [schemaClass2]);
-    } else children.push(schemaClass2);
-  }
-  return descendantClassIdsInChildIndex(classId, childrenByClassId);
+  return descendantClassIdsInChildIndex(classId, subclassIndexFor(allClasses));
 }
 function descendantClassIdsInChildIndex(classId, childrenByClassId) {
   const result = /* @__PURE__ */ new Set();
@@ -10667,103 +10787,204 @@ function buildDefaultClassMaterializationPlan(document2, classId, instanceEnv) {
     ...document2,
     constructors: document2.constructors ?? []
   });
-  const merged = document2.storedInstanceSchema?.(classId) ?? mergeInstanceSurfaceSchema(classId, document2.classes, document2.members);
-  return merged.flatMap((entry) => {
-    if (entry.memberId === null) return [];
-    const childMember = findMemberInDocument(document2, entry.memberId);
-    if (!memberKindOwnsStoredValue(childMember.kind)) return [];
-    if (instanceEnv.size === 0 && isImmutableConstantMember(
-      document2,
-      document2.resolvedMember?.(childMember) ?? resolveMember(childMember, document2.members)
-    ))
-      return [];
-    const member = substituteMember(
-      childMember,
-      instanceEnv,
-      document2.members,
-      document2.resolvedMember?.(childMember)
-    );
-    return [
-      {
-        schemaKey: entry.schemaKey,
-        member,
-        defaultSettlesConstruction: settlesConstruction(member, instanceEnv),
-        directScalarBody: directScalarDefaultBody(document2, member)
-      }
-    ];
-  });
+  return storedSchemaOf(document2, classId).flatMap(
+    (entry) => {
+      if (entry.memberId === null) return [];
+      const childMember = findMemberInDocument(document2, entry.memberId);
+      if (!memberKindOwnsStoredValue(childMember.kind)) return [];
+      if (instanceEnv.size === 0 && isConstantMember(document2, resolvedInDocument(document2, childMember)))
+        return [];
+      const member = substituteMember(
+        childMember,
+        instanceEnv,
+        document2.members,
+        document2.resolvedMember?.(childMember)
+      );
+      return [
+        {
+          schemaKey: entry.schemaKey,
+          member,
+          defaultSettlesConstruction: settlesConstruction(member, instanceEnv),
+          directScalarBody: directScalarDefaultBody(document2, member)
+        }
+      ];
+    }
+  );
 }
-function isImmutableConstantMember(document2, resolved) {
-  if (resolved.storage !== 1 /* Immutable */) return false;
+function isConstantMember(document2, resolved) {
   if (isStaticMember(resolved)) return false;
+  const fixedness = fixednessOf(resolved, 0 /* Writable */);
+  if (fixedness === 0 /* Writable */) return false;
   const declared = resolved.defaultValue;
   if (declared == null) return false;
-  return !declarationReadsInstance(
-    { document: document2, visited: /* @__PURE__ */ new Set() },
+  if (fixedness === 1 /* ReadOnly */ && (isMemberListBase(resolved) || isMemberDictionaryBase(resolved)))
+    return false;
+  return !declarationVaries(
+    {
+      document: document2,
+      rows: /* @__PURE__ */ new Set(),
+      declarations: /* @__PURE__ */ new Set(),
+      classes: /* @__PURE__ */ new Set()
+    },
     resolved,
     declared,
-    null
+    null,
+    { fixedness, ownsReads: true }
   );
 }
-function declarationReadsInstance(walk, member, body, rowId) {
+function fixednessOf(resolved, parent) {
+  const storage = resolved.storage ?? 0 /* Inherit */;
+  if (storage === 1 /* Immutable */) return 2 /* Immutable */;
+  if (storage === 0 /* Inherit */ && parent === 2 /* Immutable */)
+    return 2 /* Immutable */;
+  return isReadOnlyMember(resolved) ? 1 /* ReadOnly */ : 0 /* Writable */;
+}
+function scopeKey(id, scope) {
+  return `${id}:${scope.fixedness}:${scope.ownsReads}`;
+}
+function resolvedInDocument(document2, member) {
+  return document2.resolvedMember?.(member) ?? resolveMember(member, document2.members);
+}
+function declarationVaries(walk, member, body, rowId, scope) {
   const { document: document2 } = walk;
+  const { ownsReads } = scope;
+  const immutable2 = scope.fixedness === 2 /* Immutable */;
   if (documentHasInitValueContent(document2, body)) {
-    const compiled = body.init.compiled;
-    if (compiled === void 0) return true;
-    const instanceParameters = /* @__PURE__ */ new Set();
-    for (const parameter3 of compiled.parameters) {
-      if (parameter3.id !== "__root__") instanceParameters.add(parameter3.id);
-    }
-    return irReadsInstance(
-      compiled.instructions,
-      instanceParameters,
-      /* @__PURE__ */ new Set()
-    );
+    if (!immutable2) return true;
+    if (ownsReads) {
+      const compiled = body.init.compiled;
+      if (compiled === void 0) return true;
+      if (initializerReadsInstance(compiled)) return true;
+    }
+    return typeHoldsWritable(walk, member, 2 /* Immutable */);
   }
   if (!isLiteralValueContent(body)) return true;
-  if (irReadsInstance(body.constructorArgs, /* @__PURE__ */ new Set(), /* @__PURE__ */ new Set())) return true;
+  if (!immutable2 && body.instanceConstructorId !== void 0) return true;
+  if (!immutable2 && body.constructorArgs != null) return true;
+  if (ownsReads && irReadsInstance(body.constructorArgs, /* @__PURE__ */ new Set(), /* @__PURE__ */ new Set()))
+    return true;
   const value = body.value;
-  const ownedEntry = (entryMember) => (valueId) => typeof valueId !== "string" || rowReadsInstance(walk, entryMember, valueId);
   if (isMemberClassBase(member)) {
     if (value === null) return false;
     if (!isStringRecord(value)) return true;
     const classId = typeof body.classId === "string" ? body.classId : member.classId;
-    const entries = getSchemaEntryMap(document2, classId);
-    for (const [schemaKey, valueId] of Object.entries(value)) {
-      const memberId = entries.get(schemaKey)?.memberId;
-      if (memberId == null) return true;
-      const child = findMemberInDocument(document2, memberId);
-      if (ownedEntry(child)(valueId)) return true;
+    let owned = 0;
+    for (const entry of storedSchemaOf(document2, classId)) {
+      if (entry.memberId === null) continue;
+      const child = resolvedInDocument(
+        document2,
+        findMemberInDocument(document2, entry.memberId)
+      );
+      const childId = value[entry.schemaKey];
+      if (childId !== void 0) owned++;
+      else if (!memberKindOwnsStoredValue(child.kind) || isStaticMember(child))
+        continue;
+      const fixedness = fixednessOf(child, scope.fixedness);
+      if (fixedness === 0 /* Writable */) return true;
+      if (childId !== void 0) {
+        if (rowVaries(walk, child, childId, { fixedness, ownsReads }))
+          return true;
+        continue;
+      }
+      const declared = child.defaultValue;
+      if (declared == null) continue;
+      const childScope = { fixedness, ownsReads: false };
+      const key = scopeKey(entry.memberId, childScope);
+      if (walk.declarations.has(key)) continue;
+      walk.declarations.add(key);
+      if (declarationVaries(walk, child, declared, null, childScope))
+        return true;
     }
-    return false;
+    return owned !== Object.keys(value).length;
   }
   if (isMemberListBase(member)) {
-    const entryMember = findMemberInDocument(document2, member.entryMemberId);
     const entryIds = listKindOf(member) !== 1 /* Unordered */ ? value : rowId === null ? [] : document2.unorderedListEntryIds?.(rowId) ?? (walk.membership ??= buildUnorderedListMembershipIndex(
       document2.values
     )).get(rowId) ?? [];
     if (entryIds === null) return false;
-    return !Array.isArray(entryIds) || entryIds.some(ownedEntry(entryMember));
+    if (!Array.isArray(entryIds)) return true;
+    return entriesVary(walk, member.entryMemberId, entryIds, scope);
   }
   if (isMemberDictionaryBase(member)) {
     if (value === null) return false;
     if (!isStringRecord(value)) return true;
-    const entryMember = findMemberInDocument(document2, member.entryMemberId);
-    return Object.values(value).some(ownedEntry(entryMember));
+    return entriesVary(walk, member.entryMemberId, Object.values(value), scope);
   }
   if (member.kind === 21 /* Generic */) return true;
-  return irReadsInstance(value, /* @__PURE__ */ new Set(), /* @__PURE__ */ new Set());
+  return ownsReads && irReadsInstance(value, /* @__PURE__ */ new Set(), /* @__PURE__ */ new Set());
+}
+function entriesVary(walk, entryMemberId, entryIds, scope) {
+  if (entryIds.length === 0) return false;
+  const entryMember = resolvedInDocument(
+    walk.document,
+    findMemberInDocument(walk.document, entryMemberId)
+  );
+  const fixedness = fixednessOf(entryMember, scope.fixedness);
+  if (fixedness === 0 /* Writable */) return true;
+  const entryScope = { fixedness, ownsReads: scope.ownsReads };
+  return entryIds.some(
+    (entryId) => typeof entryId !== "string" || rowVaries(walk, entryMember, entryId, entryScope)
+  );
 }
-function rowReadsInstance(walk, member, valueId) {
-  if (walk.visited.has(valueId)) return false;
-  walk.visited.add(valueId);
+function rowVaries(walk, member, valueId, scope) {
+  const key = scopeKey(valueId, scope);
+  if (walk.rows.has(key)) return false;
+  walk.rows.add(key);
   const { document: document2 } = walk;
   const row = document2.valueById?.(valueId) ?? (walk.rowById ??= new Map(
     document2.values.map((value) => [value.id, value])
   )).get(valueId);
   if (row === void 0 || row === null) return true;
-  const resolved = document2.resolvedMember?.(member) ?? resolveMember(member, document2.members);
-  return declarationReadsInstance(walk, resolved, row, row.id);
+  return declarationVaries(walk, member, row, row.id, scope);
+}
+function typeHoldsWritable(walk, member, fixedness) {
+  if (isMemberClassBase(member)) {
+    const { classes } = walk.document;
+    if (!classIndexFor(classes).has(member.classId)) return true;
+    if (classHoldsWritable(walk, member.classId, fixedness)) return true;
+    for (const classId of descendantClassIds(member.classId, classes)) {
+      if (classHoldsWritable(walk, classId, fixedness)) return true;
+    }
+    return false;
+  }
+  if (isMemberListBase(member) || isMemberDictionaryBase(member)) {
+    const entryMember = resolvedInDocument(
+      walk.document,
+      findMemberInDocument(walk.document, member.entryMemberId)
+    );
+    const entryFixedness = fixednessOf(entryMember, fixedness);
+    return entryFixedness === 0 /* Writable */ || typeHoldsWritable(walk, entryMember, entryFixedness);
+  }
+  return member.kind === 21 /* Generic */;
+}
+function classHoldsWritable(walk, classId, fixedness) {
+  const key = `${classId}:${fixedness}`;
+  if (walk.classes.has(key)) return false;
+  walk.classes.add(key);
+  const { document: document2 } = walk;
+  for (const entry of storedSchemaOf(document2, classId)) {
+    if (entry.memberId === null) continue;
+    const child = resolvedInDocument(
+      document2,
+      findMemberInDocument(document2, entry.memberId)
+    );
+    if (!memberKindOwnsStoredValue(child.kind) || isStaticMember(child))
+      continue;
+    const childFixedness = fixednessOf(child, fixedness);
+    if (childFixedness === 0 /* Writable */) return true;
+    if (typeHoldsWritable(walk, child, childFixedness)) return true;
+  }
+  return false;
+}
+function storedSchemaOf(document2, classId) {
+  return document2.storedInstanceSchema?.(classId) ?? resolvedClassSchema(classId, document2.classes, document2.members).surface;
+}
+function initializerReadsInstance(compiled) {
+  const instanceParameters = /* @__PURE__ */ new Set();
+  for (const parameter3 of compiled.parameters) {
+    if (parameter3.id !== "__root__") instanceParameters.add(parameter3.id);
+  }
+  return irReadsInstance(compiled.instructions, instanceParameters, /* @__PURE__ */ new Set());
 }
 function irReadsInstance(value, instanceParameters, visited) {
   if (typeof value !== "object" || value === null) return false;
@@ -15468,7 +15689,9 @@ function readClassMember(args) {
   const expanded = args.expandedRecord();
   if (expanded !== null && Object.prototype.hasOwnProperty.call(expanded, schemaKey))
     return { kind: "value", value: Reflect.get(expanded, schemaKey) };
-  if (args.mode !== "resolved" && declaration !== void 0)
+  if (args.mode === "resolved")
+    return declaration !== void 0 && args.isConstant() ? { kind: "declaration", content: declaration } : { kind: "missing" };
+  if (declaration !== void 0)
     return { kind: "declaration", content: declaration };
   if (args.mode === "runtime" && !isRequiredMember(member))
     return { kind: "null" };
@@ -16974,6 +17197,7 @@ function withEvaluationRuntime(ctx, writes) {
       constructionTimestamp: Date.now(),
       ownedValueAttachments: /* @__PURE__ */ new Map(),
       constructionStack: [],
+      openConstructions: /* @__PURE__ */ new Map(),
       loopIterations: 0,
       budgetedConstructedRowIds: /* @__PURE__ */ new Set(),
       budgetedProducedEntriesByRowId: /* @__PURE__ */ new Map(),
@@ -18109,14 +18333,16 @@ function evalInstructions(instructions, scope, ctx, options) {
             };
           }
           const assignedReferenceValueId = targetTypeInfo.type === 7 /* Class */ || targetTypeInfo.type === 6 /* List */ || targetTypeInfo.type === 5 /* Dictionary */ ? findKnownRowIdByValueReference(value, ctx) : null;
-          applyOverlayAssignment(
-            ins.target.pointer,
-            targetTypeInfo,
-            value,
-            scope,
-            ctx,
-            destination
-          );
+          if (!bindOmittedConstantSlot(destination, member, value, ctx)) {
+            applyOverlayAssignment(
+              ins.target.pointer,
+              targetTypeInfo,
+              value,
+              scope,
+              ctx,
+              destination
+            );
+          }
           const unorderedReplacement = assignedReferenceValueId === null && member !== null && isMemberListBase(member) && listKindOf(member) === 1 /* Unordered */ && Array.isArray(value) ? unorderedReplacementProjection(
             ins.target.pointer,
             destination,
@@ -18971,6 +19197,36 @@ function applyOverlayStaticAssignment(memberId, value, ctx) {
   bindings.set(member.id, row.id);
   invalidateEvaluatorIndexes(ctx);
 }
+function bindOmittedConstantSlot(destination, member, value, ctx) {
+  if (destination === void 0 || member === null) return false;
+  const { receiver } = destination;
+  if (typeof receiver !== "object" || receiver === null) return false;
+  const construction = ctx.__executionState?.openConstructions.get(receiver);
+  if (construction === void 0) return false;
+  const key = String(destination.key);
+  if (Object.prototype.hasOwnProperty.call(receiver, key)) return false;
+  if (isMemberClassBase(member) || isMemberListBase(member) || isMemberDictionaryBase(member))
+    return false;
+  const resolved = resolveMember(member, ctx.vm.members);
+  if (!isConstantMember(constructorDefaultValueDocument(ctx, member), resolved))
+    return false;
+  const { createdValues } = construction;
+  const staged = createdValues.length;
+  const row = materializeConstructorArgumentValue({
+    member: resolved,
+    value,
+    // A constant has no instance environment.
+    genericEnv: /* @__PURE__ */ new Map(),
+    ctx,
+    createdValues,
+    createdById: /* @__PURE__ */ new Map(),
+    storageKeyDeclarations: construction.storageKeyDeclarations
+  });
+  stageConstructedRows(createdValues.slice(staged), ctx);
+  Reflect.set(receiver, key, row.id);
+  invalidateEvaluatorIndexes(ctx, receiver);
+  return true;
+}
 function touchUnknown(_ins) {
   void _ins;
 }
@@ -21358,7 +21614,7 @@ function readDeclarationDefault(member, ctx) {
       };
     }
     const document2 = constructorDefaultValueDocument(ctx, member);
-    const constant = shared !== void 0 && known !== false && (known !== void 0 || isImmutableConstantMember(document2, member));
+    const constant = shared !== void 0 && known !== false && (known !== void 0 || isConstantMember(document2, member));
     if (shared !== void 0 && !constant) shared.set(member.id, false);
     const created = [];
     const closeFrame = pushConstructionFrame(ctx, `${member.name} declaration`);
@@ -24713,6 +24969,11 @@ function evaluateInitializerInContext(init, member, ctx, createdValues, argument
         sessionValueExport: "defer"
       }
     );
+  } catch (error) {
+    const ownerId = compileMemberId ?? Reflect.get(member, "id");
+    if (error instanceof NSGetterRuntimeError && sourceValueId === null && typeof ownerId === "string")
+      error.sourceOwnerId ??= ownerId;
+    throw error;
   } finally {
     closeFrame();
   }
@@ -25865,39 +26126,50 @@ function constructDeclaredClassValueWithinFrame(descriptor, record4, info, scope
   stageConstructedRows(createdValues, ctx);
   bindConstructedDelegateTargets(createdValues, ctx);
   if (record4 !== null) {
-    runDeclaredConstructorChain({
-      record: record4,
-      argumentValues,
-      preparedArgumentScopes,
-      thisValue: root.value,
-      ctx,
-      visitedConstructorIds: /* @__PURE__ */ new Set(),
-      applyBaseInitializerBlock: (chainRecord, chainArguments, chainThisValue) => {
-        const supplied2 = evaluateBaseInitializerFields({
-          record: chainRecord,
-          argumentValues: chainArguments,
-          thisValue: chainThisValue,
-          constructedClassId: classId,
-          instanceEnv: descriptor.instanceEnv,
-          ctx
-        });
-        if (supplied2.length === 0) return;
-        applyConstructorFields({
-          supplied: supplied2,
-          root,
-          rootRecord,
-          schemaClass: schemaClass2,
-          instanceEnv: descriptor.instanceEnv,
-          createdValues,
-          createdById: new Map(createdValues.map((row) => [row.id, row])),
-          storageKeyDeclarations,
-          // §1.5 base blocks are assignments, not omissions: an explicit null
-          // clears the slot exactly as a call-site block entry does.
-          nullMeansOmit: false,
-          ctx
-        });
-      }
+    const openConstructions = ctx.__executionState?.openConstructions;
+    openConstructions?.set(rootRecord, {
+      createdValues,
+      storageKeyDeclarations
     });
+    try {
+      runDeclaredConstructorChain({
+        record: record4,
+        argumentValues,
+        preparedArgumentScopes,
+        thisValue: root.value,
+        ctx,
+        visitedConstructorIds: /* @__PURE__ */ new Set(),
+        applyBaseInitializerBlock: (chainRecord, chainArguments, chainThisValue) => {
+          const supplied2 = evaluateBaseInitializerFields({
+            record: chainRecord,
+            argumentValues: chainArguments,
+            thisValue: chainThisValue,
+            constructedClassId: classId,
+            instanceEnv: descriptor.instanceEnv,
+            ctx
+          });
+          if (supplied2.length === 0) return;
+          const staged = createdValues.length;
+          applyConstructorFields({
+            supplied: supplied2,
+            root,
+            rootRecord,
+            schemaClass: schemaClass2,
+            instanceEnv: descriptor.instanceEnv,
+            createdValues,
+            createdById: new Map(createdValues.map((row) => [row.id, row])),
+            storageKeyDeclarations,
+            // §1.5 base blocks are assignments, not omissions: an explicit null
+            // clears the slot exactly as a call-site block entry does.
+            nullMeansOmit: false,
+            ctx
+          });
+          stageConstructedRows(createdValues.slice(staged), ctx);
+        }
+      });
+    } finally {
+      openConstructions?.delete(rootRecord);
+    }
   }
   const supplied = evaluateConstructorFields(descriptor, scope, ctx);
   try {
@@ -29272,11 +29544,8 @@ var Parser = class _Parser {
    * always opens with a type expression, which can be:
    *   - A primitive keyword: int / float / bool / string
    *   - `Dictionary` keyword followed by `<`
-   *   - An identifier (Class or Enum) with `[]` suffix or
-   *     followed by another identifier (the var name).
-   *
-   * We don't fully parse the type here — we just decide whether to commit
-   * to the varDecl path or fall through to an expression statement.
+   *   - Any other type the type grammar parses (`Item[]`, `Box<int>?`,
+   *     `NeoDelegate<int, int>`) followed by the var name and `=`.
    */
   looksLikeVarDecl() {
     const t = this.peek();
@@ -29293,25 +29562,53 @@ var Parser = class _Parser {
       return true;
     }
     if (!isIdentifier(t)) return false;
-    let j = this.i + 1;
-    const tk = (k) => this.tokens[k];
-    while (tk(j)?.kind === "punctuation" && tk(j)?.text === "[" && tk(j + 1)?.kind === "punctuation" && tk(j + 1)?.text === "]") {
-      j += 2;
-    }
-    if (tk(j)?.kind === "operator" && tk(j)?.text === "?") {
-      j += 1;
-    }
-    const name = tk(j);
-    if (name !== void 0 && isIdentifier(name) && tk(j + 1)?.kind === "operator" && tk(j + 1)?.text === "=") {
-      return true;
+    const end = this.typeEnd();
+    const name = this.tokens[end];
+    const equals = this.tokens[end + 1];
+    return end >= 0 && name !== void 0 && isIdentifier(name) && equals?.kind === "operator" && equals.text === "=";
+  }
+  /**
+   * Token index just past the type that starts at the cursor, or -1 when the
+   * type grammar rejects it. The cursor does not move. Editor recovery shares
+   * this with declaration lookahead so both agree on every type form.
+   */
+  typeEnd(options = {}) {
+    const start = this.i;
+    this.probingType = true;
+    try {
+      return this.parseTypeOrFail(options) ? this.i : -1;
+    } catch {
+      return -1;
+    } finally {
+      this.probingType = false;
+      this.i = start;
     }
-    return false;
+  }
+  /**
+   * True while `typeEnd` probes. Lookahead runs at every identifier on editor
+   * paths, so a rejected type returns null instead of constructing an error.
+   */
+  probingType = false;
+  /** A type-grammar failure: null while probing, otherwise a CompileError. */
+  typeFailure(message, token) {
+    if (this.probingType) return null;
+    throw new CompileError(message, at(token));
+  }
+  /** `expect` inside the type grammar: false while probing a mismatch. */
+  expectTypeToken(kind, text) {
+    if (this.probingType && !tokenMatches(this.peek(), kind, text))
+      return false;
+    this.expect(kind, text);
+    return true;
   }
   // ------------------------------------------------------------------
   // Types
   // ------------------------------------------------------------------
   /** Parses a type annotation (used in varDecls and Dictionary generics). */
   parseType(options = {}) {
+    return this.parseTypeOrFail(options);
+  }
+  parseTypeOrFail(options) {
     const startPos = at(this.peek());
     let inner;
     const t = this.peek();
@@ -29325,17 +29622,18 @@ var Parser = class _Parser {
       };
     } else if (t.kind === "type" && (t.text === "Dictionary" || t.text === "List" || t.text === "Set")) {
       this.next();
-      this.expect("operator", "<");
+      if (!this.expectTypeToken("operator", "<")) return null;
       if (t.text === "Dictionary") {
-        const key = this.parseType();
+        const key = this.parseTypeOrFail({});
+        if (!key) return null;
         if (this.peek().text === ">")
-          throw new CompileError(
+          return this.typeFailure(
             "Dictionary requires a key type and a value type, for example Dictionary<string, int>.",
-            at(this.peek())
+            this.peek()
           );
-        this.expect("punctuation", ",");
-        const value = this.parseType();
-        this.expect("operator", ">");
+        if (!this.expectTypeToken("punctuation", ",")) return null;
+        const value = this.parseTypeOrFail({});
+        if (!value || !this.expectTypeToken("operator", ">")) return null;
         inner = {
           kind: "dict",
           key,
@@ -29344,8 +29642,8 @@ var Parser = class _Parser {
           pos: startPos
         };
       } else {
-        const element = this.parseType();
-        this.expect("operator", ">");
+        const element = this.parseTypeOrFail({});
+        if (!element || !this.expectTypeToken("operator", ">")) return null;
         inner = {
           kind: t.text === "List" ? "list" : "set",
           element,
@@ -29357,10 +29655,12 @@ var Parser = class _Parser {
       this.next();
       const typeArguments = [];
       if (this.eat("operator", "<")) {
-        typeArguments.push(this.parseType());
-        while (this.eat("punctuation", ","))
-          typeArguments.push(this.parseType());
-        this.expect("operator", ">");
+        do {
+          const argument2 = typeArguments.length === 0 && t.text === "NeoDelegate" ? this.parseDelegateReturnType() : this.parseTypeOrFail({});
+          if (!argument2) return null;
+          typeArguments.push(argument2);
+        } while (this.eat("punctuation", ","));
+        if (!this.expectTypeToken("operator", ">")) return null;
       }
       inner = {
         kind: "named",
@@ -29370,7 +29670,7 @@ var Parser = class _Parser {
         pos: startPos
       };
     } else {
-      throw new CompileError(`Expected a type, got ${describeToken(t)}`, at(t));
+      return this.typeFailure(`Expected a type, got ${describeToken(t)}`, t);
     }
     while (this.peek().kind === "punctuation" && this.peek().text === "[" && this.peek(1).kind === "punctuation" && this.peek(1).text === "]") {
       const arrPos = at(this.peek());
@@ -29389,6 +29689,14 @@ var Parser = class _Parser {
     }
     return inner;
   }
+  /** `NeoDelegate<void, …>`: the return slot is the one type that may be `void`. */
+  parseDelegateReturnType() {
+    const t = this.peek();
+    if (t.kind !== "keyword" || t.text !== "void")
+      return this.parseTypeOrFail({});
+    this.next();
+    return { kind: "primitive", name: "void", required: true, pos: at(t) };
+  }
   /**
    * `is T ? a : b` is ambiguous at the token level because `?` is also the
    * nullable type suffix. A colon at the same delimiter depth makes it the
@@ -29743,7 +30051,7 @@ var Parser = class _Parser {
     }
     while (true) {
       let name = null;
-      if ((isIdentifier(this.peek()) || this.peek().kind === "keyword" && (this.peek().text === "default" || isValidNeoProjectIdentifier(this.peek().text))) && this.peek(1).kind === "punctuation" && this.peek(1).text === ":") {
+      if (isCallArgumentLabelToken(this.peek()) && this.peek(1).kind === "punctuation" && this.peek(1).text === ":") {
         name = this.next().text;
         this.next();
       }
@@ -30226,6 +30534,9 @@ function at(token) {
 function tokenMatches(token, kind, text) {
   return (kind === "identifier" ? isIdentifier(token) : token.kind === kind) && (text === void 0 || token.text === text);
 }
+function isCallArgumentLabelToken(token) {
+  return isIdentifier(token) || token.kind === "keyword" && (token.text === "default" || isValidNeoProjectIdentifier(token.text));
+}
 function isIdentifier(token) {
   return token.kind === "identifier" || token.kind === "type" && token.text !== "int" && token.text !== "float" && token.text !== "decimal" && token.text !== "bool" && token.text !== "string" && token.text !== "Dictionary" && token.text !== "List" && token.text !== "Set";
 }
@@ -32829,6 +33140,9 @@ function evaluateMemberInitializer(args) {
     } catch (error) {
       if (error instanceof NSGetterRuntimeError) {
         error.initializerValueId ??= args.sourceValueId ?? void 0;
+        const memberId = Reflect.get(args.member, "id");
+        if (args.sourceValueId == null && typeof memberId === "string")
+          error.sourceOwnerId ??= memberId;
       }
       throw error;
     }
@@ -33093,6 +33407,9 @@ function buildNeoScriptEditorIndex(lexed, kind) {
   const references = [];
   const calls = [];
   const switches = [];
+  const lambdaBodies = [];
+  const contextualKeywordRanges = [];
+  const objectInitializers = [];
   for (const executable of executableRegions) {
     const executablePairs = pairBrackets(executable);
     const regionSwitches = indexSwitchStatements(
@@ -33102,7 +33419,13 @@ function buildNeoScriptEditorIndex(lexed, kind) {
       diagnostics
     );
     const regionLocals = applySwitchSectionScopes(
-      indexLocals(executable, executablePairs, lexed, diagnostics),
+      indexLocals(
+        executable,
+        executablePairs,
+        lexed,
+        diagnostics,
+        lambdaBodies
+      ),
       regionSwitches,
       lexed
     );
@@ -33113,24 +33436,36 @@ function buildNeoScriptEditorIndex(lexed, kind) {
       )
     );
     const contextualKeywords = new Set(
-      [
-        ...regionLocals.flatMap(
-          (local) => local.contextualKeywordRange ? [local.contextualKeywordRange] : []
-        ),
-        ...regionCalls.flatMap(
-          (call) => call.contextualKeywordRange ? [call.contextualKeywordRange] : []
-        )
-      ].map((range2) => `${range2.start.line}:${range2.start.character}`)
+      regionLocals.flatMap(
+        (local) => local.contextualKeywordRange ? [local.contextualKeywordRange] : []
+      ).map((range2) => `${range2.start.line}:${range2.start.character}`)
     );
     locals.push(...regionLocals);
     references.push(
-      ...indexReferences(executable, declarations, contextualKeywords)
+      ...indexReferences(
+        executable,
+        executablePairs,
+        declarations,
+        contextualKeywords,
+        contextualKeywordRanges,
+        objectInitializers
+      )
     );
     calls.push(...regionCalls);
     switches.push(...regionSwitches);
     validateTerminatedStatements(executable, diagnostics);
   }
-  return { units, locals, references, calls, switches, diagnostics };
+  return {
+    units,
+    locals,
+    references,
+    calls,
+    switches,
+    lambdaBodies,
+    contextualKeywordRanges,
+    objectInitializers,
+    diagnostics
+  };
 }
 function indexUnits(tokens, pairs, kind, lexed) {
   if (kind !== "property") {
@@ -33547,8 +33882,9 @@ function duplicateUnitDiagnostic(label, units, diagnostics) {
     ]
   });
 }
-function indexLocals(tokens, pairs, lexed, diagnostics) {
+function indexLocals(tokens, pairs, lexed, diagnostics, lambdaBodies) {
   const locals = [];
+  const braceScope = braceScopeIndex(tokens, lexed.end);
   for (let index = 0; index < tokens.length; index++) {
     const caught = tryParseCatchParameter(tokens, index, pairs, lexed);
     if (caught) {
@@ -33556,7 +33892,14 @@ function indexLocals(tokens, pairs, lexed, diagnostics) {
       index = caught.resumeTokenIndex;
       continue;
     }
-    const loop = tryParseLoopLocal(tokens, index, pairs, lexed, diagnostics);
+    const loop = tryParseLoopLocal(
+      tokens,
+      index,
+      pairs,
+      lexed,
+      diagnostics,
+      braceScope
+    );
     if (loop) {
       locals.push(...loop.locals);
       index = loop.resumeTokenIndex;
@@ -33565,10 +33908,16 @@ function indexLocals(tokens, pairs, lexed, diagnostics) {
     const lambda = tryParseLambdaParameters(tokens, index, pairs, lexed);
     if (lambda) {
       locals.push(...lambda.locals);
+      lambdaBodies.push(lambda.body);
       index = lambda.endTokenIndex;
       continue;
     }
-    const declaration = tryParseVariableDeclaration(tokens, index, lexed);
+    const declaration = tryParseVariableDeclaration(
+      tokens,
+      index,
+      lexed,
+      braceScope
+    );
     if (!declaration) continue;
     locals.push(declaration.local);
     if (declaration.missingInitializer) {
@@ -33584,36 +33933,14 @@ function indexLocals(tokens, pairs, lexed, diagnostics) {
   }
   return locals;
 }
-function tryParseVariableDeclaration(tokens, start, lexed) {
+function tryParseVariableDeclaration(tokens, start, lexed, braceScope) {
   const first = tokens[start];
   if (!first || first.kind !== "type" && first.kind !== "identifier")
     return null;
   const inferred = first.kind === "identifier" && first.text === NEOSCRIPT_INFERRED_LOCAL_KEYWORD;
-  let cursor = start + 1;
-  if (!inferred && (first.text === "Dictionary" || first.text === "Set")) {
-    const open = tokens[cursor];
-    if (!open || open.kind !== "operator" || open.text !== "<") return null;
-    let angleDepth = 0;
-    while (cursor < tokens.length) {
-      const token = tokens[cursor];
-      if (!token) return null;
-      if (token.kind === "operator" && token.text === "<") angleDepth++;
-      if (token.kind === "operator" && token.text === ">") {
-        angleDepth--;
-        if (angleDepth === 0) {
-          cursor++;
-          break;
-        }
-      }
-      cursor++;
-    }
-  }
-  while (!inferred && tokens[cursor]?.kind === "punctuation" && tokens[cursor]?.text === "[" && tokens[cursor + 1]?.kind === "punctuation" && tokens[cursor + 1]?.text === "]") {
-    cursor += 2;
-  }
-  if (!inferred && tokens[cursor]?.kind === "operator" && tokens[cursor]?.text === "?") {
-    cursor++;
-  }
+  if (!inferred && !mayStartTypedLocal(tokens, start)) return null;
+  const cursor = inferred ? start + 1 : new Parser(tokens, start).typeEnd();
+  if (cursor < 0) return null;
   const name = tokens[cursor];
   const equals = tokens[cursor + 1];
   if (!name || name.kind !== "identifier") return null;
@@ -33625,7 +33952,7 @@ function tryParseVariableDeclaration(tokens, start, lexed) {
   const statementEnd = statementEndTokenIndex(tokens, cursor + 2);
   const initializerTokens = hasEquals ? tokens.slice(cursor + 2, statementEnd) : [];
   const terminator = tokens[statementEnd];
-  const scope = containingBraceRange(tokens, start, lexed.end);
+  const scope = braceScope(start);
   return {
     local: {
       name: name.text,
@@ -33643,6 +33970,24 @@ function tryParseVariableDeclaration(tokens, start, lexed) {
     missingInitializer: inferred && (!hasEquals || initializerTokens.length === 0)
   };
 }
+var STATEMENT_BOUNDARY_TOKENS = /* @__PURE__ */ new Set([
+  ";",
+  "{",
+  "}",
+  ")",
+  ":"
+]);
+function mayStartTypedLocal(tokens, start) {
+  const previous = tokens[start - 1];
+  if (previous && !STATEMENT_BOUNDARY_TOKENS.has(previous.text) && previous.text !== "else" && !(previous.text === "(" && tokens[start - 2]?.text === "for")) {
+    return false;
+  }
+  const next = tokens[start + 1];
+  if (!next) return false;
+  if (next.kind === "identifier") return true;
+  if (next.kind === "operator") return next.text === "<" || next.text === "?";
+  return next.kind === "punctuation" && next.text === "[";
+}
 function statementEndTokenIndex(tokens, start) {
   let depth = 0;
   for (let cursor = start; cursor < tokens.length; cursor++) {
@@ -33669,6 +34014,7 @@ function tryParseLambdaParameters(tokens, start, pairs, lexed) {
     if (!arrow2 || arrow2.kind !== "operator" || arrow2.text !== "=>") {
       return null;
     }
+    const body2 = lambdaBodySpan(tokens, start + 1, pairs, lexed);
     return {
       locals: [
         {
@@ -33677,17 +34023,13 @@ function tryParseLambdaParameters(tokens, start, pairs, lexed) {
           typeTokens: [],
           inferred: false,
           declarationRange: open.range,
-          scopeStart: arrow2.end,
-          scopeEnd: lambdaExpressionScopeEnd(
-            tokens,
-            start + 2,
-            pairs,
-            lexed.end
-          ),
+          scopeStart: body2.start,
+          scopeEnd: body2.end,
           lambdaParameter: true,
           lambdaParameterIndex: 0
         }
       ],
+      body: body2,
       endTokenIndex: start + 1
     };
   }
@@ -33695,12 +34037,8 @@ function tryParseLambdaParameters(tokens, start, pairs, lexed) {
   const closeIndex = pairs.get(start);
   if (closeIndex === void 0) return null;
   const arrow = tokens[closeIndex + 1];
-  const bodyOpen = tokens[closeIndex + 2];
   if (!arrow || arrow.kind !== "operator" || arrow.text !== "=>") return null;
-  const hasBlockBody = bodyOpen?.kind === "punctuation" && bodyOpen.text === "{";
-  const bodyCloseIndex = hasBlockBody ? pairs.get(closeIndex + 2) : void 0;
-  const bodyClose = bodyCloseIndex === void 0 ? void 0 : tokens[bodyCloseIndex];
-  const scopeEnd = hasBlockBody ? bodyClose?.start ?? lexed.end : lambdaExpressionScopeEnd(tokens, closeIndex + 2, pairs, lexed.end);
+  const body = lambdaBodySpan(tokens, closeIndex + 1, pairs, lexed);
   const locals = [];
   let segmentStart = start + 1;
   for (let cursor = start + 1; cursor <= closeIndex; cursor++) {
@@ -33721,15 +34059,28 @@ function tryParseLambdaParameters(tokens, start, pairs, lexed) {
           segment[0]?.start ?? nameToken.start,
           nameToken.end
         ),
-        scopeStart: hasBlockBody && bodyOpen ? bodyOpen.end : bodyOpen?.start ?? arrow.end,
-        scopeEnd,
+        scopeStart: body.start,
+        scopeEnd: body.end,
         lambdaParameter: true,
         lambdaParameterIndex: locals.length
       });
     }
     segmentStart = cursor + 1;
   }
-  return { locals, endTokenIndex: closeIndex };
+  return { locals, body, endTokenIndex: closeIndex };
+}
+function lambdaBodySpan(tokens, arrowIndex, pairs, lexed) {
+  const arrow = tokens[arrowIndex];
+  const bodyOpen = tokens[arrowIndex + 1];
+  if (bodyOpen?.kind === "punctuation" && bodyOpen.text === "{") {
+    const closeIndex = pairs.get(arrowIndex + 1);
+    const close = closeIndex === void 0 ? void 0 : tokens[closeIndex];
+    return { start: bodyOpen.end, end: close?.start ?? lexed.end };
+  }
+  return {
+    start: arrow?.end ?? lexed.end,
+    end: lambdaExpressionScopeEnd(tokens, arrowIndex + 1, pairs, lexed.end)
+  };
 }
 function lambdaExpressionScopeEnd(tokens, bodyStart, pairs, sourceEnd) {
   for (let cursor = bodyStart; cursor < tokens.length; cursor++) {
@@ -33746,6 +34097,9 @@ function lambdaExpressionScopeEnd(tokens, bodyStart, pairs, sourceEnd) {
   }
   return sourceEnd;
 }
+function isCallTypeArgumentToken(token) {
+  return token.kind === "identifier" || token.kind === "type" || [".", ",", "?", "[", "]"].includes(token.text);
+}
 function callOpenParenIndex(tokens, nameIndex) {
   if (tokens[nameIndex + 1]?.text === "(") return nameIndex + 1;
   if (tokens[nameIndex + 1]?.text !== "<") return -1;
@@ -33754,8 +34108,7 @@ function callOpenParenIndex(tokens, nameIndex) {
     const token = tokens[cursor];
     if (token.text === "<") depth++;
     else if (/^>+$/.test(token.text)) depth -= token.text.length;
-    else if (token.kind !== "identifier" && token.kind !== "type" && ![".", ",", "?", "[", "]"].includes(token.text))
-      return -1;
+    else if (!isCallTypeArgumentToken(token)) return -1;
     if (depth === 0) return tokens[cursor + 1]?.text === "(" ? cursor + 1 : -1;
     if (depth < 0) return -1;
   }
@@ -33777,15 +34130,84 @@ function callTypeArgumentTokens(tokens, nameIndex, openIndex) {
   }
   return argumentsTokens;
 }
-function indexReferences(tokens, declarations, contextualKeywords) {
+function enclosingOpenerIndex(tokens) {
+  const enclosing = new Int32Array(tokens.length);
+  const openers = [];
+  for (let index = 0; index < tokens.length; index++) {
+    enclosing[index] = openers.length ? openers[openers.length - 1] : -1;
+    const token = tokens[index];
+    if (token.kind !== "punctuation") continue;
+    if (token.text === "(" || token.text === "[" || token.text === "{") {
+      openers.push(index);
+    } else if (token.text === ")" || token.text === "]" || token.text === "}") {
+      openers.pop();
+    }
+  }
+  return enclosing;
+}
+function isContextualNew(token, previous, next) {
+  return token.text === NEOSCRIPT_CONSTRUCTOR_KEYWORD && previous?.text !== "." && previous?.text !== "?." && (next?.kind === "identifier" || next?.kind === "type" || next?.text === "(" || next?.text === "{");
+}
+function objectInitializerBraceIndex(tokens, newIndex, pairs) {
+  let cursor = newIndex + 1;
+  const opener = tokens[cursor]?.text;
+  if (opener !== "(" && opener !== "{") {
+    const typeEnd = new Parser(tokens, cursor).typeEnd();
+    if (typeEnd >= 0) cursor = typeEnd;
+  }
+  if (tokens[cursor]?.text === "(") {
+    const close = pairs.get(cursor);
+    if (close === void 0) return -1;
+    cursor = close + 1;
+  }
+  return tokens[cursor]?.text === "{" ? cursor : -1;
+}
+function indexReferences(tokens, pairs, declarations, contextualKeywords, negations, initializers) {
   const references = [];
+  const enclosing = enclosingOpenerIndex(tokens);
+  const initializerBraces = /* @__PURE__ */ new Set();
+  const patternBindings = /* @__PURE__ */ new Set();
   for (let index = 0; index < tokens.length; index++) {
     const token = tokens[index];
-    if (!token || token.kind !== "identifier" && token.text !== "base")
+    if (!token) continue;
+    if (token.kind === "keyword" && token.text === "is") {
+      const not = tokens[index + 1];
+      let typeStart = index + 1;
+      if (not?.text === "not") {
+        negations.push(not.range);
+        typeStart = index + 2;
+        index++;
+      }
+      const end = new Parser(tokens, typeStart).typeEnd({
+        conditionalQuestion: true
+      });
+      if (end >= 0 && tokens[end]?.kind === "identifier") {
+        patternBindings.add(end);
+      }
       continue;
+    }
+    if (token.kind !== "identifier" && token.text !== "base") continue;
+    const previous = tokens[index - 1];
+    const next = tokens[index + 1];
+    if (isContextualNew(token, previous, next)) {
+      const brace = objectInitializerBraceIndex(tokens, index, pairs);
+      if (brace >= 0) {
+        initializerBraces.add(brace);
+        initializers.push({
+          constructorStart: token.start,
+          braceStart: tokens[brace].start
+        });
+      }
+      continue;
+    }
+    const opener = enclosing[index];
+    if (opener >= 0 && (previous?.text === "," || index - 1 === opener)) {
+      const label = next?.text === ":" && tokens[opener]?.text === "(";
+      const key = next?.kind === "operator" && next.text === "=" && initializerBraces.has(opener);
+      if (label || key) continue;
+    }
     const declarationKey = `${token.range.start.line}:${token.range.start.character}`;
     if (contextualKeywords.has(declarationKey)) continue;
-    const previous = tokens[index - 1];
     references.push({
       name: token.text,
       range: token.range,
@@ -33793,7 +34215,7 @@ function indexReferences(tokens, declarations, contextualKeywords) {
       end: token.end,
       member: previous?.kind === "punctuation" && previous.text === "." || previous?.kind === "operator" && previous.text === "?.",
       call: callOpenParenIndex(tokens, index) >= 0,
-      declaration: declarations.has(declarationKey)
+      declaration: declarations.has(declarationKey) || patternBindings.has(index)
     });
   }
   return references;
@@ -33806,12 +34228,18 @@ function indexCalls(tokens, pairs, lexed) {
     const open = tokens[openIndex];
     if (!name || name.kind !== "identifier") continue;
     if (!open || open.kind !== "punctuation" || open.text !== "(") continue;
-    const contextualKeyword = tokens[index - 1];
-    const constructor = contextualKeyword?.kind === "identifier" && contextualKeyword.text === NEOSCRIPT_CONSTRUCTOR_KEYWORD;
+    const previous = tokens[index - 1];
+    const targetTyped = isContextualNew(name, previous, open);
+    let contextualKeyword;
+    if (targetTyped) contextualKeyword = name;
+    else if (previous?.kind === "identifier" && previous.text === NEOSCRIPT_CONSTRUCTOR_KEYWORD)
+      contextualKeyword = previous;
     const closeIndex = pairs.get(openIndex);
     const close = closeIndex === void 0 ? void 0 : tokens[closeIndex];
     const ranges = [];
+    const names = [];
     let segmentStart = open.end;
+    let segmentStartIndex = openIndex + 1;
     let nested = 0;
     const limit = closeIndex ?? tokens.length;
     for (let cursor = openIndex + 1; cursor < limit; cursor++) {
@@ -33823,17 +34251,21 @@ function indexCalls(tokens, pairs, lexed) {
         nested--;
       if (nested === 0 && token.kind === "punctuation" && token.text === ",") {
         ranges.push(lexed.source.range(segmentStart, token.start));
+        names.push(callArgumentLabel(tokens, segmentStartIndex, cursor));
         segmentStart = token.end;
+        segmentStartIndex = cursor + 1;
       }
     }
     if (segmentStart < (close?.start ?? lexed.end)) {
       ranges.push(lexed.source.range(segmentStart, close?.start ?? lexed.end));
+      names.push(callArgumentLabel(tokens, segmentStartIndex, limit));
     }
     calls.push({
-      kind: constructor ? "constructor" : "function",
+      kind: contextualKeyword ? "constructor" : "function",
       name: name.text,
       nameRange: name.range,
-      ...constructor ? { contextualKeywordRange: contextualKeyword.range } : {},
+      ...contextualKeyword ? { contextualKeywordRange: contextualKeyword.range } : {},
+      ...targetTyped ? { targetTyped: true } : {},
       ...openIndex > index + 1 ? {
         typeArgumentTokens: callTypeArgumentTokens(
           tokens,
@@ -33843,11 +34275,17 @@ function indexCalls(tokens, pairs, lexed) {
       } : {},
       openParenOffset: open.start,
       ...close ? { closeParenOffset: close.end } : {},
-      argumentRanges: ranges
+      argumentRanges: ranges,
+      argumentNames: names
     });
   }
   return calls;
 }
+function callArgumentLabel(tokens, start, end) {
+  const name = tokens[start];
+  const colon = tokens[start + 1];
+  return start + 1 < end && name !== void 0 && isCallArgumentLabelToken(name) && colon?.kind === "punctuation" && colon.text === ":" ? name.text : null;
+}
 function validateTerminatedStatements(tokens, diagnostics) {
   for (let index = 0; index < tokens.length; index++) {
     const token = tokens[index];
@@ -33892,36 +34330,44 @@ function validateTerminatedStatements(tokens, diagnostics) {
     }
   }
 }
-function containingBraceRange(tokens, tokenIndex, documentEnd) {
-  let depth = 0;
-  let start = 0;
-  for (let index = tokenIndex - 1; index >= 0; index--) {
+function braceScopeIndex(tokens, documentEnd) {
+  const openBefore = new Int32Array(tokens.length);
+  const closeOf = /* @__PURE__ */ new Map();
+  const unmatchedCloses = [];
+  const stack = [];
+  for (let index = 0; index < tokens.length; index++) {
+    openBefore[index] = stack.at(-1) ?? -1;
     const token = tokens[index];
-    if (!token || token.kind !== "punctuation") continue;
-    if (token.text === "}") depth++;
-    if (token.text === "{") {
-      if (depth === 0) {
-        start = token.end;
-        break;
-      }
-      depth--;
+    if (token.kind !== "punctuation") continue;
+    if (token.text === "{") stack.push(index);
+    else if (token.text === "}") {
+      const open = stack.pop();
+      if (open === void 0) unmatchedCloses.push(index);
+      else closeOf.set(open, index);
+    }
+  }
+  return (tokenIndex) => {
+    const open = openBefore[tokenIndex] ?? -1;
+    if (open >= 0) {
+      const close2 = closeOf.get(open);
+      return {
+        start: tokens[open].end,
+        end: close2 === void 0 ? documentEnd : tokens[close2].start
+      };
     }
-  }
-  depth = 0;
-  let end = documentEnd;
-  for (let index = tokenIndex + 1; index < tokens.length; index++) {
-    const token = tokens[index];
-    if (!token || token.kind !== "punctuation") continue;
-    if (token.text === "{") depth++;
-    if (token.text === "}") {
-      if (depth === 0) {
-        end = token.start;
-        break;
-      }
-      depth--;
+    let low = 0;
+    let high = unmatchedCloses.length;
+    while (low < high) {
+      const mid = low + high >> 1;
+      if (unmatchedCloses[mid] > tokenIndex) high = mid;
+      else low = mid + 1;
     }
-  }
-  return { start, end };
+    const close = unmatchedCloses[low];
+    return {
+      start: 0,
+      end: close === void 0 ? documentEnd : tokens[close].start
+    };
+  };
 }
 function tryParseCatchParameter(tokens, start, pairs, lexed) {
   const keyword = tokens[start];
@@ -33969,7 +34415,7 @@ function tryParseCatchParameter(tokens, start, pairs, lexed) {
     resumeTokenIndex: closeIndex
   };
 }
-function tryParseLoopLocal(tokens, start, pairs, lexed, diagnostics) {
+function tryParseLoopLocal(tokens, start, pairs, lexed, diagnostics, braceScope) {
   const keyword = tokens[start];
   if (!keyword || keyword.kind !== "keyword" || keyword.text !== "for" && keyword.text !== "foreach") {
     return null;
@@ -33980,7 +34426,12 @@ function tryParseLoopLocal(tokens, start, pairs, lexed, diagnostics) {
   if (closeIndex === void 0) return null;
   const scopeEnd = loopBodyScopeEnd(tokens, closeIndex + 1, pairs, lexed.end);
   if (keyword.text === "for") {
-    const declaration = tryParseVariableDeclaration(tokens, start + 2, lexed);
+    const declaration = tryParseVariableDeclaration(
+      tokens,
+      start + 2,
+      lexed,
+      braceScope
+    );
     if (!declaration || declaration.endTokenIndex >= closeIndex) return null;
     if (declaration.missingInitializer) {
       diagnostics.push({
@@ -34302,6 +34753,23 @@ var COLLECTION_QUERY_METHODS = {
   Reverse: "none",
   Concat: "collection"
 };
+var COLLECTION_FUNCTION_ARGUMENTS = {
+  Where: "predicate",
+  First: "optionalPredicate",
+  FirstOrDefault: "optionalPredicate",
+  Select: "selector",
+  Count: "optionalPredicate",
+  ...COLLECTION_QUERY_METHODS
+};
+function isCollectionFunctionName(name) {
+  return Object.hasOwn(COLLECTION_FUNCTION_ARGUMENTS, name);
+}
+var COLLECTION_FUNCTION_ALIASES = { Find: "FirstOrDefault" };
+function collectionFunctionContract(name) {
+  if (Object.hasOwn(COLLECTION_FUNCTION_ALIASES, name))
+    return COLLECTION_FUNCTION_ALIASES[name];
+  return isCollectionFunctionName(name) ? name : null;
+}
 function isCollectionQueryName(name) {
   return Object.hasOwn(COLLECTION_QUERY_METHODS, name);
 }
@@ -36192,10 +36660,12 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         statement.pos
       );
     }
-    if (statement.target.kind === "member" && statement.target.name === "OnChanged") {
+    if (statement.target.kind === "member" && statement.target.name === NEOSCRIPT_ON_CHANGED_MEMBER) {
       const observed = this.resolveExpression(statement.target.receiver, scope);
       const observedType = neoScriptMemberLookupType(observed.type);
-      const declared = observedType.kind === "named" && this.project.typeById.get(observedType.typeId)?.members.some((member) => member.name === "OnChanged");
+      const declared = observedType.kind === "named" && this.project.typeById.get(observedType.typeId)?.members.some(
+        (member) => member.name === NEOSCRIPT_ON_CHANGED_MEMBER
+      );
       if (!declared) {
         if (statement.op !== "+=" && statement.op !== "-=")
           throw new CompileError(ON_CHANGED_OPERATIONS_ERROR, statement.pos);
@@ -36414,12 +36884,12 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
   }
   /** `X.M.OnChanged.Clear()` empties M's listener set on X (P70, P106). */
   resolveChangeListenerClear(expression, scope, pos) {
-    if (expression.kind !== "call" || expression.callee.kind !== "member" || expression.callee.name !== "Clear" || expression.callee.receiver.kind !== "member" || expression.callee.receiver.name !== "OnChanged")
+    if (expression.kind !== "call" || expression.callee.kind !== "member" || expression.callee.name !== "Clear" || expression.callee.receiver.kind !== "member" || expression.callee.receiver.name !== NEOSCRIPT_ON_CHANGED_MEMBER)
       return null;
     const onChanged = expression.callee.receiver;
     const observed = this.resolveExpression(onChanged.receiver, scope);
     const observedType = neoScriptMemberLookupType(observed.type);
-    if (observedType.kind === "named" && this.project.typeById.get(observedType.typeId)?.members.some((member) => member.name === "OnChanged"))
+    if (observedType.kind === "named" && this.project.typeById.get(observedType.typeId)?.members.some((member) => member.name === NEOSCRIPT_ON_CHANGED_MEMBER))
       return null;
     if (expression.callee.optional)
       throw new CompileError(
@@ -37145,7 +37615,14 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         );
       }
       case "new": {
-        const vector3 = this.targetTypedVectorKind(expression, expected);
+        const constructed = expression.className ?? (expected?.kind === "primitive" ? expected.name : null);
+        if (constructed === "Color") {
+          throw new CompileError(
+            "Color has no NeoScript constructor; write its components as numeric literals.",
+            expression.pos
+          );
+        }
+        const vector3 = this.constructedVectorKind(expression, constructed);
         if (vector3 !== null) {
           return this.resolveVectorConstructor(
             vector3,
@@ -37655,10 +38132,19 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     };
   }
   resolveListLiteral(elements, scope, expected, pos) {
-    const expectedEntry = expected?.kind === "list" ? expected.elementType : void 0;
+    const expectedEntry = expected?.kind === "list" || expected?.kind === "set" ? expected.elementType : void 0;
     const resolved = elements.map(
       (element) => this.resolveExpression(element, scope, expectedEntry)
     );
+    if (expectedEntry !== void 0 && this.context.kind === "initializer") {
+      resolved.forEach((item, index) => {
+        if (isNeoScriptTypeAssignable(item.type, expectedEntry, this.project)) return;
+        throw new CompileError(
+          `Expected ${this.describe(expectedEntry)} but received ${this.describe(item.type)}.`,
+          elements[index].pos
+        );
+      });
+    }
     let entryType = expectedEntry ?? resolved[0]?.type;
     if (!entryType) {
       throw new CompileError(
@@ -37680,6 +38166,14 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       }
       entryType = common;
     }
+    if (expected?.kind === "set" && this.context.kind === "initializer") {
+      const element = expected.elementType;
+      const spelling = element.kind === "named" && this.project.typeById.get(element.typeId)?.kind === "enum" ? `.Option or ${this.describe({ ...element, nullable: false })}.Option values` : "literal values";
+      throw new CompileError(
+        `${this.describe(expected)} has no NeoScript literal; write its elements as ${spelling}.`,
+        pos
+      );
+    }
     const type = {
       kind: "list",
       elementType: entryType
@@ -38616,7 +39110,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
           pos
         );
       }
-      if (name === "Id" && type.kind === "class") {
+      if (name === NEOSCRIPT_CLASS_ID_MEMBER && type.kind === "class") {
         return this.keyOf(
           receiver,
           name,
@@ -38705,7 +39199,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         entryUserData
       };
     }
-    if (name === "OnChanged")
+    if (name === NEOSCRIPT_ON_CHANGED_MEMBER)
       throw new CompileError(ON_CHANGED_OPERATIONS_ERROR, pos);
     throw new CompileError(
       `Cannot read member '${name}' on ${this.describe(receiver.type)}`,
@@ -40202,23 +40696,12 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         this.project.typeByName.get(className) ?? { declaredConstructors: [] }
       );
     }
-    const inferredTypes = this.inferOverloadArgumentTypes(
+    const resolution = this.declaredConstructorResolution(
       declared,
       named,
-      expression,
+      expression.args,
       scope
     );
-    const resolution = resolveNeoScriptDeclaredConstructorOverload(
-      declared,
-      named.map((name, index) => {
-        const inferred = inferredTypes?.[index];
-        if (!inferred) return { name };
-        return {
-          name,
-          matchesParameter: (parameter3) => isNeoScriptTypeAssignable(inferred, parameter3.type, this.project)
-        };
-      })
-    );
     if (resolution.kind === "resolved") return resolution.constructor;
     if (resolution.kind === "ambiguous") {
       throw new CompileError(
@@ -40231,6 +40714,38 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       pos
     );
   }
+  /**
+   * #1310. The overload a named `new` call in an initializer expression
+   * compiles against, for editor features that hold its argument expressions.
+   */
+  initializerConstructorOverload(declared, named, args) {
+    const resolution = this.declaredConstructorResolution(
+      declared,
+      named,
+      args,
+      this.initialScope()
+    );
+    return resolution.kind === "resolved" ? resolution.constructor : null;
+  }
+  declaredConstructorResolution(declared, named, args, scope) {
+    const inferredTypes = this.inferOverloadArgumentTypes(
+      declared,
+      named,
+      args,
+      scope
+    );
+    return resolveNeoScriptDeclaredConstructorOverload(
+      declared,
+      named.map((name, index) => {
+        const inferred = inferredTypes?.[index];
+        if (!inferred) return { name };
+        return {
+          name,
+          matchesParameter: (parameter3) => isNeoScriptTypeAssignable(inferred, parameter3.type, this.project)
+        };
+      })
+    );
+  }
   /**
    * Types for the §6.1.1 step-2 tie-break, computed only when several
    * overloads share the call's name set. Expected-type inference is
@@ -40238,7 +40753,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
    * known — so an argument that needs it (a contextual enum option, a
    * target-typed `new`) simply does not participate in the tie-break.
    */
-  inferOverloadArgumentTypes(declared, named, expression, scope) {
+  inferOverloadArgumentTypes(declared, named, args, scope) {
     const nameSetKey = neoScriptArgumentNameSetKey(named);
     const sharing = declared.filter(
       (candidate) => neoScriptArgumentNameSetKey(
@@ -40247,7 +40762,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     );
     if (sharing.length < 2) return null;
     return named.map((_, index) => {
-      const argument2 = expression.args[index];
+      const argument2 = args[index];
       if (!argument2) return null;
       try {
         return this.resolveExpression(argument2, scope).type;
@@ -40931,6 +41446,15 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
   resolveCollectionFunction(receiver, name, args, scope, pos) {
     const collection = collectionPartsFor(receiver);
     if (!collection) return null;
+    const contract = collectionFunctionContract(name);
+    if (contract !== null) {
+      requireCollectionArguments(
+        name,
+        COLLECTION_FUNCTION_ARGUMENTS[contract],
+        args,
+        pos
+      );
+    }
     if (isCollectionQueryName(name)) {
       return this.resolveCollectionQuery(
         receiver,
@@ -40942,12 +41466,6 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       );
     }
     if (name === "Count") {
-      if (args.length > 1) {
-        throw new CompileError(
-          `Count expects zero or one predicate, got ${args.length}.`,
-          pos
-        );
-      }
       const fn = args[0] ? this.resolveCollectionLambda(
         args[0],
         collection,
@@ -41023,7 +41541,6 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       );
     }
     if (name === "Where") {
-      requireArgCount(name, args, 1, pos);
       const fn = this.resolveCollectionLambda(
         requiredAt(args, 0),
         collection,
@@ -41046,12 +41563,6 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       };
     }
     if (name === "First" || name === "FirstOrDefault" || name === "Find") {
-      if (args.length > 1) {
-        throw new CompileError(
-          `${name} expects zero or one predicate, got ${args.length}.`,
-          pos
-        );
-      }
       const fn = args[0] ? this.resolveCollectionLambda(
         args[0],
         collection,
@@ -41076,7 +41587,6 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       };
     }
     if (name === "Select") {
-      requireArgCount(name, args, 1, pos);
       const lambda = requiredAt(args, 0);
       if (lambda.kind !== "lambda") {
         throw new CompileError("Select requires a lambda argument.", pos);
@@ -41103,16 +41613,6 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     return null;
   }
   resolveCollectionQuery(receiver, collection, name, args, scope, pos) {
-    const kind = COLLECTION_QUERY_METHODS[name];
-    if (kind === "optionalPredicate") {
-      if (args.length > 1)
-        throw new CompileError(
-          `${name} expects zero or one predicate, got ${args.length}.`,
-          pos
-        );
-    } else {
-      requireArgCount(name, args, kind === "none" ? 0 : 1, pos);
-    }
     const base = { collectionPointer: receiver.pointer };
     let info;
     let resultType = {
@@ -41278,6 +41778,8 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     };
   }
   resolveScalarFunction(receiver, name, args, scope, pos) {
+    if (receiver.type.kind !== "primitive" || !neoScriptScalarMethod(receiver.type.name, name))
+      return null;
     if (isPrimitive(receiver.type, "string")) {
       if (name === "Contains") {
         requireArgCount("string.Contains", args, 1, pos);
@@ -42429,27 +42931,26 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     };
   }
   /**
-   * The vector leaf a target-typed `new(…)` constructs, or null when the
-   * expression is not one.
+   * The vector leaf a target-typed `new(…)` or a named `new Vector2(…)`
+   * constructs, or null when the expression is not one.
    *
    * A vector has fields rather than members, so neither of `new`'s two
    * declaration-side spellings applies to it: an argument names a component by
    * position and there is no member for an initializer block to settle.
    */
-  targetTypedVectorKind(expression, expected) {
-    if (expression.className !== null) return null;
-    if (expected?.kind !== "primitive") return null;
-    const vector3 = vectorKind(expected.name);
+  constructedVectorKind(expression, constructed) {
+    const vector3 = constructed === null ? null : vectorKind(constructed);
     if (vector3 === null) return null;
+    const spelling = expression.className === null ? "new(\u2026)" : `new ${vector3}(\u2026)`;
     if (expression.argumentNames !== void 0) {
       throw new CompileError(
-        `${vector3} components are positional, so \`new(\u2026)\` cannot name them.`,
+        `${vector3} components are positional, so \`${spelling}\` cannot name them.`,
         expression.pos
       );
     }
     if ((expression.initializer?.length ?? 0) > 0) {
       throw new CompileError(
-        `${vector3} has fields rather than members, so \`new(\u2026)\` cannot carry an initializer block. Pass every component instead.`,
+        `${vector3} has fields rather than members, so \`${spelling}\` cannot carry an initializer block. Pass every component instead.`,
         expression.pos
       );
     }
@@ -42620,6 +43121,12 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
   }
   requireAssignable(source, target, pos, usage) {
     if (isNeoScriptTypeAssignable(source, target, this.project)) return;
+    if (usage === "return" && this.context.kind === "initializer" && this.lambdaDepth === 0) {
+      throw new CompileError(
+        `Expected ${this.describe(target)} but received ${this.describe(source)}.`,
+        pos
+      );
+    }
     const prefix = usage === "return" ? "Returned" : "Cannot use";
     throw new CompileError(
       `${prefix} ${this.describe(source)} ${usage === "return" ? "is not assignable to declared return type" : `as ${usage} of type`} ${this.describe(target)}`,
@@ -43894,17 +44401,6 @@ function collectionOperationValueType(expression, collection) {
 function isLookupSelectionCollection(expression, collection) {
   return collection.kind === "set" && expression.wireType?.type === 9 /* Lookup */;
 }
-var SPRITE_DERIVED_MEMBERS = {
-  FileName: { kind: "primitive", name: "string" },
-  Name: { kind: "primitive", name: "string" },
-  Size: { kind: "primitive", name: "Vector2" },
-  Pivot: { kind: "primitive", name: "Vector2" },
-  Slices: {
-    kind: "list",
-    elementType: { kind: "primitive", name: "SpriteInfo" },
-    readOnly: true
-  }
-};
 function assignableFieldList(owner) {
   if (!isNeoScriptStructuredLeafTypeName(owner)) return "a stored field";
   const names = neoScriptStructuredLeafFieldNames(owner);
@@ -43918,19 +44414,8 @@ function resolvePrimitiveMember(type, name) {
     );
     if (field) return { type: field.type, key: field.key };
   }
-  if (type.name === "SpriteInfo" && Object.prototype.hasOwnProperty.call(SPRITE_DERIVED_MEMBERS, name)) {
-    const derived = SPRITE_DERIVED_MEMBERS[name];
-    if (derived) return { type: derived, derived: true };
-  }
-  if (type.name === "AudioClipInfo") {
-    if (name === "url" || name === "name")
-      return { type: { kind: "primitive", name: "string" } };
-    if (name === "length")
-      return { type: { kind: "primitive", name: "float" } };
-  }
-  if (type.name === "NeoDialogueReference" && name === "id")
-    return { type: { kind: "primitive", name: "string" } };
-  return null;
+  const derived = neoScriptPrimitiveDerivedMember(type.name, name);
+  return derived ? { type: derived.type, derived: true } : null;
 }
 function isActionMemberPointer(pointer) {
   if (pointer.type === "staticMember" /* StaticMember */) return true;
@@ -44179,6 +44664,17 @@ function functionArityMessage(name, minimum, maximum, got) {
   }
   return `Function '${name}' expects between ${minimum} and ${maximum} arguments, got ${got}.`;
 }
+function requireCollectionArguments(name, shape, args, pos) {
+  if (shape !== "optionalPredicate") {
+    requireArgCount(name, args, shape === "none" ? 0 : 1, pos);
+    return;
+  }
+  if (args.length <= 1) return;
+  throw new CompileError(
+    `${name} expects zero or one predicate, got ${args.length}.`,
+    pos
+  );
+}
 function requireArgCount(name, args, expected, pos) {
   if (args.length === expected) return;
   throw new CompileError(
@@ -44260,6 +44756,18 @@ function resolveNeoScriptType(type, context, project) {
         resolved = registryReference;
         break;
       }
+      if (type.name === "NeoDelegate") {
+        const [returnType, ...parameterTypes] = (type.typeArguments ?? []).map(
+          (argument2) => resolveNeoScriptType(argument2, context, project)
+        );
+        if (!returnType)
+          throw new CompileError(
+            "NeoDelegate requires a return type argument, for example NeoDelegate<int>.",
+            type.pos
+          );
+        resolved = { kind: "delegate", returnType, parameterTypes };
+        break;
+      }
       const named = project.typeByName.get(type.name);
       if (!named)
         throw new CompileError(
@@ -45884,7 +46392,7 @@ function manifestParameterDefault(argument2, environment, field) {
   const value = constantDefaultValue(declared.value, `${field}.default.value`);
   const type = record2(argument2.type, `${field}.type`);
   const kind = string(type.kind, `${field}.type.kind`);
-  const enumOptionName = kind === "enum" && typeof value === "string" ? manifestEnumOptionName(
+  const enumOptionName2 = kind === "enum" && typeof value === "string" ? manifestEnumOptionName(
     string(type.enumId, `${field}.type.enumId`),
     value,
     environment
@@ -45894,7 +46402,7 @@ function manifestParameterDefault(argument2, environment, field) {
       displayText: neoScriptParameterDefaultDisplayText({
         value,
         kind: kind === "enum" || kind === "decimal" ? kind : "other",
-        ...enumOptionName === void 0 ? {} : { enumOptionName }
+        ...enumOptionName2 === void 0 ? {} : { enumOptionName: enumOptionName2 }
       }),
       value
     }
@@ -46759,13 +47267,13 @@ function overrideBaseClass(context) {
 function parameterDefaultDescriptor(argument2, context) {
   if (argument2.defaultValue === void 0) return {};
   const value = argument2.defaultValue.value;
-  const enumOptionName = argument2.type === 8 /* Enum */ && typeof value === "string" ? analyzerEnumOptionName(argument2.enumId, value, context) : void 0;
+  const enumOptionName2 = argument2.type === 8 /* Enum */ && typeof value === "string" ? analyzerEnumOptionName(argument2.enumId, value, context) : void 0;
   return {
     defaultValue: {
       displayText: neoScriptParameterDefaultDisplayText({
         value,
         kind: parameterDefaultSpellingKind(argument2.type),
-        ...enumOptionName === void 0 ? {} : { enumOptionName }
+        ...enumOptionName2 === void 0 ? {} : { enumOptionName: enumOptionName2 }
       }),
       value
     }
@@ -48388,8 +48896,9 @@ function createContext(ctx, options) {
 }
 
 // ../src/database/neoscript/compile-delegate-closure.ts
+var CLOSURE_GETTER_PREFIX = "return ";
 function compileDelegateClosureValue(code, signature) {
-  const compiled = compileNSGetter(`return ${code};`, {
+  const compiled = compileNSGetter(`${CLOSURE_GETTER_PREFIX}${code};`, {
     project: signature.project,
     projectFiles: [...signature.projectFiles ?? []],
     dialogueGroups: signature.dialogueGroups ?? [],
@@ -48407,7 +48916,8 @@ function compileDelegateClosureValue(code, signature) {
       returnTypeInfo: signature.returnTypeInfo,
       argumentTypes: [...signature.argumentTypes]
     },
-    functionName: signature.name
+    functionName: signature.name,
+    compilationProject: signature.compilationProject
   });
   const instruction = compiled.instructions[0];
   if (compiled.instructions.length !== 1 || instruction?.type !== "return" /* return */ || instruction.pointer?.type !== "value" /* value */) {
@@ -48497,7 +49007,8 @@ function compileMemberInitializerBody(args) {
       error,
       memberId: args.member.id,
       memberName: args.member.name,
-      valueId: null
+      valueId: null,
+      code: defaultValue.init.code
     });
   }
   Object.assign(defaultValue.init, { compiled });
@@ -48556,7 +49067,8 @@ function compileValueRowInitializerBody(args) {
       error,
       memberId: args.member.id,
       memberName: args.member.name,
-      valueId: args.valueId
+      valueId: args.valueId,
+      code: container.init.code
     });
   }
   Object.assign(container.init, { compiled });
@@ -48585,10 +49097,20 @@ var NeoScriptBodyCompileError = class extends Error {
   memberId;
   memberName;
   valueId;
+  /**
+   * The constructor argument the body is stored inline under, when the value
+   * row carries it as creation data rather than as its own row (#1303).
+   */
+  argument;
+  /** The exact code handed to the compiler; `bodyPosition` is measured in it. */
+  code;
   bodyPosition;
+  /** The compiler's message without its body position. */
+  detail;
   constructor(args) {
-    const subject = args.valueId === null ? `Member "${args.memberName}" (${args.memberId})` : `Value row "${args.valueId}" of member "${args.memberName}" (${args.memberId})`;
-    const at2 = args.bodyPosition === null ? "" : ` at initializer ${args.bodyPosition}`;
+    const argument2 = args.argument === void 0 ? "" : ` constructor argument "${args.argument.parameterName}"`;
+    const subject = args.valueId === null ? `Member "${args.memberName}" (${args.memberId})` : `Value row "${args.valueId}"${argument2} of member "${args.memberName}" (${args.memberId})`;
+    const at2 = args.bodyPosition === null ? "" : ` at initializer ${args.bodyPosition.line}:${args.bodyPosition.column}`;
     super(
       `${subject} has a NeoScript body that failed to compile${at2}: ${args.detail}`
     );
@@ -48596,18 +49118,24 @@ var NeoScriptBodyCompileError = class extends Error {
     this.memberId = args.memberId;
     this.memberName = args.memberName;
     this.valueId = args.valueId;
+    this.argument = args.argument ?? null;
+    this.code = args.code;
     this.bodyPosition = args.bodyPosition;
+    this.detail = args.detail;
   }
 };
 function throwNamedBodyCompileFailure(args) {
   if (args.error instanceof NeoScriptBodyCompileError) throw args.error;
   const compileError = args.error instanceof CompileError ? args.error : null;
   const detail = args.error instanceof Error ? args.error.message : String(args.error);
+  const position = compileError === null ? null : { line: compileError.line, column: compileError.column };
   throw new NeoScriptBodyCompileError({
     memberId: args.memberId,
     memberName: args.memberName,
     valueId: args.valueId,
-    bodyPosition: compileError === null ? null : `${compileError.line}:${compileError.column}`,
+    ...args.argument === void 0 ? {} : { argument: args.argument },
+    code: args.code,
+    bodyPosition: position === null ? null : args.codePosition?.(position) ?? position,
     detail: compileError === null ? detail : detail.replace(
       new RegExp(`^${compileError.line}:${compileError.column}: `),
       ""
@@ -55878,79 +56406,9 @@ var INITIALIZER_KEY_PLACEHOLDER = new RegExp(
   "g"
 );
 
-// ../packages/neoscript-language/src/project-schema-contract.generated.ts
-var PROJECT_FILE_UPLOAD_BATCH_SIZE = 32;
-
-// src/project-source/lower-configuration.ts
-var wireEnumOptions = () => (options) => options;
-var TEXTURE_TYPE_WIRE_OPTIONS = wireEnumOptions()([
-  "default",
-  "normal-map",
-  "editor-gui-and-legacy-gui",
-  "sprite",
-  "cursor",
-  "cookie",
-  "lightmap",
-  "single-channel"
-]);
-var ALPHA_SOURCE_WIRE_OPTIONS = wireEnumOptions()(["none", "input-texture-alpha", "from-gray-scale"]);
-var NON_POWER_OF_TWO_SCALE_WIRE_OPTIONS = wireEnumOptions()(["none", "to-nearest", "to-larger", "to-smaller"]);
-var MIP_MAP_FILTERING_WIRE_OPTIONS = wireEnumOptions()(["box", "kaiser"]);
-var WRAP_MODE_WIRE_OPTIONS = wireEnumOptions()(["repeat", "clamp", "mirror", "mirror-once", "per-axis"]);
-var FILTER_MODE_WIRE_OPTIONS = wireEnumOptions()(["point", "bilinear", "trilinear"]);
-var RESIZE_ALGORITHM_WIRE_OPTIONS = wireEnumOptions()(["mitchell", "bilinear"]);
-var TEXTURE_COMPRESSION_WIRE_OPTIONS = wireEnumOptions()(["none", "low-quality", "normal-quality", "high-quality"]);
-var PLATFORM_FORMAT_WIRE_OPTIONS = wireEnumOptions()([
-  "automatic",
-  "rgba-compressed-dxt5-bc3",
-  "rgb-compressed-dxt1-bc1",
-  "rgba-32-bit",
-  "rgb-24-bit"
-]);
-var SPRITE_MODE_WIRE_OPTIONS = wireEnumOptions()(["single", "multiple", "polygon"]);
-var MESH_TYPE_WIRE_OPTIONS = wireEnumOptions()(["full-rect", "tight"]);
-var PIVOT_ALIGNMENT_WIRE_OPTIONS = wireEnumOptions()([
-  "center",
-  "top-left",
-  "top-center",
-  "top-right",
-  "left-center",
-  "right-center",
-  "bottom-left",
-  "bottom-center",
-  "bottom-right",
-  "custom"
-]);
-var SLICE_TYPE_WIRE_OPTIONS = wireEnumOptions()(["grid-by-cell-size"]);
-var SLICE_NAMING_ORDER_WIRE_OPTIONS = wireEnumOptions()(["row-major", "column-major"]);
-var NORMAL_MAP_FILTERING_WIRE_OPTIONS = wireEnumOptions()(["sharp", "smooth"]);
-var COOKIE_LIGHT_TYPE_WIRE_OPTIONS = wireEnumOptions()(["spot", "directional", "point"]);
-var SINGLE_CHANNEL_COMPONENT_WIRE_OPTIONS = wireEnumOptions()(["alpha", "red"]);
-var SWIZZLE_WIRE_OPTIONS = wireEnumOptions()(["red", "green", "blue", "alpha", "zero", "one"]);
-var AUDIO_LOAD_TYPE_WIRE_OPTIONS = wireEnumOptions()(["decompress-on-load", "compressed-in-memory", "streaming"]);
-var AUDIO_COMPRESSION_FORMAT_WIRE_OPTIONS = wireEnumOptions()(["pcm", "adpcm", "vorbis"]);
-var AUDIO_SAMPLE_RATE_WIRE_OPTIONS = wireEnumOptions()(["preserve-sample-rate", "optimize-sample-rate", "override-sample-rate"]);
-
-// src/project-source/lower-relations.ts
-var RELATION_KIND_BY_PROPERTY = /* @__PURE__ */ new Map([
-  ["tileImports", "world.grid.tile-import"],
-  ["objectImports", "world.grid.object-import"],
-  ["tileLayers", "world.grid.tile-layer"],
-  ["objectLayers", "world.grid.object-layer"]
-]);
-var SPECIALIZED_RELATION_KINDS = /* @__PURE__ */ new Set([
-  ...RELATION_KIND_BY_PROPERTY.values(),
-  "world.tile.compatible-layer",
-  "world.tile.default-layer",
-  "world.object.compatible-layer",
-  "world.object.default-layer",
-  "world.tile-layer-link.target",
-  "world.object-layer-link.target"
-]);
-
 // ../packages/manifest/schema-contract/registry.mjs
 var PROJECT_SCHEMA_CONTRACT = Object.freeze({
-  cliVersion: "0.76.0",
+  cliVersion: "0.76.2",
   projectFileUploadBatchSize: 32,
   documentRecords: {
     member: {
@@ -57384,6 +57842,76 @@ var PROJECT_SCHEMA_CONTRACT = Object.freeze({
   }
 });
 
+// ../packages/neoscript-language/src/project-schema-contract.generated.ts
+var PROJECT_FILE_UPLOAD_BATCH_SIZE = 32;
+
+// src/project-source/lower-configuration.ts
+var wireEnumOptions = () => (options) => options;
+var TEXTURE_TYPE_WIRE_OPTIONS = wireEnumOptions()([
+  "default",
+  "normal-map",
+  "editor-gui-and-legacy-gui",
+  "sprite",
+  "cursor",
+  "cookie",
+  "lightmap",
+  "single-channel"
+]);
+var ALPHA_SOURCE_WIRE_OPTIONS = wireEnumOptions()(["none", "input-texture-alpha", "from-gray-scale"]);
+var NON_POWER_OF_TWO_SCALE_WIRE_OPTIONS = wireEnumOptions()(["none", "to-nearest", "to-larger", "to-smaller"]);
+var MIP_MAP_FILTERING_WIRE_OPTIONS = wireEnumOptions()(["box", "kaiser"]);
+var WRAP_MODE_WIRE_OPTIONS = wireEnumOptions()(["repeat", "clamp", "mirror", "mirror-once", "per-axis"]);
+var FILTER_MODE_WIRE_OPTIONS = wireEnumOptions()(["point", "bilinear", "trilinear"]);
+var RESIZE_ALGORITHM_WIRE_OPTIONS = wireEnumOptions()(["mitchell", "bilinear"]);
+var TEXTURE_COMPRESSION_WIRE_OPTIONS = wireEnumOptions()(["none", "low-quality", "normal-quality", "high-quality"]);
+var PLATFORM_FORMAT_WIRE_OPTIONS = wireEnumOptions()([
+  "automatic",
+  "rgba-compressed-dxt5-bc3",
+  "rgb-compressed-dxt1-bc1",
+  "rgba-32-bit",
+  "rgb-24-bit"
+]);
+var SPRITE_MODE_WIRE_OPTIONS = wireEnumOptions()(["single", "multiple", "polygon"]);
+var MESH_TYPE_WIRE_OPTIONS = wireEnumOptions()(["full-rect", "tight"]);
+var PIVOT_ALIGNMENT_WIRE_OPTIONS = wireEnumOptions()([
+  "center",
+  "top-left",
+  "top-center",
+  "top-right",
+  "left-center",
+  "right-center",
+  "bottom-left",
+  "bottom-center",
+  "bottom-right",
+  "custom"
+]);
+var SLICE_TYPE_WIRE_OPTIONS = wireEnumOptions()(["grid-by-cell-size"]);
+var SLICE_NAMING_ORDER_WIRE_OPTIONS = wireEnumOptions()(["row-major", "column-major"]);
+var NORMAL_MAP_FILTERING_WIRE_OPTIONS = wireEnumOptions()(["sharp", "smooth"]);
+var COOKIE_LIGHT_TYPE_WIRE_OPTIONS = wireEnumOptions()(["spot", "directional", "point"]);
+var SINGLE_CHANNEL_COMPONENT_WIRE_OPTIONS = wireEnumOptions()(["alpha", "red"]);
+var SWIZZLE_WIRE_OPTIONS = wireEnumOptions()(["red", "green", "blue", "alpha", "zero", "one"]);
+var AUDIO_LOAD_TYPE_WIRE_OPTIONS = wireEnumOptions()(["decompress-on-load", "compressed-in-memory", "streaming"]);
+var AUDIO_COMPRESSION_FORMAT_WIRE_OPTIONS = wireEnumOptions()(["pcm", "adpcm", "vorbis"]);
+var AUDIO_SAMPLE_RATE_WIRE_OPTIONS = wireEnumOptions()(["preserve-sample-rate", "optimize-sample-rate", "override-sample-rate"]);
+
+// src/project-source/lower-relations.ts
+var RELATION_KIND_BY_PROPERTY = /* @__PURE__ */ new Map([
+  ["tileImports", "world.grid.tile-import"],
+  ["objectImports", "world.grid.object-import"],
+  ["tileLayers", "world.grid.tile-layer"],
+  ["objectLayers", "world.grid.object-layer"]
+]);
+var SPECIALIZED_RELATION_KINDS = /* @__PURE__ */ new Set([
+  ...RELATION_KIND_BY_PROPERTY.values(),
+  "world.tile.compatible-layer",
+  "world.tile.default-layer",
+  "world.object.compatible-layer",
+  "world.object.default-layer",
+  "world.tile-layer-link.target",
+  "world.object-layer-link.target"
+]);
+
 // src/project-source/workspace-status-core.ts
 var ANIMATION_DOCUMENT_RECORD_KINDS = [
   ProjectRecordKind.Project,