@neocompose/cli 0.89.4 → 0.89.6

package/dist/neo-runtime.mjs

@@ -2569,7 +2569,7 @@ var init_strict_ir = __esm({
   "../packages/neoscript-language/src/strict-ir.ts"() {
     "use strict";
     init_debug_info();
-    NEOSCRIPT_COMPILER_REVISION = 17;
+    NEOSCRIPT_COMPILER_REVISION = 18;
     NeoScriptDialogueOp = /* @__PURE__ */ ((NeoScriptDialogueOp2) => {
       NeoScriptDialogueOp2["TryTrigger"] = "TryTrigger";
       NeoScriptDialogueOp2["CanTrigger"] = "CanTrigger";
@@ -3964,6 +3964,8 @@ function isNSWriteTarget(value) {
   if (!target) return false;
   if (!isNSPointer(target.pointer)) return false;
   if (!isNSTypeInfo(target.typeInfo)) return false;
+  if (target.structuredLeafKind !== void 0 && !isNeoScriptVectorKind(target.structuredLeafKind))
+    return false;
   if (target.writability === void 0) return true;
   return Object.values(NSWritability).includes(target.writability);
 }
@@ -7287,6 +7289,9 @@ function resolveMemberWithIndex(member, memberIndex) {
   chain.reverse();
   const merged = {};
   for (const link of chain) {
+    if (link.requirement === 1 /* Required */ && link.defaultValue == null && getField(merged.defaultValue, "value") === null) {
+      delete merged.defaultValue;
+    }
     if (getField(link, "classId") !== void 0) {
       delete merged.interfaceId;
       delete merged.interfaceArguments;
@@ -15893,11 +15898,36 @@ function cloneDefaultValueForMember(args) {
     throw new Error(
       `Cannot clone default value graph: circular reference at value "${args.sourceValueId}".`
     );
-  const source = findValueInDocument(
+  const member = substituteMember(
+    args.member,
+    args.genericEnv,
+    args.document.members,
+    args.document.resolvedMember?.(args.member)
+  );
+  const resolved = args.document.defaultValueSource?.(
+    args.sourceValueId,
+    member
+  );
+  const source = resolved?.value ?? findValueInDocument(
     args.document,
     args.sourceValueId,
     args.referenceLocation
   );
+  if (resolved?.rowsById !== void 0) {
+    const document = args.document;
+    const rows = resolved.rowsById;
+    args = {
+      ...args,
+      document: {
+        ...document,
+        valueById: (id2) => rows.get(id2) ?? document.valueById?.(id2) ?? null,
+        defaultValueSource: (id2, child2) => {
+          const value = rows.get(id2);
+          return value === void 0 ? document.defaultValueSource?.(id2, child2) ?? null : { value };
+        }
+      }
+    };
+  }
   if (capture === void 0)
     return cloneDefaultValueForMemberCore(args, source);
   const start = source.changeListeners === void 0 ? void 0 : capture.begin();
@@ -19377,7 +19407,7 @@ var init_registry = __esm({
   "../packages/manifest/schema-contract/registry.mjs"() {
     "use strict";
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
-      cliVersion: "0.89.4",
+      cliVersion: "0.89.6",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -27842,6 +27872,15 @@ function isCallableMemberForCodegen(value) {
 }
 function createGenerationContext(exportData, diagnostics, docs = EMPTY_UNITY_CODEGEN_DOCS) {
   const classes = Object.values(exportData.classes);
+  const genericDeclarations = /* @__PURE__ */ new Map();
+  for (const schemaClass2 of classes) {
+    for (const param of schemaClass2.genericParams ?? []) {
+      genericDeclarations.set(param.id, {
+        param,
+        declaringClassId: schemaClass2.id
+      });
+    }
+  }
   const members2 = Object.values(exportData.members);
   const dialogueGroups = Object.values(exportData.dialogueGroups ?? {});
   const dialogueGroupsByParent = /* @__PURE__ */ new Map();
@@ -27935,6 +27974,7 @@ function createGenerationContext(exportData, diagnostics, docs = EMPTY_UNITY_COD
     declarationSignatures: /* @__PURE__ */ new Map(),
     worldKinds: indexWorldSystemClassKinds(classes),
     resolvedMembers: /* @__PURE__ */ new Map(),
+    genericDeclarations,
     genericScopes: /* @__PURE__ */ new Map(),
     genericEnvironments: /* @__PURE__ */ new Map(),
     functionGenericParams: indexFunctionGenericParams(
@@ -28152,12 +28192,25 @@ function inheritedGeneratedMemberContract(ctx, ownerClassId, schemaKey, memberId
   }
   return null;
 }
+function declaredGeneratedPropertyValueType(ctx, member, memberSaved, saved, genericEnv) {
+  const declared = lookupDeclaredTypeInfo(member);
+  if (declared?.type !== 21 /* Generic */ || isMultiSelectionMember(member))
+    return csharpPropertyValueType(ctx, member, memberSaved, genericEnv, saved);
+  const target = csharpTypeInfoValueType(ctx, declared, saved, genericEnv);
+  if (target === null) return null;
+  return lookupProjection(ctx, member) === "slot" /* Slot */ ? `NeoReference<${target}>${isRequiredMember(member) ? "" : "?"}` : target;
+}
 function emittedGeneratedMemberContract(ctx, ownerClassId, schemaKey, memberId, saved, genericEnv) {
-  const member = ctx.exportData.members[memberId];
-  if (member === void 0) return null;
+  const member = resolveMemberById(ctx, memberId, `members.${memberId}`);
+  if (member === null) return null;
   const memberSaved = memberSavedForStorage(ctx, memberId, saved, ownerClassId);
-  const declaredLookupType = lookupDeclaredTypeInfo(member);
-  const valueType = declaredLookupType !== null && declaredLookupType.type === 21 /* Generic */ ? csharpTypeInfoValueType(ctx, declaredLookupType, saved, genericEnv) : csharpPropertyValueType(ctx, member, memberSaved, genericEnv, saved);
+  const valueType = declaredGeneratedPropertyValueType(
+    ctx,
+    member,
+    memberSaved,
+    saved,
+    genericEnv
+  );
   if (valueType === null) return null;
   const inherited = inheritedGeneratedMemberContract(
     ctx,
@@ -28168,11 +28221,38 @@ function emittedGeneratedMemberContract(ctx, ownerClassId, schemaKey, memberId,
     genericEnv
   );
   const hasSetter = emitsGeneratedSetter(member, memberSaved) && !suppressesInheritedSetter(inherited);
+  const declaredValueTypeInfo = generatedValueTypeInfo(ctx, member);
+  const readsReferenceValue = referenceImplementsValueContract(
+    ctx,
+    member,
+    valueType,
+    inherited
+  );
+  let valueTypeInfo = declaredValueTypeInfo;
+  if (readsReferenceValue && inherited !== null) {
+    valueTypeInfo = inherited.valueTypeInfo;
+  } else if (isMemberLookupBase(member) && !isMultiSelectionMember(member) && lookupProjection(ctx, member) === "slot" /* Slot */ && declaredValueTypeInfo !== null) {
+    valueTypeInfo = {
+      type: 29 /* Reference */,
+      required: isRequiredMember(member),
+      targetTypeInfo: declaredValueTypeInfo
+    };
+  }
+  const emittedValueType = narrowedMemberValueType(
+    ctx,
+    member,
+    valueType,
+    inherited
+  );
+  if (inherited?.valueTypeInfo?.type === 29 /* Reference */ && emittedValueType === inherited.valueType) {
+    valueTypeInfo = inherited.valueTypeInfo;
+  }
   return {
-    valueType: narrowedMemberValueType(ctx, member, valueType, inherited),
+    valueType: emittedValueType,
     hasSetter,
     getOnlyContract: (inherited?.getOnlyContract ?? false) || isAbstractMember(member) === true && !hasSetter,
-    valueTypeInfo: generatedValueTypeInfo(ctx, member),
+    valueTypeInfo,
+    genericEnv,
     closesGenericType: (inherited?.closesGenericType ?? false) || lookupNarrowsThroughGenericParam(member) || isMemberGenericBase(member)
   };
 }
@@ -28181,7 +28261,8 @@ function suppressesInheritedSetter(contract) {
 }
 function generatedValueTypeInfo(ctx, member) {
   const required2 = isRequiredMember(member);
-  if (isMemberTupleBase(member)) return memberTypeInfoForCodegen(ctx, member);
+  if (isMemberTupleBase(member) || isMemberVariantBase(member))
+    return memberTypeInfoForCodegen(ctx, member);
   const slotType = classSlotTypeInfo(ctx, member, required2);
   if (slotType !== null) return slotType;
   const returnType = nsPropertyReturnTypeInfo(member);
@@ -28196,8 +28277,8 @@ function generatedValueTypeInfo(ctx, member) {
   return null;
 }
 function genericParamTypeInfo(ctx, genericParamId, required2) {
-  const declaration = findGenericParamDeclaration(genericParamId, ctx.classes);
-  if (declaration === null) {
+  const declaration = ctx.genericDeclarations.get(genericParamId);
+  if (declaration === void 0) {
     ctx.diagnostics.push({
       severity: "error",
       message: `Generic param "${genericParamId}" is not declared by any type in the export.`,
@@ -28208,7 +28289,7 @@ function genericParamTypeInfo(ctx, genericParamId, required2) {
   return {
     type: 21 /* Generic */,
     required: required2,
-    ownerClassId: declaration.declaringClass.id,
+    ownerClassId: declaration.declaringClassId,
     genericParamId
   };
 }
@@ -28229,7 +28310,7 @@ function classSlotTypeInfo(ctx, member, required2) {
         "classArguments"
       );
       if (argument2 === null) return null;
-      const typeInfo = memberTypeInfoForCodegen(ctx, argument2);
+      const typeInfo = storedMemberTypeInfoForCodegen(ctx, argument2);
       if (typeInfo === null) return null;
       typeArguments[parameterId] = typeInfo;
     }
@@ -28257,9 +28338,63 @@ function generatedValueClassId(ctx, member) {
   const typeInfo = generatedValueTypeInfo(ctx, member);
   return typeInfo?.type === 7 /* Class */ ? typeInfo.classId : null;
 }
+function referenceDepth(ctx, type2, env) {
+  let depth = 0;
+  let current = type2;
+  let seen;
+  while (current !== null) {
+    if (current.type === 29 /* Reference */) {
+      depth++;
+      current = current.targetTypeInfo;
+      continue;
+    }
+    if (current.type !== 21 /* Generic */) return depth;
+    if (!isClassGenericParamTypeInfo(current)) return depth;
+    const entry = env?.get(current.genericParamId);
+    if (entry === void 0 || entry.kind === "unbound") return depth;
+    seen ??= /* @__PURE__ */ new Set();
+    if (seen.has(entry.memberId)) return null;
+    seen.add(entry.memberId);
+    const binding = resolveMemberById(ctx, entry.memberId, "genericBinding");
+    if (binding === null) return null;
+    if (isMemberGenericBase(binding)) {
+      current = genericParamTypeInfo(ctx, binding.genericParamId, true);
+    } else if (isMemberLookupBase(binding) && !isMultiSelectionMember(binding)) {
+      current = slotTypeInfo(binding, ctx);
+    } else {
+      return depth;
+    }
+  }
+  return null;
+}
+function referenceImplementsValueContract(ctx, member, rawValueType, contract) {
+  if (contract?.getOnlyContract !== true || !isMemberLookupBase(member) || isMultiSelectionMember(member))
+    return false;
+  const projection = lookupProjection(ctx, member);
+  if (contract.valueTypeInfo?.type === 21 /* Generic */ && (lookupDeclaredTypeInfo(member)?.type === 21 /* Generic */ || projection === "collection" /* Collection */))
+    return true;
+  if (projection !== "slot" /* Slot */) return false;
+  const target = lookupDeclaredTypeInfo(member);
+  const inherited = contract.valueTypeInfo;
+  if (target?.type === 29 /* Reference */ && inherited?.type === 29 /* Reference */) {
+    const targetDepth = referenceDepth(ctx, target, contract.genericEnv);
+    return targetDepth !== null && targetDepth === referenceDepth(ctx, inherited, contract.genericEnv);
+  }
+  const wrapper = `NeoReference<${contract.valueType}>`;
+  if (rawValueType === wrapper || rawValueType === `${wrapper}?`) return true;
+  if (contract.valueType.endsWith("?")) {
+    const requiredTarget = `NeoReference<${contract.valueType.slice(0, -1)}>`;
+    return rawValueType === requiredTarget || rawValueType === `${requiredTarget}?`;
+  }
+  return false;
+}
 function narrowedMemberValueType(ctx, member, rawValueType, contract) {
   if (contract === null) return rawValueType;
   if (contract.valueType === rawValueType) return rawValueType;
+  if (referenceImplementsValueContract(ctx, member, rawValueType, contract))
+    return contract.valueType;
+  if (contract.valueTypeInfo?.type === 29 /* Reference */ && isMemberLookupBase(member) && !isMultiSelectionMember(member))
+    return contract.valueType;
   if (contract.closesGenericType && !isMemberGenericBase(member) && !lookupNarrowsThroughGenericParam(member)) {
     return contract.valueType;
   }
@@ -28278,6 +28413,13 @@ function narrowedMemberValueType(ctx, member, rawValueType, contract) {
     return rawValueType;
   const valueType = generatedValueTypeInfo(ctx, member);
   if (valueType === null) return rawValueType;
+  if (isMemberVariantBase(member) && member.valueTypeInfo == null && inheritedType.type === 7 /* Class */ && valueType.type === 7 /* Class */ && inheritedType.classId === valueType.classId) {
+    const declaration = ctx.exportData.classes[inheritedType.classId];
+    const targetParamId = declaration?.genericParams?.[0]?.id;
+    const target = targetParamId === void 0 ? void 0 : inheritedType.typeArguments?.[targetParamId];
+    if (declaration?.system?.worldKind === NeoWorldSystemClassKind.Variant && target !== void 0 && isTypeInfoAssignable(member.targetTypeInfo, target, ctx))
+      return contract.valueType;
+  }
   const sourceType = valueType.type === 7 /* Class */ && inheritedType.type === 7 /* Class */ && valueType.required === false && inheritedType.required === true ? { ...valueType, required: true } : valueType;
   try {
     return isTypeInfoAssignable(sourceType, inheritedType, ctx) ? contract.valueType : rawValueType;
@@ -28380,8 +28522,13 @@ function calculateDeclarationSignature(ctx, projectionClassId, schemaKey, declar
     true,
     declaration.classDef.id
   );
-  const declaredLookupType = lookupDeclaredTypeInfo(member);
-  const valueType = declaredLookupType !== null && declaredLookupType.type === 21 /* Generic */ ? csharpTypeInfoValueType(ctx, declaredLookupType, true, genericEnv) : csharpPropertyValueType(ctx, member, memberSaved, genericEnv, true);
+  const valueType = declaredGeneratedPropertyValueType(
+    ctx,
+    member,
+    memberSaved,
+    true,
+    genericEnv
+  );
   if (valueType === null) return null;
   const contract = inheritedGeneratedMemberContract(
     ctx,
@@ -28744,11 +28891,11 @@ function csharpGenericParamType(ctx, genericParamId, saved, env, path) {
   if (entry !== void 0 && entry.kind === "member") {
     const bindingMember = resolveMemberById(ctx, entry.memberId, path);
     if (bindingMember === null) return null;
-    return csharpValueType(ctx, bindingMember, saved, env);
+    return csharpGenericArgumentMemberType(ctx, bindingMember, env, saved);
   }
   const terminalParamId = entry !== void 0 && entry.kind === "unbound" ? entry.paramId : genericParamId;
-  const declaration = findGenericParamDeclaration(terminalParamId, ctx.classes);
-  if (declaration === null) {
+  const declaration = ctx.genericDeclarations.get(terminalParamId);
+  if (declaration === void 0) {
     ctx.diagnostics.push({
       severity: "error",
       message: `Generic param "${terminalParamId}" is not declared by any type in the export.`,
@@ -28796,7 +28943,7 @@ function constructedTypeArgumentsSuffix(ctx, member, saved, env, genericBindingS
     }
     const bindingMember = resolveMemberById(ctx, arg.memberId, path);
     if (bindingMember === null) return null;
-    const argType = csharpValueType(ctx, bindingMember, true, env);
+    const argType = csharpGenericArgumentMemberType(ctx, bindingMember, env);
     if (argType === null) {
       ctx.diagnostics.push({
         severity: "error",
@@ -28944,7 +29091,7 @@ function interfaceBridgeCodecType(ctx, typeInfo, env) {
 function bindingMemberValueType(ctx, memberId, env, path) {
   const bindingMember = resolveMemberById(ctx, memberId, path);
   if (bindingMember === null) return null;
-  return csharpValueType(ctx, bindingMember, true, env);
+  return csharpGenericArgumentMemberType(ctx, bindingMember, env);
 }
 function typeInfoInterfaceArgumentsSuffix(ctx, typeInfo, genericEnv, genericBindingSaved) {
   const params = ctx.exportData.interfaces[typeInfo.interfaceId]?.genericParams;
@@ -28964,10 +29111,16 @@ function typeInfoInterfaceArgumentsSuffix(ctx, typeInfo, genericEnv, genericBind
       });
       return null;
     }
-    const argType = csharpTypeInfoValueType(
+    const argType = sequenceParameters.has(param.id) ? csharpTypeInfoValueType(
       ctx,
       argInfo,
-      !sequenceParameters.has(param.id),
+      false,
+      genericEnv,
+      genericBindingSaved
+    ) : csharpGenericArgumentType(
+      ctx,
+      argInfo,
+      true,
       genericEnv,
       genericBindingSaved
     );
@@ -29463,6 +29616,120 @@ function animationClipTargetType(ctx, member, env, ownerClassId) {
   }
   return constructedTarget;
 }
+function storedMemberTypeInfoForCodegen(ctx, member) {
+  if (isMemberTupleBase(member)) return tupleMemberTypeInfo(ctx, member);
+  if (isMemberLookupBase(member) || isMemberEnumBase(member))
+    return slotTypeInfo(member, ctx);
+  if (isMemberWithEntries(member)) {
+    const entry = resolveMemberById(ctx, member.entryMemberId, "entryMemberId");
+    if (entry === null) return null;
+    const entryTypeInfo = storedMemberTypeInfoForCodegen(ctx, entry);
+    if (entryTypeInfo === null) return null;
+    return {
+      type: member.kind,
+      required: isRequiredMember(member),
+      entryTypeInfo,
+      ...isMemberDictionaryBase(member) && member.keyEnumId ? { keyEnumId: member.keyEnumId } : {}
+    };
+  }
+  return memberTypeInfoForCodegen(ctx, member);
+}
+function csharpGenericArgumentMemberType(ctx, member, env, saved = true) {
+  const type2 = storedMemberTypeInfoForCodegen(ctx, member);
+  return type2 === null ? csharpValueType(ctx, member, saved, env) : csharpGenericArgumentType(ctx, type2, saved, env);
+}
+function csharpGenericArgumentType(ctx, type2, saved, env, genericBindingSaved = saved) {
+  const optional2 = type2.required ? "" : "?";
+  const family = saved ? "Neo" : "NeoReadOnly";
+  switch (type2.type) {
+    case 14 /* Vector2 */:
+    case 15 /* Vector2Int */:
+    case 16 /* Vector3 */:
+    case 17 /* Vector3Int */:
+      return `${vectorWrapperType(type2.type, saved)}${optional2}`;
+    case 19 /* Color */:
+      return `${family}Color${optional2}`;
+    case 6 /* List */:
+    case 5 /* Dictionary */:
+    case 28 /* Set */:
+    case 9 /* Lookup */: {
+      const entry = type2.entryTypeInfo;
+      const set = type2.type === 28 /* Set */ || type2.type === 9 /* Lookup */;
+      let wrapper = type2.type === 6 /* List */ ? "List" : "Dictionary";
+      let entryType;
+      if (set && entry.type === 29 /* Reference */) {
+        wrapper = "LookupSet";
+        entryType = csharpGenericArgumentType(
+          ctx,
+          entry,
+          false,
+          env,
+          genericBindingSaved
+        );
+      } else if (set && entry.type === 8 /* Enum */) {
+        wrapper = "EnumSet";
+        entryType = csharpTypeInfoValueType(
+          ctx,
+          entry,
+          false,
+          env,
+          genericBindingSaved
+        );
+      } else if (set && entry.type === 18 /* DialogueLookup */) {
+        return `${family}DialogueReferenceSet${optional2}`;
+      } else {
+        if (set) wrapper = "Set";
+        const entrySaved = saved && (!set || entry.type === 7 /* Class */ || entry.type === 22 /* Interface */ || entry.type === 21 /* Generic */);
+        entryType = csharpGenericArgumentType(
+          ctx,
+          entry,
+          entrySaved,
+          env,
+          genericBindingSaved
+        );
+      }
+      if (entryType === null) return null;
+      if (type2.type === 5 /* Dictionary */ && type2.keyEnumId !== void 0) {
+        const key = ctx.enumNames.get(type2.keyEnumId);
+        if (key === void 0) return null;
+        entryType = `${key}, ${entryType}`;
+      }
+      return `${family}${wrapper}<${entryType}>${optional2}`;
+    }
+    case 29 /* Reference */: {
+      const collection = referencedCollectionView(
+        ctx,
+        type2.targetTypeInfo,
+        env
+      );
+      if (collection !== null) return `${collection.view}${optional2}`;
+      const handle = referenceHandleTypeInfo(ctx, type2);
+      if (handle !== null)
+        return csharpTypeInfoValueType(
+          ctx,
+          handle,
+          false,
+          env,
+          genericBindingSaved
+        );
+      return csharpTypeInfoValueType(
+        ctx,
+        type2,
+        false,
+        env,
+        genericBindingSaved
+      );
+    }
+    default:
+      return csharpTypeInfoValueType(
+        ctx,
+        type2,
+        saved,
+        env,
+        genericBindingSaved
+      );
+  }
+}
 function csharpTypeInfoValueType(ctx, typeInfo, saved, genericEnv, genericBindingSaved = saved) {
   const optional2 = !typeInfo.required;
   switch (typeInfo.type) {
@@ -29648,7 +29915,7 @@ function typeInfoConstructedSuffix(ctx, typeInfo, saved, genericEnv, genericBind
       });
       return null;
     }
-    const argType = csharpTypeInfoValueType(
+    const argType = csharpGenericArgumentType(
       ctx,
       argInfo,
       true,
@@ -30384,24 +30651,29 @@ function pointerOwnershipForStorage(storage) {
       return "asset";
   }
 }
+function tupleMemberTypeInfo(ctx, member) {
+  const elements = [];
+  for (const [index, id2] of member.elementMemberIds.entries()) {
+    const descriptor = resolveMemberById(ctx, id2, "elementMemberIds");
+    if (descriptor === null) return null;
+    const typeInfo = storedMemberTypeInfoForCodegen(ctx, descriptor);
+    if (typeInfo === null) return null;
+    elements.push({
+      typeInfo,
+      ...descriptor.name === `Item${index + 1}` ? {} : { name: descriptor.name }
+    });
+  }
+  return {
+    type: 30 /* Tuple */,
+    required: isRequiredMember(member),
+    elements
+  };
+}
 function memberTypeInfoForCodegen(ctx, member) {
   const required2 = isRequiredMember(member);
   if (isMemberGenericBase(member))
     return genericParamTypeInfo(ctx, member.genericParamId, required2);
-  if (isMemberTupleBase(member)) {
-    const elements = [];
-    for (const [index, id2] of member.elementMemberIds.entries()) {
-      const descriptor = resolveMemberById(ctx, id2, "elementMemberIds");
-      if (descriptor === null) return null;
-      const typeInfo = memberTypeInfoForCodegen(ctx, descriptor);
-      if (typeInfo === null) return null;
-      elements.push({
-        typeInfo,
-        ...descriptor.name === `Item${index + 1}` ? {} : { name: descriptor.name }
-      });
-    }
-    return { type: 30 /* Tuple */, required: required2, elements };
-  }
+  if (isMemberTupleBase(member)) return tupleMemberTypeInfo(ctx, member);
   const slotType = classSlotTypeInfo(ctx, member, required2);
   if (slotType !== null) return slotType;
   if (isMemberLookupBase(member)) {
@@ -30446,9 +30718,12 @@ function memberTypeInfoForCodegen(ctx, member) {
   }
   if (isMemberNSPropertyBase(member)) return member.returnTypeInfo;
   if (isMemberVariantBase(member)) {
+    const lookup = member.valueTypeInfo != null;
+    const kind = lookup ? NeoWorldSystemClassKind.LookupVariant : NeoWorldSystemClassKind.Variant;
+    const declaration = ctx.exportData.classes[requireWorldSystemClassDefinition(kind).classId];
     const systemClass = neoVariantSystemClass(
-      ctx.classes,
-      member.valueTypeInfo != null
+      declaration === void 0 ? [] : [declaration],
+      lookup
     );
     return variantMemberDeclaredTypeInfo(member, systemClass);
   }
@@ -36730,6 +37005,13 @@ var init_function_type_inference = __esm({
           this.bounds[index]?.set(`${kind}:${identity(type2)}`, { type: type2, kind });
           return;
         }
+        if (pattern.kind === "tuple" && actual.kind === "tuple") {
+          if (actual.elements.length !== pattern.elements.length) return;
+          pattern.elements.forEach((element, index) => {
+            this.add(actual.elements[index].type, element.type, kind);
+          });
+          return;
+        }
         if (pattern.kind === "named" && (pattern.typeId === NEO_SEQUENCE_IDS.IEnumerable || pattern.typeId === NEO_SEQUENCE_IDS.IEnumerator)) {
           const sourceElement = neoScriptSequenceElementType(actual, "IEnumerable", this.project) ?? (pattern.typeId === NEO_SEQUENCE_IDS.IEnumerator ? neoScriptSequenceElementType(actual, "IEnumerator", this.project) : void 0);
           const expectedElement = pattern.typeArguments?.[0];
@@ -39023,6 +39305,25 @@ function addEvaluatorParentLink(indexes4, childId, parentId, key) {
   links.push({ parentId, key });
   indexes4.parentLinksByChildId.set(childId, links);
 }
+function indexRuntimeCollectionAppend(collection, entry, ctx) {
+  const indexes4 = ctx.__indexes;
+  const row = indexes4?.rowByValueReference.get(collection);
+  if (indexes4 === void 0 || indexes4.invalidated || row === void 0 || ctx.__runtimeSessionValues?.get(row.id) !== row || !indexes4.indexedRowIds.has(row.id))
+    return false;
+  if (typeof entry === "string") {
+    addEvaluatorParentLink(indexes4, entry, row.id, "");
+    indexes4.ownedValueAttachmentsByValueId.delete(entry);
+    indexes4.constructorOwnershipDirtyValueIds.add(entry);
+    indexes4.ownershipRootIdsByRowId.clear();
+    indexes4.ownershipDistancesByRowId.clear();
+    indexes4.memberByRowId.clear();
+  }
+  forgetLocalListIndexes(ctx, collection);
+  markOverlayMutated(ctx, collection);
+  if (ctx.__valueOverlay instanceof LazyValueOverlay)
+    indexes4.overlayRevision = ctx.__valueOverlay.revision;
+  return true;
+}
 function evaluatorParentLinks(indexes4, childId) {
   const unfilteredBase = indexes4.baseParentLinksByChildId?.get(childId) ?? [];
   const base = indexes4.shadowedBaseRowIds.size === 0 ? unfilteredBase : unfilteredBase.filter(
@@ -39343,11 +39644,15 @@ function evaluatorDefaultValueDocument(ctx) {
       project: ctx.vm.project,
       members: ctx.vm.members,
       classes: ctx.vm.classes,
+      constructors: ctx.vm.constructors,
       interfaces: ctx.vm.interfaces ?? NO_INTERFACES,
       enums: ctx.vm.enums,
       values: ctx.vm.values,
       memberById: ctx.vm.databaseVM?.memberById,
-      valueById: ctx.vm.databaseVM?.defaultValueById ?? ctx.vm.databaseVM?.valueById,
+      defaultValueSource: ctx.vm.databaseVM?.defaultValueSource?.bind(
+        ctx.vm.databaseVM
+      ),
+      valueById: ctx.vm.databaseVM?.valueById,
       unorderedListEntryIds: ctx.vm.databaseVM?.unorderedListEntryIds?.bind(
         ctx.vm.databaseVM
       ),
@@ -41455,6 +41760,12 @@ function evalInstructions(instructions, scope, ctx, options) {
                 destination
               );
             }
+            if (target.structuredLeafKind !== void 0 && destination !== void 0)
+              validateStructuredFieldAssignment(
+                target.structuredLeafKind,
+                String(destination.key),
+                value
+              );
             assertStoredClosureCaptures(
               member,
               target.pointer,
@@ -41474,7 +41785,7 @@ function evalInstructions(instructions, scope, ctx, options) {
               const selection2 = encodeLookupInitializerSelection(
                 lookupMember,
                 value,
-                [],
+                /* @__PURE__ */ new Set(),
                 ctx,
                 lookupTarget
               );
@@ -41487,7 +41798,7 @@ function evalInstructions(instructions, scope, ctx, options) {
               );
               value = selection2;
             }
-            let targetTypeInfo = target.typeInfo;
+            let targetTypeInfo = runtimeConcreteTypeInfo(target.typeInfo, ctx);
             if (lookupMember !== null && targetTypeInfo.type !== 9 /* Lookup */ && targetTypeInfo.type !== 18 /* DialogueLookup */) {
               const entryTypeInfo = targetTypeInfo.type === 29 /* Reference */ ? targetTypeInfo.targetTypeInfo : targetTypeInfo;
               targetTypeInfo = lookupMember.collectionMemberId === void 0 ? {
@@ -42176,6 +42487,23 @@ function evalActionListenerInstruction(ins, scope, ctx, options) {
     ...resolvedDestinationFieldsForAssign(target, scope, ctx, destination)
   });
 }
+function validateStructuredFieldAssignment(kind, field, value) {
+  const subject = kind === "Color" ? `Colour channel '${field}'` : `Vector field '${field}'`;
+  if (typeof value !== "number")
+    throw new NSGetterRuntimeError(`${subject} must be numeric.`);
+  const numeric = value;
+  if (!Number.isFinite(numeric))
+    throw new NSGetterRuntimeError(`${subject} must be a finite number.`);
+  if (kind === "Color" && (numeric < 0 || numeric > 1))
+    throw new NSGetterRuntimeError(
+      `${subject} must be within [0, 1]; found ${numeric}.`
+    );
+  if ((kind === "Vector2Int" || kind === "Vector3Int") && !Number.isInteger(numeric))
+    throw new NSGetterRuntimeError(
+      `${subject} must be an integer on an integer vector; found ${numeric}.`,
+      { errorClassId: NEO_ERROR_CLASS_IDS.NeoArgumentError }
+    );
+}
 function applyOverlayAssignment(target, targetTypeInfo, value, scope, ctx, destination) {
   if (target.type === "staticMember" /* staticMember */) {
     if (ctx.storedConstructionReplay === true) {
@@ -42193,7 +42521,6 @@ function applyOverlayAssignment(target, targetTypeInfo, value, scope, ctx, desti
   }
   const receiver = destination === void 0 ? evalPointer(target.keyOf.pointer, scope, ctx) : destination.receiver;
   const key = destination === void 0 ? evalPointer(target.keyOf.key, scope, ctx) : destination.key;
-  assertStoredReplayMutableValue(receiver, ctx, "assignment target", key);
   if (findKnownRowIdByValueReference(receiver, ctx) !== null)
     assertInterfaceValueKind(
       targetTypeInfo,
@@ -42202,6 +42529,13 @@ function applyOverlayAssignment(target, targetTypeInfo, value, scope, ctx, desti
       ctx
     );
   const referenceValueId = targetTypeInfo.type === 7 /* Class */ || targetTypeInfo.type === 22 /* Interface */ || targetTypeInfo.type === 6 /* List */ || targetTypeInfo.type === 28 /* Set */ || targetTypeInfo.type === 5 /* Dictionary */ ? findKnownRowIdByValueReference(value, ctx) : null;
+  const reattachesReplaySlot = ctx.storedConstructionReplay === true && ctx.__storedConstructionReplayRootId !== void 0 && target.memberId !== void 0 && referenceValueId !== null && receiver !== null && typeof receiver === "object" && Reflect.get(receiver, String(key)) === referenceValueId && findKnownRowIdByValueReference(receiver, ctx) === ctx.__storedConstructionReplayRootId;
+  assertStoredReplayMutableValue(
+    receiver,
+    ctx,
+    "assignment target",
+    reattachesReplaySlot ? void 0 : key
+  );
   if (Array.isArray(receiver)) {
     const index = numberArg(key, "List assignment index");
     if (referenceValueId !== null) {
@@ -42246,6 +42580,14 @@ function applyOverlayAssignment(target, targetTypeInfo, value, scope, ctx, desti
   const object2 = objectArg(receiver, "Assignment target");
   const stringKey = String(key);
   const field = target.memberId !== void 0;
+  if (field && isTypeInfoWithEntries(targetTypeInfo)) {
+    const slot = collectionSlotRow(target, { receiver, key }, ctx);
+    if (slot !== null && slot.id !== referenceValueId) {
+      object2[stringKey] = slot.id;
+      if (replaceEntryRowValue(receiver, slot.id, value, targetTypeInfo, ctx))
+        return;
+    }
+  }
   if (referenceValueId !== null) {
     const parentId = findKnownRowIdByValueReference(receiver, ctx);
     if (parentId !== null) {
@@ -42312,6 +42654,9 @@ function collectionSlotRow(target, destination, ctx) {
     if (!isReferenceEntry(collectionReferences(receiver, ctx), entryKey))
       return null;
     slotId = Reflect.get(receiver, entryKey);
+    if (typeof slotId !== "string" && target.type === "keyOf" /* keyOf */ && target.memberId !== void 0 && !Array.isArray(receiver)) {
+      slotId = slotTargetId(receiver, String(key), target.memberId, ctx);
+    }
   }
   if (typeof slotId !== "string") return null;
   return evalValueById(
@@ -42383,20 +42728,196 @@ function replaceEntryRowValue(receiver, existing, value, targetTypeInfo, ctx) {
     `collection entry '${existing}'`,
     ctx
   );
-  keepAssignedCollectionValues(value, targetTypeInfo, ctx);
+  keepAssignedCollectionValues(value, targetTypeInfo, row, ctx);
+  if (isTypeInfoWithEntries(targetTypeInfo))
+    retainCollectionEntryReferences(row.value, ctx);
   replaceRowValue(row, value, receiver, ctx);
   updateUnorderedListProjectionAfterAssignment(row, value, ctx);
   return true;
 }
-function keepAssignedCollectionValues(value, targetTypeInfo, ctx) {
+function keepAssignedCollectionValues(value, targetTypeInfo, row, ctx) {
+  if (!isTypeInfoWithEntries(targetTypeInfo)) return;
+  let collection;
   const cache = unorderedListProjectionCache(ctx);
-  if (Array.isArray(value) && (targetTypeInfo.type === 6 /* List */ || targetTypeInfo.type === 28 /* Set */)) {
+  if (Array.isArray(value)) {
+    collection = value;
     if (!cache.referenceEntryIndexesByArray.has(value))
       cache.referenceEntryIndexesByArray.set(value, /* @__PURE__ */ new Set());
+  } else if (targetTypeInfo.type === 5 /* Dictionary */ && typeof value === "object" && value !== null) {
+    collection = objectArg(value, "Dictionary assignment");
+    if (!cache.referenceEntryKeysByRecord.has(collection))
+      cache.referenceEntryKeysByRecord.set(collection, /* @__PURE__ */ new Set());
+  } else {
+    return;
+  }
+  const entryType = targetTypeInfo.entryTypeInfo;
+  if (entryType.type !== 7 /* Class */ && entryType.type !== 22 /* Interface */)
     return;
+  const member = memberForValueRow(row, ctx);
+  if (member !== null && isMemberEntryCollectionBase(member) && listKindOf(member) === 1 /* Unordered */)
+    return;
+  preflightAssignedCollection(collection, member, row, ctx);
+  forEachRawCollectionEntry(collection, ctx, ({ raw, key, valueId }) => {
+    if (valueId !== null) return 0 /* Continue */;
+    const rowId = findKnownRowIdByValueReference(raw, ctx);
+    if (rowId !== null) {
+      Reflect.set(collection, key, rowId);
+      recordWrittenEntry(collection, key, true, ctx);
+    }
+    return 0 /* Continue */;
+  });
+}
+function pendingConstructorRootsForRow(valueId, ctx) {
+  const roots = /* @__PURE__ */ new Set();
+  const open2 = ctx.__executionState?.openConstructions;
+  if (open2 === void 0 || open2.size === 0) return roots;
+  const visited = /* @__PURE__ */ new Set();
+  const pending = [valueId];
+  const parentEntries = /* @__PURE__ */ new Map();
+  const placingMembers = /* @__PURE__ */ new Map();
+  while (pending.length > 0) {
+    const id2 = pending.pop();
+    if (id2 === void 0 || visited.has(id2)) continue;
+    visited.add(id2);
+    const row = evalValueById(
+      ctx,
+      id2,
+      ctx.__runtimeSessionValues,
+      ctx.__valueOverlay
+    );
+    if (row === null) continue;
+    if (typeof row.value === "object" && row.value !== null && open2.has(row.value))
+      roots.add(id2);
+    for (const owner of currentOwnedValueAttachments(
+      id2,
+      ctx,
+      parentEntries,
+      placingMembers
+    )) {
+      if (!owner.identity.startsWith("value:")) continue;
+      const parent = evalValueById(
+        ctx,
+        owner.label,
+        ctx.__runtimeSessionValues,
+        ctx.__valueOverlay
+      );
+      if (parent === null) continue;
+      if (parent.classId === void 0 || parent.classId === null) {
+        const raw = placingMember(
+          parent,
+          ctx,
+          void 0,
+          0,
+          placingMembers,
+          parentEntries
+        );
+        if (raw === null) continue;
+        const member = raw.kind === 21 /* Generic */ ? substituteMember(raw, rowGenericEnv(parent, ctx), ctx.vm.members) : resolveMember(raw, ctx.vm.members);
+        if (isMemberWithEntries(member)) {
+          const rawEntry = evalMemberById(ctx.vm, member.entryMemberId);
+          if (rawEntry === null) continue;
+          const entry = rawEntry.kind === 21 /* Generic */ ? substituteMember(
+            rawEntry,
+            rowGenericEnv(parent, ctx),
+            ctx.vm.members
+          ) : resolveMember(rawEntry, ctx.vm.members);
+          if (entry.kind === 21 /* Generic */ || isMemberLookupBase(entry))
+            continue;
+        }
+      }
+      pending.push(owner.label);
+    }
+    for (const link of evaluatorParentLinks(evaluatorIndexes(ctx), id2)) {
+      const parent = evalValueById(
+        ctx,
+        link.parentId,
+        ctx.__runtimeSessionValues,
+        ctx.__valueOverlay
+      );
+      if (parent === null || !Array.isArray(parent.value)) continue;
+      const member = placingMember(
+        parent,
+        ctx,
+        void 0,
+        0,
+        placingMembers,
+        parentEntries
+      );
+      if (member === null || !isMemberTupleBase(member)) continue;
+      const positions = ownershipParentEntryKeys(
+        parent.value,
+        id2,
+        parentEntries
+      );
+      for (const position of positions ?? []) {
+        if (typeof position !== "number") continue;
+        const entryId = member.elementMemberIds[position];
+        const rawEntry = entryId === void 0 ? null : evalMemberById(ctx.vm, entryId);
+        if (rawEntry === null) continue;
+        const entry = rawEntry.kind === 21 /* Generic */ ? substituteMember(
+          rawEntry,
+          rowGenericEnv(parent, ctx),
+          ctx.vm.members
+        ) : resolveMember(rawEntry, ctx.vm.members);
+        if (entry.kind === 21 /* Generic */ || isMemberLookupBase(entry))
+          continue;
+        pending.push(parent.id);
+        break;
+      }
+    }
   }
-  if (targetTypeInfo.type === 5 /* Dictionary */ && typeof value === "object" && value !== null && !cache.referenceEntryKeysByRecord.has(value)) {
-    cache.referenceEntryKeysByRecord.set(value, /* @__PURE__ */ new Set());
+  return roots;
+}
+function preflightAssignedCollection(collection, member, row, ctx) {
+  if (member === null) return;
+  const env = rowGenericEnv(row, ctx);
+  const resolved = substituteMember(member, env, ctx.vm.members);
+  if (!isMemberWithEntries(resolved)) return;
+  const rawEntry = evalMemberById(ctx.vm, resolved.entryMemberId);
+  if (rawEntry === null) return;
+  const entry = substituteMember(rawEntry, env, ctx.vm.members);
+  if (!isClassSlotMember(entry)) return;
+  const attached = /* @__PURE__ */ new Set();
+  const preflight = {
+    parentEntries: /* @__PURE__ */ new Map(),
+    constructorRootIds: pendingConstructorRootsForRow(row.id, ctx),
+    constructorArgumentTransfers: /* @__PURE__ */ new Map(),
+    dependencies: /* @__PURE__ */ new Map()
+  };
+  forEachRawCollectionEntry(collection, ctx, ({ raw, key, valueId }) => {
+    const id2 = valueId ?? findKnownRowIdByValueReference(raw, ctx);
+    if (id2 === null) return 0 /* Continue */;
+    if (attached.has(id2))
+      throw new NSGetterRuntimeError(
+        `Aggregate value '${id2}' is already owned by another entry of '${row.id}'. Call Clone() explicitly.`
+      );
+    attached.add(id2);
+    const placement = Array.isArray(collection) ? "index" : "slot";
+    assertOwnedValueAttachable(
+      id2,
+      { identity: `value:${row.id}:${placement}:${key}`, label: row.id },
+      `${row.id}[${key}]`,
+      ctx,
+      false,
+      "assign",
+      preflight
+    );
+    return 0 /* Continue */;
+  });
+  for (const [id2, destination] of preflight.constructorArgumentTransfers)
+    ctx.__executionState?.ownedValueAttachments.set(id2, destination);
+  for (const [id2, destination] of preflight.dependencies)
+    recordConstructorGroupDependency(id2, destination, ctx);
+}
+function retainCollectionEntryReferences(value, ctx) {
+  if (collectionReferences(value, ctx) !== 0 /* RowIds */) return;
+  if (Array.isArray(value)) {
+    referenceEntryList(value, ctx);
+  } else if (typeof value === "object" && value !== null) {
+    unorderedListProjectionCache(ctx).referenceEntryKeysByRecord.set(
+      value,
+      new Set(Object.keys(value))
+    );
   }
 }
 function replaceRowValue(row, value, receiver, ctx) {
@@ -42483,7 +43004,7 @@ function applyOverlayStaticAssignment(memberId, targetTypeInfo, value, ctx) {
       );
     }
     observeValueWrite(ctx, row);
-    keepAssignedCollectionValues(value, targetTypeInfo, ctx);
+    keepAssignedCollectionValues(value, targetTypeInfo, row, ctx);
     row.value = value ?? null;
     row.updatedAt = Date.now();
     updateUnorderedListProjectionAfterAssignment(row, value, ctx);
@@ -42823,7 +43344,7 @@ function materializeSlotRow(place, targetId, ctx) {
   const value = member === null ? read : encodeLookupInitializerSelection(
     member,
     read,
-    [],
+    /* @__PURE__ */ new Set(),
     ctx,
     lookupTargetTypeInfo(member, owner, ctx)
   );
@@ -43262,8 +43783,12 @@ function evalCollectionMutationInstruction(ins, scope, ctx, options) {
     );
   }
   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) {
+  if (ins.mutation === "Add" /* Add */) {
+    if (setMatch !== null) return;
+    if (targetValue instanceof RuntimeSet && targetValue.has(runtimeSetKey(args[0], targetValue, ctx)))
+      return;
+  }
+  if (ins.mutation === "Remove" /* Remove */ && setEntryMember !== null && Array.isArray(targetValue) && setMatch === null) {
     return;
   }
   if (mutatesLocalVariable && variablePointer !== null) {
@@ -43291,6 +43816,13 @@ function evalCollectionMutationInstruction(ins, scope, ctx, options) {
     return;
   }
   validateCollectionMutation(targetValue, ins.mutation, args);
+  if (!isLookupSet && entryArgumentIndex !== null && (ins.mutation === "Add" /* Add */ || ins.mutation === "Insert" /* Insert */) && findKnownRowIdByValueReference(targetValue, ctx) !== null)
+    trackInsertedCollection(
+      args[entryArgumentIndex],
+      collectionEntryWriteType(ins.target.typeInfo, targetValue, ctx),
+      targetValue,
+      ctx
+    );
   const overlayArgs = [...args];
   if ((ins.mutation === "Add" /* Add */ || ins.mutation === "Remove" /* Remove */) && isArrayCollection(targetValue)) {
     if (setMatch !== null) overlayArgs[0] = setMatch.entry;
@@ -43349,6 +43881,7 @@ function evalCollectionMutationInstruction(ins, scope, ctx, options) {
     );
   }
   const removableRowIds = isLookupSet || ins.reference === true ? null : removableEntryRowIds(targetValue, ins.mutation, overlayArgs, ctx);
+  const previousSetSize = targetValue instanceof RuntimeSet ? targetValue.size : null;
   const removedIndex = applyLocalCollectionMutation(
     targetValue,
     ins.mutation,
@@ -43420,7 +43953,28 @@ function evalCollectionMutationInstruction(ins, scope, ctx, options) {
       cache
     );
   }
-  invalidateEvaluatorIndexes(ctx, targetValue);
+  let indexedAppend = false;
+  if (targetValue instanceof RuntimeSet) {
+    if (ins.mutation === "Add" /* Add */) {
+      if (targetValue.size !== previousSetSize) {
+        targetValue.source.push(overlayArgs[0]);
+        recordWrittenEntry(
+          targetValue.source,
+          targetValue.source.length - 1,
+          targetValue.reference,
+          ctx
+        );
+        indexedAppend = indexRuntimeCollectionAppend(
+          targetValue.source,
+          overlayArgs[0],
+          ctx
+        );
+      }
+    } else {
+      exportRuntimeSetValue(targetValue, ctx);
+    }
+  }
+  if (!indexedAppend) invalidateEvaluatorIndexes(ctx, targetValue);
   switch (ins.mutation) {
     case "Insert" /* Insert */:
       options.writes.push({
@@ -43566,6 +44120,90 @@ function sortCollectionInPlace(ins, value, scope, ctx, options) {
       ...resolvedDestinationFieldsForContainer(list, ctx)
     });
 }
+function trackInsertedCollection(value, type2, parentValue, ctx) {
+  if (!isTypeInfoWithEntries(type2) && type2.type !== 9 /* Lookup */ || value === null || typeof value !== "object" || findKnownRowIdByValueReference(value, ctx) !== null)
+    return;
+  const parent = trackedRowForValueReference(parentValue, ctx);
+  const placement = parent === null ? null : memberForValueRow(parent, ctx);
+  if (parent === null || placement === null) return;
+  const genericEnv = rowGenericEnv(parent, ctx);
+  const parentMember = substituteMember(placement, genericEnv, ctx.vm.members);
+  if (!isMemberWithEntries(parentMember)) return;
+  const entry = evalMemberById(ctx.vm, parentMember.entryMemberId);
+  if (entry === null) return;
+  const member = substituteMember(entry, genericEnv, ctx.vm.members);
+  const createdValues = [];
+  const collectionAliases = /* @__PURE__ */ new Map();
+  const reservations = /* @__PURE__ */ new Map();
+  try {
+    const row = materializeConstructorArgumentValue({
+      member,
+      value,
+      genericEnv,
+      ctx,
+      createdValues,
+      createdById: /* @__PURE__ */ new Map(),
+      storageKeyDeclarations: /* @__PURE__ */ new Map(),
+      collectionEntriesAreReferences: false,
+      collectionAliases,
+      attachmentReservations: reservations
+    });
+    row.genericBindings = computeGenericBindingsStamp(
+      entry,
+      genericEnv,
+      ctx.vm.members
+    );
+    for (const [encoded, alias] of collectionAliases) {
+      retainEncodedCollectionAlias(encoded, alias, ctx);
+    }
+    for (const created of createdValues)
+      registerRuntimeSessionValue(ctx, created);
+    if (ctx.__indexes !== void 0)
+      indexEvaluatorRows(ctx.__indexes, createdValues);
+  } catch (error) {
+    for (const created of createdValues)
+      ctx.__executionState?.constructorGroupDependencies.delete(created.id);
+    throw error;
+  } finally {
+    const attachments = ctx.__executionState?.ownedValueAttachments;
+    for (const [id2, previous] of reservations) {
+      if (previous === void 0) attachments?.delete(id2);
+      else attachments?.set(id2, previous);
+    }
+  }
+}
+function retainEncodedCollectionAlias(row, alias, ctx) {
+  const stored = alias instanceof RuntimeSet ? alias.source : alias;
+  if (Array.isArray(stored) && Array.isArray(row.value)) {
+    const keys = alias instanceof RuntimeSet ? collectionEntries(alias, ctx).map(
+      (item) => runtimeSetKey(item, alias, ctx)
+    ) : null;
+    const encoded = row.value;
+    stored.length = encoded.length;
+    const references = /* @__PURE__ */ new Set();
+    for (let index = 0; index < encoded.length; index++) {
+      stored[index] = encoded[index];
+      references.add(index);
+    }
+    unorderedListProjectionCache(ctx).referenceEntryIndexesByArray.set(
+      stored,
+      references
+    );
+    if (alias instanceof RuntimeSet && keys !== null) {
+      alias.clear();
+      for (let index = 0; index < stored.length; index++)
+        alias.add(keys[index], stored[index], true);
+    }
+  } else if (isPlainRecord(stored) && isPlainRecord(row.value)) {
+    for (const [key, encoded] of Object.entries(row.value))
+      setOwnField(stored, key, encoded);
+    unorderedListProjectionCache(ctx).referenceEntryKeysByRecord.set(
+      stored,
+      new Set(Object.keys(stored))
+    );
+  }
+  row.value = stored;
+}
 function storedSetEntryMember(collection, ctx) {
   const containerId = findKnownRowIdByValueReference(collection, ctx);
   if (containerId === null) return null;
@@ -44311,6 +44949,39 @@ function slotTargetId(owner, key, memberId, ctx) {
   if (typeof virtual === "string") return virtual;
   return virtualValueId(ownerId, memberId);
 }
+function readDispatchedGetterValue(value, member, receiver, ctx) {
+  if (!(value instanceof NSSlotReference) || member === null) return value;
+  const declared = nsPropertyReturnTypeInfo(cachedResolvedMember(member, ctx));
+  if (declared === null) return value;
+  let expected = declared;
+  if (typeInfoContainsGeneric2(declared)) {
+    const row = trackedRowForValueReference(receiver, ctx);
+    if (row === null)
+      throw new NSGetterRuntimeError(
+        "Cannot resolve a generic getter contract without a tracked receiver."
+      );
+    expected = substituteRuntimeTypeInfo(
+      declared,
+      runtimeGenericEnvForValueRow(row, ctx),
+      ctx
+    );
+  }
+  let readLayers = 1;
+  let actualTarget = value.target;
+  while (actualTarget?.type === 29 /* Reference */) {
+    readLayers += 1;
+    actualTarget = actualTarget.targetTypeInfo;
+  }
+  let target = expected;
+  while (target.type === 29 /* Reference */) {
+    readLayers -= 1;
+    target = target.targetTypeInfo;
+  }
+  while (readLayers-- > 0 && value instanceof NSSlotReference) {
+    value = readThroughReference(value, ctx);
+  }
+  return value;
+}
 function readThroughReference(reference2, ctx) {
   if (!(reference2 instanceof NSSlotReference)) return reference2;
   if (reference2.place !== null) {
@@ -44562,7 +45233,13 @@ function evalPointerCore(pointer, scope, ctx, resultUsage = "value") {
       const schemaKey = pointer.memberId === NEO_SEQUENCE_IDS.Current ? "Current" : cachedSchemaKeyForMember(pointer.memberId, ctx);
       if (schemaKey !== null) {
         const dispatched = dispatchSchemaMember(innerThis, schemaKey, ctx);
-        if (dispatched.kind === "ok") return dispatched.value;
+        if (dispatched.kind === "ok")
+          return readDispatchedGetterValue(
+            dispatched.value,
+            extension,
+            innerThis,
+            ctx
+          );
       }
       return dispatchNSGetterById(pointer.memberId, innerThis, ctx);
     }
@@ -47207,7 +47884,21 @@ function placingMemberBinding(row, ctx) {
   const syntheticMemberId = memberIdFromSyntheticDefaultValueId(row.id);
   return syntheticMemberId === null ? null : evalMemberById(ctx.vm, syntheticMemberId);
 }
-function placingMember(row, ctx, ownerEdge, depth = 0) {
+function placingMember(row, ctx, ownerEdge, depth = 0, resolved, positions) {
+  const known = resolved?.get(row.id);
+  if (known !== void 0) return known;
+  const member = resolvePlacingMember(
+    row,
+    ctx,
+    ownerEdge,
+    depth,
+    resolved,
+    positions
+  );
+  if (member !== null) resolved?.set(row.id, member);
+  return member;
+}
+function resolvePlacingMember(row, ctx, ownerEdge, depth = 0, resolved, positions) {
   const bound = placingMemberBinding(row, ctx);
   if (bound !== null) return bound;
   const edge = ownerEdge ?? firstOwnerEdge(row, ctx);
@@ -47216,10 +47907,26 @@ function placingMember(row, ctx, ownerEdge, depth = 0) {
   if (depth >= MAX_AREA_DEPTH) return null;
   const parent = untrackedValueById(edge.parentId, ctx);
   if (parent === null) return null;
-  const parentMember = parent.classId === void 0 ? placingMember(parent, ctx, void 0, depth + 1) : null;
+  const parentMember = parent.classId === void 0 ? placingMember(parent, ctx, void 0, depth + 1, resolved, positions) : null;
   if (parentMember !== null && isMemberTupleBase(parentMember)) {
-    const memberId = parentMember.elementMemberIds[Number(edge.key)];
-    return memberId === void 0 ? null : evalMemberById(ctx.vm, memberId);
+    if (!Array.isArray(parent.value)) return null;
+    const keys = ownershipParentEntryKeys(parent.value, row.id, positions);
+    let selected = null;
+    for (const key of keys ?? parent.value.keys()) {
+      if (typeof key !== "number" || parent.value[key] !== row.id) continue;
+      const memberId = parentMember.elementMemberIds[key];
+      const candidate = memberId === void 0 ? null : evalMemberById(ctx.vm, memberId);
+      if (candidate === null) continue;
+      const contract = candidate.kind === 21 /* Generic */ ? substituteMember(
+        candidate,
+        rowGenericEnv(parent, ctx),
+        ctx.vm.members
+      ) : resolveMember(candidate, ctx.vm.members);
+      if (contract.kind !== 21 /* Generic */ && !isMemberLookupBase(contract))
+        return candidate;
+      selected ??= candidate;
+    }
+    return selected;
   }
   if (parentMember !== null && isMemberWithEntries(parentMember)) {
     return evalMemberById(ctx.vm, parentMember.entryMemberId);
@@ -49662,7 +50369,7 @@ function validateClassConstructorDescriptor(info, ctx, requireEveryRequiredField
     members: ctx.vm.members,
     constructors: ctx.vm.constructors ?? [],
     values: ctx.vm.values,
-    valueById: ctx.vm.databaseVM?.defaultValueById ?? ctx.vm.databaseVM?.valueById,
+    valueById: ctx.vm.databaseVM?.valueById,
     memberById: evaluatorDefaultValueDocument(ctx).memberById
   };
   const classArguments = slotArguments ?? resolveConstructionTypeArguments(typeArguments, constructionDocument);
@@ -49982,7 +50689,7 @@ function applyConstructorFields(args) {
       continue;
     }
     const { schemaKey, member } = validated;
-    const value = isMemberLookupBase(member) ? encodeLookupInitializerSelection(member, supplied, createdValues, ctx) : supplied;
+    const value = isMemberLookupBase(member) ? encodeLookupInitializerSelection(member, supplied, createdById, ctx) : supplied;
     const trackedValueId = findKnownRowIdByValueReference(value, ctx);
     if (trackedValueId !== null && isClassSlotMember(member)) {
       const source = evalValueById(
@@ -50310,11 +51017,15 @@ function constructorDefaultValueDocument(ctx, syntheticMember2) {
     // the entire project for every constructor replay.
     values: ctx.vm.values,
     memberById: database?.memberById,
+    defaultValueSource: database?.defaultValueSource === void 0 ? void 0 : (id2, member) => {
+      ctx.valueDependencies?.add(id2);
+      return database.defaultValueSource(id2, member);
+    },
     // The declaration rows a default clones are reads of this evaluation.
     ...database === void 0 ? {} : {
       valueById: (id2) => {
         ctx.valueDependencies?.add(id2);
-        return database.defaultValueById !== void 0 ? database.defaultValueById(id2) : database.valueById(id2);
+        return database.valueById(id2);
       }
     },
     ...entryIdsOf === void 0 ? {} : {
@@ -50994,9 +51705,12 @@ function evaluateInitializerInContext(init, member, ctx, createdValues, argument
       }
     );
   } catch (error) {
-    const ownerId = compileMemberId ?? Reflect.get(member, "id");
-    if (error instanceof NSGetterRuntimeError && sourceValueId === null && typeof ownerId === "string")
-      error.sourceOwnerId ??= ownerId;
+    if (error instanceof NSGetterRuntimeError) {
+      error.initializerValueId ??= sourceValueId ?? void 0;
+      const ownerId = compileMemberId ?? Reflect.get(member, "id");
+      if (sourceValueId === null && typeof ownerId === "string")
+        error.sourceOwnerId ??= ownerId;
+    }
     throw error;
   } finally {
     initializerCtx.__initializerGenericEnv = previousGenericEnv;
@@ -51004,7 +51718,19 @@ function evaluateInitializerInContext(init, member, ctx, createdValues, argument
   }
   const created = result.createdSessionValues ?? [];
   if (isMemberLookupBase(member)) {
-    return encodeLookupInitializerResult(member, result.value, created, ctx);
+    const declaredTarget2 = lookupTargetTypeInfo(member, null, ctx);
+    const target = typeInfoContainsGeneric2(declaredTarget2) ? substituteRuntimeTypeInfo(
+      declaredTarget2,
+      genericEnv,
+      ctx
+    ) : declaredTarget2;
+    return encodeLookupInitializerResult(
+      member,
+      result.value,
+      created,
+      ctx,
+      target
+    );
   }
   let rootRow = initializerRootRow(result.value, created);
   for (const row of created) {
@@ -51094,12 +51820,13 @@ function ensureInitializerCompiled(args) {
   }
   return compiled;
 }
-function encodeLookupInitializerResult(member, value, created, ctx) {
+function encodeLookupInitializerResult(member, value, created, ctx, target = lookupTargetTypeInfo(member, null, ctx)) {
   const selection2 = encodeLookupInitializerSelection(
     member,
     value,
-    created,
-    ctx
+    new Set(created.map((row) => row.id)),
+    ctx,
+    target
   );
   if (created.length > 0) {
     for (const row of created) {
@@ -51109,11 +51836,11 @@ function encodeLookupInitializerResult(member, value, created, ctx) {
   }
   return { value: selection2, classId: null };
 }
-function encodeLookupInitializerSelection(member, value, created, ctx, target = lookupTargetTypeInfo(member, null, ctx)) {
+function encodeLookupInitializerSelection(member, value, createdIds, ctx, target = lookupTargetTypeInfo(member, null, ctx)) {
   if (value === null) return null;
   if (value === void 0) return null;
   if (isMultiSelectionMember(member) !== true && isCollectionTypeInfo(target))
-    return [lookupInitializerSelectionId(member, value, created, ctx)];
+    return [lookupInitializerSelectionId(member, value, createdIds, ctx)];
   if (value instanceof RuntimeSet) value = value.toArray();
   if (Array.isArray(value)) {
     if (isMultiSelectionMember(member) !== true && value.length > 1) {
@@ -51122,7 +51849,7 @@ function encodeLookupInitializerSelection(member, value, created, ctx, target =
       );
     }
     return value.map(
-      (entry) => lookupInitializerSelectionId(member, entry, created, ctx)
+      (entry) => lookupInitializerSelectionId(member, entry, createdIds, ctx)
     );
   }
   if (isMultiSelectionMember(member) === true) {
@@ -51130,9 +51857,9 @@ function encodeLookupInitializerSelection(member, value, created, ctx, target =
       `Lookup member '${member.name}' is multiselect, but its initializer produced a single value instead of a selection set.`
     );
   }
-  return [lookupInitializerSelectionId(member, value, created, ctx)];
+  return [lookupInitializerSelectionId(member, value, createdIds, ctx)];
 }
-function lookupInitializerSelectionId(member, entry, created, ctx) {
+function lookupInitializerSelectionId(member, entry, createdIds, ctx) {
   if (typeof entry === "string") return entry;
   if (entry instanceof NSSlotReference) return entry.targetId;
   if (typeof entry !== "object" || entry === null) {
@@ -51144,7 +51871,7 @@ function lookupInitializerSelectionId(member, entry, created, ctx) {
   if (typeof cloneSourceRowId === "string") return cloneSourceRowId;
   const row = trackedRowForValueReference(entry, ctx);
   if (row !== null) {
-    if (created.some((candidate) => candidate.id === row.id)) {
+    if (createdIds.has(row.id)) {
       throw new NSGetterRuntimeError(
         `Lookup member '${member.name}' initializer constructed a new value; a lookup selection must reference an existing collection entry.`
       );
@@ -51323,7 +52050,11 @@ function encodeRequiredConstructorArgument(args) {
     }
     const row2 = registerCollectionRow([]);
     row2.value = args.value.map(
-      (entry, index) => encodeEntry(entry, collectionType.entryTypeInfo, `index:${index}`)
+      (entry, index) => encodeEntry(
+        resolveCollectionEntry(args.value, entry, index, args.ctx),
+        collectionType.entryTypeInfo,
+        `index:${index}`
+      )
     );
     return row2.id;
   }
@@ -51336,7 +52067,11 @@ function encodeRequiredConstructorArgument(args) {
   row.value = Object.fromEntries(
     Object.entries(args.value).map(([key, entry]) => [
       key,
-      encodeEntry(entry, collectionType.entryTypeInfo, `key:${key}`)
+      encodeEntry(
+        resolveCollectionEntry(args.value, entry, key, args.ctx),
+        collectionType.entryTypeInfo,
+        `key:${key}`
+      )
     ])
   );
   return row.id;
@@ -52152,6 +52887,7 @@ function constructDeclaredClassValue(info, scope, ctx) {
   const descriptor = validateClassConstructorDescriptor(info, ctx, false);
   const schemaClass2 = descriptor.schemaClass;
   const record7 = resolveDeclaredConstructorRecord(info, schemaClass2, ctx);
+  const replayCheckpoint = ctx.storedConstructionReplay === true && ctx.__storedConstructionReplayRowId !== void 0 && ctx.__storedConstructionReplaySlot?.classId === schemaClass2.id && ctx.__executionState?.constructionStack.length === 0 ? sessionCreationCheckpoint(ctx) : void 0;
   const closeFrame = pushConstructionFrame(ctx, schemaClass2.name);
   try {
     return constructDeclaredClassValueWithinFrame(
@@ -52161,6 +52897,13 @@ function constructDeclaredClassValue(info, scope, ctx) {
       scope,
       ctx
     );
+  } catch (error) {
+    if (replayCheckpoint !== void 0) {
+      for (const row of createdSessionValuesSince(ctx, replayCheckpoint)) {
+        deleteRuntimeSessionValue(ctx, row.id);
+      }
+    }
+    throw error;
   } finally {
     closeFrame();
   }
@@ -52232,6 +52975,9 @@ function constructDeclaredClassValueWithinFrame(descriptor, record7, info, scope
       `Declared constructor for '${schemaClass2.name}' produced a non-record root.`
     );
   }
+  if (ctx.storedConstructionReplay === true && ctx.__storedConstructionReplayRowId !== void 0 && ctx.__storedConstructionReplaySlot?.classId === classId && ctx.__executionState?.constructionStack.length === 1) {
+    ctx = { ...ctx, __storedConstructionReplayRootId: root.id };
+  }
   const rootRecord = root.value;
   recordConstructedFieldSchemaKeys(ctx, rootRecord, descriptor);
   if (record7 !== null) {
@@ -52369,7 +53115,14 @@ function constructDeclaredClassValueWithinFrame(descriptor, record7, info, scope
   });
   return root.value;
 }
-function assertOwnedValueAttachable(valueId, destination, destinationName2, ctx, reserveUntilPublished = false, mode = "assign") {
+function ownedAttachmentIdentity(attachment, ctx) {
+  const rootId = ctx.__storedConstructionReplayRootId;
+  const rowId = ctx.__storedConstructionReplayRowId;
+  if (rootId === void 0 || rowId === void 0) return attachment.identity;
+  const prefix = `value:${rootId}:slot:`;
+  return attachment.identity.startsWith(prefix) ? `value:${rowId}:slot:${attachment.identity.slice(prefix.length)}` : attachment.identity;
+}
+function assertOwnedValueAttachable(valueId, destination, destinationName2, ctx, reserveUntilPublished = false, mode = "assign", preflight) {
   const row = evalValueById(
     ctx,
     valueId,
@@ -52381,8 +53134,13 @@ function assertOwnedValueAttachable(valueId, destination, destinationName2, ctx,
       `Aggregate assignment to '${destinationName2}' references missing value '${valueId}'.`
     );
   }
-  for (const owner of currentOwnedValueAttachments(valueId, ctx)) {
-    if (mode === "assign" && owner.identity === destination.identity) continue;
+  for (const owner of currentOwnedValueAttachments(
+    valueId,
+    ctx,
+    preflight?.parentEntries
+  )) {
+    if (mode === "assign" && ownedAttachmentIdentity(owner, ctx) === ownedAttachmentIdentity(destination, ctx))
+      continue;
     const error = new NSGetterRuntimeError(
       `Aggregate value '${valueId}' is already owned by parent value '${owner.label}' and cannot be attached to '${destinationName2}'. Call Clone() explicitly.`
     );
@@ -52398,9 +53156,14 @@ function assertOwnedValueAttachable(valueId, destination, destinationName2, ctx,
       destination.label,
       ctx
     );
-    if (constructorArgumentReservation && (destination.label === reserved.label || destinationConstructorGroup === reserved.label)) {
-      ctx.__executionState?.ownedValueAttachments.set(valueId, destination);
-      recordConstructorGroupDependency(valueId, destination, ctx);
+    if (constructorArgumentReservation && (destination.label === reserved.label || destinationConstructorGroup === reserved.label || preflight?.constructorRootIds.has(reserved.label) === true)) {
+      if (preflight === void 0) {
+        ctx.__executionState?.ownedValueAttachments.set(valueId, destination);
+        recordConstructorGroupDependency(valueId, destination, ctx);
+      } else {
+        preflight.constructorArgumentTransfers.set(valueId, destination);
+        preflight.dependencies.set(valueId, destination);
+      }
       return;
     }
     throw new NSGetterRuntimeError(
@@ -52410,7 +53173,9 @@ function assertOwnedValueAttachable(valueId, destination, destinationName2, ctx,
   if (reserveUntilPublished) {
     ctx.__executionState?.ownedValueAttachments.set(valueId, destination);
   }
-  recordConstructorGroupDependency(valueId, destination, ctx);
+  if (preflight === void 0)
+    recordConstructorGroupDependency(valueId, destination, ctx);
+  else preflight.dependencies.set(valueId, destination);
 }
 function assertInitializerPlacement(valueId, member, ctx) {
   const replayRowId = ctx.__storedConstructionReplayRowId;
@@ -52430,7 +53195,25 @@ function directlyBoundMembersOf(valueId, ctx) {
     return NO_BOUND_MEMBERS;
   return ctx.vm.members.filter((member) => member.valueId === valueId);
 }
-function currentOwnedValueAttachments(valueId, ctx) {
+function ownershipParentEntryKeys(value, valueId, cache) {
+  if (cache === void 0) return void 0;
+  let entries = cache.get(value);
+  if (entries === void 0) {
+    const indexed = /* @__PURE__ */ new Map();
+    const add = (child2, key) => {
+      if (typeof child2 !== "string") return;
+      const keys = indexed.get(child2);
+      if (keys === void 0) indexed.set(child2, [key]);
+      else keys.push(key);
+    };
+    if (Array.isArray(value)) value.forEach(add);
+    else for (const [key, child2] of Object.entries(value)) add(child2, key);
+    entries = indexed;
+    cache.set(value, entries);
+  }
+  return entries.get(valueId) ?? [];
+}
+function currentOwnedValueAttachments(valueId, ctx, parentEntries, placingMembers) {
   const indexes4 = evaluatorIndexes(ctx);
   const cached = indexes4.ownedValueAttachmentsByValueId.get(valueId);
   if (cached !== void 0) return [...cached];
@@ -52493,7 +53276,14 @@ function currentOwnedValueAttachments(valueId, ctx) {
     let member = null;
     let classId = parent.classId;
     if (classId === void 0 || classId === null) {
-      member = activeStaticBindingRoot(parent.id, ctx)?.member ?? memberForValueRow(parent, ctx);
+      member = activeStaticBindingRoot(parent.id, ctx)?.member ?? (placingMembers === void 0 ? memberForValueRow(parent, ctx) : placingMember(
+        parent,
+        ctx,
+        void 0,
+        0,
+        placingMembers,
+        parentEntries
+      ));
       if (member !== null) {
         try {
           member = resolveMember(member, ctx.vm.members);
@@ -52510,7 +53300,14 @@ function currentOwnedValueAttachments(valueId, ctx) {
       classId = member !== null && isClassTypedMember(member) ? member.classId : void 0;
     }
     if (classId !== void 0 && typeof parent.value === "object" && parent.value !== null && !Array.isArray(parent.value)) {
-      for (const [key, childId] of Object.entries(parent.value)) {
+      const keys = ownershipParentEntryKeys(
+        parent.value,
+        valueId,
+        parentEntries
+      );
+      for (const rawKey of keys ?? Object.keys(parent.value)) {
+        const key = String(rawKey);
+        const childId = Reflect.get(parent.value, key);
         if (childId !== valueId) continue;
         add({
           identity: `value:${parent.id}:slot:${key}`,
@@ -52520,8 +53317,17 @@ function currentOwnedValueAttachments(valueId, ctx) {
       continue;
     }
     if (member !== null && isMemberEntryCollectionBase(member) && Array.isArray(parent.value)) {
-      for (const [index, childId] of parent.value.entries()) {
-        if (childId !== valueId) continue;
+      const references = collectionReferences(parent.value, ctx);
+      const keys = ownershipParentEntryKeys(
+        parent.value,
+        valueId,
+        parentEntries
+      );
+      for (const rawKey of keys ?? parent.value.keys()) {
+        const index = Number(rawKey);
+        const childId = parent.value[index];
+        if (childId !== valueId || !isReferenceEntry(references, index))
+          continue;
         add({
           identity: `value:${parent.id}:index:${index}`,
           label: parent.id
@@ -52530,8 +53336,16 @@ function currentOwnedValueAttachments(valueId, ctx) {
       continue;
     }
     if (member !== null && isMemberDictionaryBase(member) && typeof parent.value === "object" && parent.value !== null && !Array.isArray(parent.value)) {
-      for (const [key, childId] of Object.entries(parent.value)) {
-        if (childId !== valueId) continue;
+      const references = collectionReferences(parent.value, ctx);
+      const keys = ownershipParentEntryKeys(
+        parent.value,
+        valueId,
+        parentEntries
+      );
+      for (const rawKey of keys ?? Object.keys(parent.value)) {
+        const key = String(rawKey);
+        const childId = Reflect.get(parent.value, key);
+        if (childId !== valueId || !isReferenceEntry(references, key)) continue;
         add({
           identity: `value:${parent.id}:slot:${key}`,
           label: parent.id
@@ -52858,8 +53672,12 @@ function materializeConstructorArgumentValue(args) {
       args.destinationName ?? args.member.name,
       args.ctx
     );
+  const collectionAlias = args.value;
   if (args.value instanceof RuntimeSet)
-    args = { ...args, value: args.value.toArray() };
+    args = {
+      ...args,
+      value: args.collectionAliases === void 0 ? args.value.toArray() : exportRuntimeSetValue(args.value, args.ctx)
+    };
   const trackedValueId = findKnownRowIdByValueReference(args.value, args.ctx);
   if (args.value === null && !isRequiredMember(args.member) && isMemberWithEntries(args.member)) {
     return registerConstructorArgumentRow(args, null);
@@ -52895,15 +53713,18 @@ function materializeConstructorArgumentValue(args) {
     return row;
   }
   if (isMemberLookupBase(args.member)) {
-    return registerConstructorArgumentRow(
+    const row = registerConstructorArgumentRow(
       args,
       encodeLookupInitializerSelection(
         args.member,
         args.value,
-        args.createdValues,
+        args.createdById,
         args.ctx
       )
     );
+    if (collectionAlias instanceof RuntimeSet)
+      args.collectionAliases?.set(row, collectionAlias);
+    return row;
   }
   if (isClassSlotMember(args.member)) {
     if (args.value === null || args.value === void 0) {
@@ -52946,6 +53767,14 @@ function materializeConstructorArgumentValue(args) {
             `Constructor Class field '${args.member.name}' has no owned destination.`
           );
         }
+        if (args.attachmentReservations !== void 0 && !args.attachmentReservations.has(trackedValueId)) {
+          args.attachmentReservations.set(
+            trackedValueId,
+            args.ctx.__executionState?.ownedValueAttachments.get(
+              trackedValueId
+            )
+          );
+        }
         assertOwnedValueAttachable(
           trackedValueId,
           args.owner,
@@ -53030,6 +53859,7 @@ function materializeConstructorArgumentValue(args) {
       }
     }
     row.value = ids;
+    args.collectionAliases?.set(row, collectionAlias);
     return row;
   }
   if (isMemberDictionaryBase(args.member)) {
@@ -53084,6 +53914,7 @@ function materializeConstructorArgumentValue(args) {
       }).id;
     }
     row.value = record7;
+    args.collectionAliases?.set(row, collectionAlias);
     return row;
   }
   return registerConstructorArgumentRow(args, args.value);
@@ -55146,7 +55977,11 @@ function materializeMemberDefaultValue(args) {
       valueById: (id2) => {
         args.readTracking?.valueIds.add(id2);
         const database2 = evaluatorLookups();
-        return database2.defaultValueById !== void 0 ? database2.defaultValueById(id2) : database2.valueById(id2);
+        return database2.valueById(id2);
+      },
+      defaultValueSource: (id2, member) => {
+        args.readTracking?.valueIds.add(id2);
+        return evaluatorLookups().defaultValueSource?.(id2, member) ?? null;
       },
       unorderedListEntryIds: (containerId) => {
         args.readTracking?.containerIds.add(containerId);
@@ -55246,9 +56081,14 @@ var init_initializer_materialization = __esm({
 
 // ../packages/neoscript-runtime/src/declaration-default-source.ts
 function declarationDefaultSource(id2, stored, resolveGraph) {
-  if (stored !== null && !isCollapseStampedInstanceRoot(stored)) return stored;
+  if (stored !== null && !isCollapseStampedInstanceRoot(stored))
+    return { value: stored };
   const graph = resolveGraph(id2);
-  return defaultSourceWithListeners(graph?.rowsById.get(id2) ?? stored, graph);
+  const value = defaultSourceWithListeners(
+    graph?.rowsById.get(id2) ?? stored,
+    graph
+  );
+  return value === null ? null : { value, rowsById: graph?.rowsById };
 }
 var init_declaration_default_source = __esm({
   "../packages/neoscript-runtime/src/declaration-default-source.ts"() {
@@ -56302,6 +57142,7 @@ function rowGenericEnvironment(document, row, contextualRootMember) {
   for (const [paramId, binding] of envFromStamp(row.genericBindings)) {
     env.set(paramId, binding);
   }
+  closeForwardedGenericParams(env);
   return env;
 }
 function tryResolveTypeInfo(document, rawTypeInfo, env) {
@@ -61413,6 +62254,21 @@ function createHeadlessVirtualInstanceResolver(args) {
     return inherited === void 0 ? authored : { ...inherited, ...authored };
   };
   return {
+    declarationDefaultGraph: (rootId, member) => {
+      recorder.recordValueRead(rootId);
+      const root = rawById.get(rootId);
+      if (root === void 0) return null;
+      return resolveStoredClassValue({
+        evaluateInitializer: args.evaluateInitializer,
+        materializeInitializerValue: args.materializeInitializerValue,
+        materializeMemberDefaultValue: args.materializeMemberDefaultValue,
+        document: resolverDocumentOnce(),
+        instanceRoot: root,
+        rootMember: member,
+        materializedIndex: materializedIndexOnce(),
+        readRecorder: recorder
+      });
+    },
     storedClassGraph: (rootId, member) => {
       expandRoot(rootId, member);
       const graph = graphByValueId.get(rootId);
@@ -61723,7 +62579,7 @@ function initializerEvaluatorLookups(document, readTracking) {
       },
       memberById: (id2) => databaseVM.memberById(id2),
       valueById: (id2) => databaseVM.valueById(id2),
-      defaultValueById: (id2) => databaseVM.defaultValueById?.(id2) ?? databaseVM.valueById(id2),
+      defaultValueSource: databaseVM.defaultValueSource?.bind(databaseVM),
       onInitializerRead: databaseVM.onInitializerRead,
       localizedTextById: (id2) => databaseVM.localizedTextById?.(id2) ?? null,
       ...databaseVM.hasStoredValueId === void 0 ? {} : {
@@ -61794,10 +62650,10 @@ function initializerEvaluatorLookups(document, readTracking) {
   const lookups = {
     ...indexedLookups,
     changeListenerDefaultsForOwner: headlessVirtualResolver.changeListenerDefaultsForOwner,
-    defaultValueById: (id2) => declarationDefaultSource(
+    defaultValueSource: (id2, member) => declarationDefaultSource(
       id2,
       indexedLookups.valueById(id2),
-      headlessVirtualResolver.virtualInstanceGraphForValue
+      (id3) => headlessVirtualResolver.declarationDefaultGraph(id3, member)
     ),
     valueById: (id2) => indexedLookups.valueById(id2) ?? headlessVirtualResolver.valueById(id2),
     rowForValueReference: (value) => indexedLookups.rowForValueReference?.(value) ?? headlessVirtualResolver.rowForValueReference(value),
@@ -61852,7 +62708,8 @@ function defaultValuePlans(document) {
     projectFiles: document.projectFiles,
     textureTemplates: document.textureTemplates,
     memberById: lookups.memberById,
-    valueById: lookups.defaultValueById ?? lookups.valueById,
+    valueById: lookups.valueById,
+    defaultValueSource: lookups.defaultValueSource,
     // A host database without list membership falls back to `values`.
     unorderedListEntryIds: document.databaseVM?.unorderedListEntryIds === void 0 && document.databaseVM !== void 0 ? void 0 : lookups.unorderedListEntryIds
   });
@@ -62043,10 +62900,10 @@ function createInitializerMaterializationBatch(authoredDocument, pendingInitiali
           const authored = base.changeListenerDefaultsForOwner?.(id2);
           return inherited === void 0 ? authored : { ...inherited, ...authored };
         },
-        defaultValueById: (id2) => declarationDefaultSource(
+        defaultValueSource: (id2, member) => declarationDefaultSource(
           id2,
           base.valueById(id2),
-          (valueId) => virtual().virtualInstanceGraphForValue(valueId)
+          (id3) => virtual().declarationDefaultGraph(id3, member)
         ),
         valueById: (id2) => base.valueById(id2) ?? expandedById.get(id2) ?? virtual().valueById(id2),
         rowForValueReference: (value) => base.rowForValueReference(value) ?? expandedByReference.get(value) ?? virtual().rowForValueReference(value),
@@ -65867,7 +66724,7 @@ function variable(id2, type2, pointer, project) {
   };
 }
 function isGeneratedPositionalCall(target, expression) {
-  return neoScriptRequiredConstructor(target) === null && target.constructorSignature !== void 0 && expression.argumentNames === void 0 && callHasPositionalArguments(expression);
+  return (target.declaredConstructors?.length ?? 0) === 0 && target.constructorSignature !== void 0 && expression.argumentNames === void 0 && callHasPositionalArguments(expression);
 }
 function closedConstructorParameters(parameters, targetType, schemaClass2, project) {
   return parameters.map((parameter4) => {
@@ -65911,7 +66768,7 @@ function bindConstructorArgumentNames(className, declared, argumentNames, pos) {
   if (positionalIndex < 0) {
     return argumentNames.filter((name) => name !== null);
   }
-  const sole = declared.find((candidate) => candidate.required === true);
+  const sole = declared.length === 1 ? declared[0] : void 0;
   if (sole === void 0) {
     throw new CompileError(
       `Class '${className}' declares constructors, so argument ${positionalIndex + 1} must be passed by name \u2014 candidates: ${describeNeoScriptDeclaredConstructors(className, declared)}.`,
@@ -67479,7 +68336,7 @@ function switchValueKey(value) {
   const enumId = value.typeInfo.type === 8 /* Enum */ ? value.typeInfo.enumId : null;
   return JSON.stringify([value.typeInfo.type, enumId, value.value]);
 }
-function resolveNeoScriptType(type2, context, project) {
+function resolveNeoScriptType(type2, context, project, referenceMode = "read") {
   let resolved;
   switch (type2.kind) {
     case "primitive":
@@ -67532,7 +68389,7 @@ function resolveNeoScriptType(type2, context, project) {
           );
         const ineligible = neoScriptReferenceTargetError(targetType, project);
         if (ineligible !== null) throw new CompileError(ineligible, type2.pos);
-        resolved = neoScriptReferenceType(
+        resolved = referenceMode === "stored" ? { kind: "reference", target: targetType } : neoScriptReferenceType(
           targetType,
           false,
           (named2) => isNeoScriptValueNamedType(named2, project)
@@ -67572,7 +68429,7 @@ function resolveNeoScriptType(type2, context, project) {
         typeId: named.id,
         ...type2.typeArguments ? {
           typeArguments: type2.typeArguments.map(
-            (argument2) => resolveNeoScriptType(argument2, context, project)
+            (argument2) => resolveNeoScriptType(argument2, context, project, "stored")
           )
         } : {}
       };
@@ -67584,7 +68441,12 @@ function resolveNeoScriptType(type2, context, project) {
         kind: "tuple",
         nullable: !type2.required,
         elements: type2.elements.map((element) => ({
-          type: resolveNeoScriptType(element.type, context, project),
+          type: resolveNeoScriptType(
+            element.type,
+            context,
+            project,
+            referenceMode
+          ),
           ...element.name ? { name: element.name } : {},
           ...element.nameRange && context.sourceUri ? {
             labelLocation: {
@@ -67597,11 +68459,21 @@ function resolveNeoScriptType(type2, context, project) {
     case "list":
       resolved = {
         kind: "list",
-        elementType: resolveNeoScriptType(type2.element, context, project)
+        elementType: resolveNeoScriptType(
+          type2.element,
+          context,
+          project,
+          referenceMode
+        )
       };
       break;
     case "set": {
-      const element = resolveNeoScriptType(type2.element, context, project);
+      const element = resolveNeoScriptType(
+        type2.element,
+        context,
+        project,
+        referenceMode
+      );
       resolved = {
         kind: "set",
         // P105 §2.2. Multiselect dialogue elements are bare dialogue ids.
@@ -67620,7 +68492,12 @@ function resolveNeoScriptType(type2, context, project) {
       resolved = {
         kind: "dictionary",
         keyType: key,
-        valueType: resolveNeoScriptType(type2.value, context, project)
+        valueType: resolveNeoScriptType(
+          type2.value,
+          context,
+          project,
+          referenceMode
+        )
       };
       break;
     }
@@ -67628,12 +68505,7 @@ function resolveNeoScriptType(type2, context, project) {
   return { ...resolved, nullable: !type2.required };
 }
 function resolveStoredReferenceTarget(type2, context, project) {
-  const inner = type2.kind === "named" && type2.name === "Reference" && type2.typeArguments?.length === 1 ? type2.typeArguments[0] : void 0;
-  if (inner === void 0) return resolveNeoScriptType(type2, context, project);
-  const target = resolveStoredReferenceTarget(inner, context, project);
-  const ineligible = neoScriptReferenceTargetError(target, project);
-  if (ineligible !== null) throw new CompileError(ineligible, type2.pos);
-  return { kind: "reference", target, nullable: !type2.required };
+  return resolveNeoScriptType(type2, context, project, "stored");
 }
 function resultKind(kinds) {
   if (kinds.includes("targetTyped")) return "targetTyped";
@@ -67648,6 +68520,9 @@ function compilesAlike(kind, target) {
     );
   return !isPrimitive(target, "decimal");
 }
+function hasTupleLambda(expression) {
+  return expression.kind === "lambda" || expression.kind === "tuple" && expression.elements.some((element) => hasTupleLambda(element.value));
+}
 function sameInputs(type2, inputs) {
   return type2.kind === "delegate" && type2.parameterTypes.length === inputs.length && type2.parameterTypes.every(
     (input, index) => sameCompilationType(input, inputs[index])
@@ -68389,6 +69264,8 @@ var init_strict_resolver = __esm({
        * compiling. Only one compile of each lambda argument reaches the program.
        */
       lambdaFrame;
+      /** The current call's inferred callbacks, including tuple elements. */
+      argumentLambdas;
       /** P118. Calls compiled in a lambda frame, with what their names bound to. */
       frameCalls = /* @__PURE__ */ new Map();
       frameCallsGroup;
@@ -70602,7 +71479,7 @@ var init_strict_resolver = __esm({
           );
         }
         const bindings = [];
-        const capturedTarget = statement.op !== "=" && (vectorTypeName(target.type) !== null || isBitwiseBinaryOperator(statement.op.slice(0, -1))) ? {
+        const capturedTarget = statement.op !== "=" && (target.structuredLeafKind !== void 0 || vectorTypeName(target.type) !== null || isBitwiseBinaryOperator(statement.op.slice(0, -1))) ? {
           ...target,
           pointer: this.captureAssignmentTarget(target.pointer, bindings)
         } : target;
@@ -70684,6 +71561,7 @@ var init_strict_resolver = __esm({
           ...bindings.length > 0 ? { bindings } : {},
           target: {
             pointer: capturedTarget.pointer,
+            ...target.structuredLeafKind === void 0 ? {} : { structuredLeafKind: target.structuredLeafKind },
             typeInfo: target.wireType ?? toWireType(target.type, this.project),
             writability
           },
@@ -71750,8 +72628,7 @@ var init_strict_resolver = __esm({
       frameCallNames(expression, scope) {
         if (this.lambdaFrame === void 0) return void 0;
         if (expression.kind !== "call") return void 0;
-        if (!expression.args.some((argument2) => argument2.kind === "lambda"))
-          return void 0;
+        if (!expression.args.some(hasTupleLambda)) return void 0;
         if (this.overloadArgumentKind(expression, scope) !== "typed")
           return void 0;
         let names2 = this.callNames.get(expression);
@@ -71814,7 +72691,11 @@ var init_strict_resolver = __esm({
       resolveExpressionCore(expression, scope, expected, convertSequence = true) {
         if (expected?.kind === "delegate") {
           if (expression.kind === "lambda") {
-            return this.resolveDelegateLambda(expression, expected, scope);
+            const lambdas = this.argumentLambdas;
+            const cached = weighedLambda(lambdas?.get(expression), expected);
+            if (cached !== void 0) return cached;
+            const compile = () => this.resolveDelegateLambda(expression, expected, scope);
+            return lambdas?.has(expression) ? this.inLambdaFrame(lambdas, expression, compile) : compile();
           }
           const methodGroup = this.resolveDelegateMethodGroup(
             expression,
@@ -74583,6 +75464,7 @@ var init_strict_resolver = __esm({
         }
         const primitiveMember = resolvePrimitiveMember(receiver.type, name);
         if (primitiveMember) {
+          const structuredLeafKind = receiver.type.kind === "primitive" && isNeoScriptVectorKind(receiver.type.name) ? receiver.type.name : void 0;
           if (isPrimitive(receiver.type, "NeoDialogueReference")) {
             return {
               pointer: {
@@ -74604,7 +75486,8 @@ var init_strict_resolver = __esm({
             primitiveMember.type,
             nullPropagating
           );
-          if (!primitiveMember.derived) return resolved;
+          if (!primitiveMember.derived)
+            return structuredLeafKind === void 0 ? resolved : { ...resolved, structuredLeafKind };
           return {
             ...resolved,
             derivedMember: { owner: this.describe(receiver.type), name }
@@ -77717,10 +78600,13 @@ var init_strict_resolver = __esm({
           else if (cached && (sameCompilationType(cached.type, expected) || cached.pointer.type === "callFunction" /* CallFunction */)) {
             resolved = cached;
           } else {
-            const lambdas = choice?.lambdas;
-            const weighed = argument2.kind === "lambda" && expected.kind === "delegate" ? weighedLambda(lambdas?.get(argument2), expected) : void 0;
-            const compile = () => this.resolveExpression(argument2, scope, target);
-            resolved = weighed ?? (argument2.kind === "lambda" && lambdas ? this.inLambdaFrame(lambdas, argument2, compile) : compile());
+            const previous = this.argumentLambdas;
+            this.argumentLambdas = choice?.lambdas ?? inferred?.lambdas;
+            try {
+              resolved = this.resolveExpression(argument2, scope, target);
+            } finally {
+              this.argumentLambdas = previous;
+            }
           }
           resolved = this.contextualReference(argument2, resolved, scope, target);
           resolved = this.convertSequence(resolved, target);
@@ -77781,9 +78667,7 @@ var init_strict_resolver = __esm({
         const callbacks = [];
         const probe = new Scope(scope);
         const resolvedArguments = /* @__PURE__ */ new Map();
-        argumentsList2.forEach((argument2, index) => {
-          const pattern = parameters[index];
-          if (pattern === void 0) return;
+        const inferArgument = (argument2, pattern, prior) => {
           if (inference.unresolved(pattern).size === 0) return;
           if (argument2.kind === "lambda" && pattern.kind === "delegate") {
             argument2.params.forEach((parameter4, parameterIndex) => {
@@ -77794,8 +78678,14 @@ var init_strict_resolver = __esm({
             callbacks.push({ ast: argument2, type: pattern });
             return;
           }
+          if (argument2.kind === "tuple" && pattern.kind === "tuple") {
+            if (argument2.elements.length !== pattern.elements.length) return;
+            argument2.elements.forEach((element, index) => {
+              inferArgument(element.value, pattern.elements[index].type);
+            });
+            return;
+          }
           if (!hasIndependentTypeEvidence(argument2)) return;
-          const prior = weighed?.typed[index];
           if (prior !== void 0) {
             inference.add(
               this.referenceInferenceType(argument2, prior, pattern),
@@ -77819,9 +78709,17 @@ var init_strict_resolver = __esm({
               pattern
             );
           }
+        };
+        argumentsList2.forEach((argument2, index) => {
+          const pattern = parameters[index];
+          if (pattern === void 0) return;
+          if (weighed === void 0 && argument2.kind === "tuple" && pattern.kind === "tuple")
+            this.typeOverloadEntries(argument2, probe);
+          inferArgument(argument2, pattern, weighed?.typed[index]);
         });
+        const lambdas = weighed?.lambdas ?? /* @__PURE__ */ new Map();
         const error = inference.solve(callbacks, (callback, inputs) => {
-          const probes = weighed?.lambdas.get(callback.ast) ?? [];
+          const probes = lambdas.get(callback.ast) ?? [];
           let resolved = probes.find(
             (candidate) => sameInputs(candidate.type, inputs)
           );
@@ -77836,8 +78734,8 @@ var init_strict_resolver = __esm({
               probe,
               true
             );
-            resolved = weighed ? this.inLambdaFrame(weighed.lambdas, callback.ast, compile) : compile();
-            weighed?.lambdas.set(callback.ast, [...probes, resolved]);
+            resolved = this.inLambdaFrame(lambdas, callback.ast, compile);
+            lambdas.set(callback.ast, [...probes, resolved]);
           }
           if (!resolved.needsReturnContext)
             resolvedArguments.set(callback.ast, resolved);
@@ -77855,7 +78753,8 @@ var init_strict_resolver = __esm({
         }
         return {
           typeArguments: inference.arguments(),
-          resolved: resolvedArguments
+          resolved: resolvedArguments,
+          lambdas
         };
       }
       callableSignatureForReceiver(symbol, receiver, typeArguments, pos, inferred) {
@@ -94271,7 +95170,7 @@ function explainNeoVariantPath(index, segments, isDeclaredClass) {
   const className = segments[0];
   if (className === void 0) return null;
   if (segments[1] !== NEO_VARIANT_SCOPE_NAME) return null;
-  if (!isDeclaredClass(className)) return null;
+  if (!isDeclaredClass(className)) return { kind: "unknownClass", className };
   if (segments.length === 3 && segments[2] === NEO_VARIANT_RESERVED_NAME) {
     return null;
   }
@@ -95692,6 +96591,7 @@ function semanticDeclarationContract(document) {
         ...declaration,
         members: declaration.members.map((member) => {
           if (member.kind === "field") {
+            if (member.type.name === NEO_VARIANT_TYPE_NAME) return member;
             const initializer = member.initializer;
             return initializer === void 0 ? member : {
               ...member,
@@ -95879,6 +96779,7 @@ function createEnvironment(documents, project) {
   const types = /* @__PURE__ */ new Map();
   const globals = /* @__PURE__ */ new Map();
   const referenceTargets = /* @__PURE__ */ new Map();
+  const variantFields = /* @__PURE__ */ new Map();
   for (const [name, options] of Object.entries(
     NEO_PROJECT_SOURCE_RECORD_CONTRACT.enums
   )) {
@@ -95914,6 +96815,14 @@ function createEnvironment(documents, project) {
           });
         }
         for (const member of declaration.members) {
+          if (member.kind === "field" && member.type.name === NEO_VARIANT_TYPE_NAME) {
+            let fields = variantFields.get(declaration.name);
+            if (fields === void 0) {
+              fields = /* @__PURE__ */ new Map();
+              variantFields.set(declaration.name, fields);
+            }
+            fields.set(member.name, member);
+          }
           if ((member.kind === "field" || member.kind === "property") && member.modifiers.includes("static")) {
             referenceTargets.set(`${declaration.name}.${member.name}`, {
               kind: "value",
@@ -95924,10 +96833,20 @@ function createEnvironment(documents, project) {
       }
     }
   }
+  const projectIndex = createProjectIndex(project);
+  const imageRegistryEntries = /* @__PURE__ */ new Set();
+  for (const member of projectIndex.typeByName.get(
+    NEOSCRIPT_IMAGE_REGISTRY_TYPE
+  )?.members ?? []) {
+    imageRegistryEntries.add(member.name);
+  }
   return {
     documents,
     project,
-    projectIndex: createProjectIndex(project),
+    projectIndex,
+    imageRegistryEntries,
+    variantFields,
+    variantDefaults: /* @__PURE__ */ new Map(),
     initializerResolvers: /* @__PURE__ */ new Map(),
     staticMember: false,
     assignability: /* @__PURE__ */ new Map(),
@@ -96256,6 +97175,38 @@ function slotPosition(start, pos) {
   }
   return { line: start.line + pos.line - 1, character: pos.column - 1 };
 }
+function variantSourceDefault(ownerName, memberName, environment) {
+  const path = /* @__PURE__ */ new Set();
+  let current = environment.types.get(ownerName);
+  let result = null;
+  while (current !== void 0 && !path.has(current.name)) {
+    const cached = environment.variantDefaults.get(current.name);
+    if (cached?.has(memberName)) {
+      result = cached.get(memberName) ?? null;
+      break;
+    }
+    path.add(current.name);
+    const field = environment.variantFields.get(current.name)?.get(memberName);
+    const declaration = environment.construction.classes.get(current.name);
+    if (field?.initializer !== void 0 && declaration !== void 0) {
+      result = { uri: declaration.uri, ownerName: current.name, field };
+      break;
+    }
+    const base = current.baseTypes.find(
+      (type2) => environment.types.has(type2.name)
+    );
+    current = base === void 0 ? void 0 : environment.types.get(base.name);
+  }
+  for (const name of path) {
+    let cached = environment.variantDefaults.get(name);
+    if (cached === void 0) {
+      cached = /* @__PURE__ */ new Map();
+      environment.variantDefaults.set(name, cached);
+    }
+    cached.set(memberName, result);
+  }
+  return result;
+}
 function validateMember(uri, member, ownerName, documentKind, ownerScope, environment, diagnostics) {
   const memberType2 = semanticType(member.type);
   validateAnnotations(
@@ -96307,6 +97258,40 @@ function validateMember(uri, member, ownerName, documentKind, ownerScope, enviro
     }
     return;
   }
+  if (member.initializer === void 0 && member.modifiers.includes("override") && member.type.name === NEO_VARIANT_TYPE_NAME) {
+    const inherited = variantSourceDefault(ownerName, member.name, environment);
+    const initializer = inherited?.field.initializer;
+    if (inherited !== null && initializer !== void 0) {
+      const inheritedDiagnostics = [];
+      validateExpressionText(
+        inherited.uri,
+        initializer.text,
+        { ...memberType2, nullable: true },
+        scope,
+        environment,
+        initializer.range,
+        inheritedDiagnostics,
+        anchorOf(initializer)
+      );
+      for (const diagnostic of inheritedDiagnostics) {
+        if (diagnostic.code !== "variant-default-covariance") continue;
+        pushDiagnostic(
+          diagnostics,
+          uri,
+          member.nameRange,
+          "variant-inherited-default-covariance",
+          `Inherited default from '${inherited.ownerName}.${member.name}' is incompatible with this override. ${diagnostic.message} Declare a compatible default on the override.`,
+          "error",
+          [
+            {
+              location: { uri: inherited.uri, range: initializer.range },
+              message: `Inherited default '${initializer.text}'.`
+            }
+          ]
+        );
+      }
+    }
+  }
   if (member.initializer && !member.flowInitializer) {
     validateExpressionText(
       uri,
@@ -97292,12 +98277,25 @@ function validateExpression(expression, expected, scope, environment, uri, range
       environment,
       uri,
       range2,
-      diagnostics
+      diagnostics,
+      anchor
     );
     return;
   }
   if (expected && expression.kind !== "contextualEnum" && expression.kind !== "annotated" && !isReferenceCall(expression)) {
     const actual = inferExpressionType(expression, scope, environment);
+    if (expected.name === "SpriteInfo" && (actual?.name === "NeoImage" || actual?.name === "ImageRef")) {
+      let start = expression;
+      while (start.kind === "member") start = start.receiver;
+      pushDiagnostic(
+        diagnostics,
+        uri,
+        anchor ? anchorSpan(anchor, start.pos, 1) : range2,
+        "sprite-slice-required",
+        "SpriteInfo requires a sprite slice, not an unsliced image. Select a slice with .Slice(0)."
+      );
+      return;
+    }
     if (storedValue && environment.projectIndex.typeByName.get(expected.name)?.kind === "interface" && (expression.kind === "litList" || expression.kind === "litDict" || actual !== void 0 && ["List", "Set", "Dictionary"].includes(actual.name) || expression.kind === "binary" && expression.op === ".." || knownGeneratorExpression(expression, scope, environment))) {
       pushDiagnostic(
         diagnostics,
@@ -98722,6 +99720,9 @@ function inferExpressionType(expression, scope, environment) {
       const index = ordinal ? Number(ordinal[1]) - 1 : receiver.tupleNames?.indexOf(expression.name) ?? -1;
       return receiver.arguments?.[index];
     }
+    if (receiver?.name === NEOSCRIPT_IMAGE_REGISTRY_TYPE && environment.imageRegistryEntries.has(expression.name)) {
+      return { name: "NeoImage" };
+    }
     if (receiver?.name === "Root") {
       const slot = PROJECT_ROOT_SOURCE_SLOTS.find(
         (slot2) => slot2.name === expression.name
@@ -99440,13 +100441,13 @@ function pushDiagnostic(diagnostics, uri, range2, code, message, severity = "err
     ...relatedInformation.length === 0 ? {} : { relatedInformation }
   });
 }
-function validateVariantValuedExpression(expression, expected, environment, uri, range2, diagnostics) {
+function validateVariantValuedExpression(expression, expected, environment, uri, range2, diagnostics, anchor) {
   if (expression.kind === "litNull") {
     if (expected.nullable !== true) {
       pushDiagnostic(
         diagnostics,
         uri,
-        range2,
+        anchor ? anchorSpan(anchor, expression.pos, 4) : range2,
         "variant-required-null",
         `A non-nullable ${NEO_VARIANT_TYPE_NAME} member cannot default to null. Declare it as '${NEO_VARIANT_TYPE_NAME}<...>?' for no selection, or name '<Class>.${NEO_VARIANT_SCOPE_NAME}.${NEO_VARIANT_RESERVED_NAME}' for the class with no variant applied.`
       );
@@ -99465,7 +100466,7 @@ function validateVariantValuedExpression(expression, expected, environment, uri,
   }
   const segments = variantPathSegments(expression);
   if (segments === null) return;
-  const resolved = resolveNeoVariantPath(environment.variantScopes, segments);
+  const resolved = resolveNeoVariantPath(environment.variantScopes, segments) ?? (segments.length === 3 && segments[1] === NEO_VARIANT_SCOPE_NAME && segments[2] === NEO_VARIANT_RESERVED_NAME && environment.types.has(segments[0]) ? { kind: "base", className: segments[0] } : null);
   if (resolved === null) {
     const failure = explainNeoVariantPath(
       environment.variantScopes,
@@ -99473,6 +100474,18 @@ function validateVariantValuedExpression(expression, expected, environment, uri,
       (name) => environment.types.has(name)
     );
     if (failure === null) return;
+    if (failure.kind === "unknownClass") {
+      let root = expression;
+      while (root.kind === "member") root = root.receiver;
+      pushDiagnostic(
+        diagnostics,
+        uri,
+        anchor ? anchorSpan(anchor, root.pos, failure.className.length) : range2,
+        "unknown-variant-class",
+        `Unknown class '${failure.className}' in variant path '${segments.join(".")}'.`
+      );
+      return;
+    }
     pushDiagnostic(
       diagnostics,
       uri,
@@ -99503,7 +100516,7 @@ function validateVariantValuedExpression(expression, expected, environment, uri,
   pushDiagnostic(
     diagnostics,
     uri,
-    range2,
+    anchor ? anchorSpan(anchor, expression.pos, 1) : range2,
     "variant-default-covariance",
     `'${segments.join(".")}' is a variant of '${owner}', which does not derive from the declared target '${target}'. A ${NEO_VARIANT_TYPE_NAME}<${target}> accepts variants of '${target}' and of its subclasses only.`
   );
@@ -104420,6 +105433,12 @@ function memberCompatibility(implementation, implementationSubstitution, target,
     environment,
     implementationGenericParameters
   ) && isClassTypedShape(targetType, environment, implementationGenericParameters);
+  const permitsVariantTargetCovariance = isClassOverride && implementation.kind === "field" && target.member.kind === "field" && implementationType.name === "NeoVariant" && targetType.name === "NeoVariant" && implementationType.arguments.length === 1 && targetType.arguments.length === 1 && isTypeAssignable(
+    implementationType.arguments[0],
+    targetType.arguments[0],
+    environment,
+    implementationGenericParameters
+  );
   const permitsDelegateReturnCovariance = isClassOverride && implementationFamily === "value" && delegateShapeAssignable(
     implementationType,
     targetType,
@@ -104428,7 +105447,7 @@ function memberCompatibility(implementation, implementationSubstitution, target,
   );
   const permitsStoredOverrideNullability = isClassOverride && implementation.kind === "field" && (target.member.kind === "field" || isAbstractPropertyContract(target.member, targetAccessors));
   const comparableImplementationType = permitsStoredOverrideNullability ? { ...implementationType, nullable: targetType.nullable } : implementationType;
-  if (!typesEqual(comparableImplementationType, targetType) && !(permitsDelegateReturnCovariance || (permitsCovariantGetter || permitsClassCovariance) && isTypeAssignable(
+  if (!typesEqual(comparableImplementationType, targetType) && !(permitsDelegateReturnCovariance || permitsVariantTargetCovariance || (permitsCovariantGetter || permitsClassCovariance) && isTypeAssignable(
     comparableImplementationType,
     targetType,
     environment,
@@ -122362,6 +123381,7 @@ function constructsValue(expression) {
   if (expression.kind === "new") {
     return expression.args.length > 0 || (expression.initializer?.length ?? 0) > 0;
   }
+  if (expression.kind === "tuple") return true;
   if (expression.kind === "litList") return expression.elements.length > 0;
   if (expression.kind === "litDict") return expression.entries.length > 0;
   return false;
@@ -126038,19 +127058,17 @@ function lowerExpressionValue(context, expression, declaredExpected, ownerClass,
   }
 }
 function slotForwardsTypeParameter(context, type2, ownerClass) {
-  if (type2.name === "List" || type2.name === "Dictionary") {
-    const entry = type2.arguments.at(-1);
-    return entry !== void 0 && slotForwardsTypeParameter(context, entry, ownerClass);
-  }
-  if (!context.classIdsByName.has(type2.name)) return false;
   const parameters = context.genericParametersByClass.get(
     materializedId(ownerClass, "class", ownerClass.name)
   );
-  if (parameters === void 0) return false;
-  for (const argument2 of type2.arguments) {
-    if (parameters.has(argument2.name)) return true;
-  }
-  return false;
+  if (parameters?.has(type2.name)) return true;
+  if (type2.tupleElements !== void 0)
+    return type2.tupleElements.some(
+      ({ type: type3 }) => slotForwardsTypeParameter(context, type3, ownerClass)
+    );
+  return type2.arguments.some(
+    (argument2) => slotForwardsTypeParameter(context, argument2, ownerClass)
+  );
 }
 function positionRequiresEvaluation(context, expression, expected, ownerClass) {
   const requiresEvaluation = () => initializerRequiresEvaluation(
@@ -141298,10 +142316,10 @@ function headlessVirtualInstanceLookups(document, options = {}) {
   const lookups = {
     ...indexed,
     changeListenerDefaultsForOwner: virtual.changeListenerDefaultsForOwner,
-    defaultValueById: (id2) => declarationDefaultSource(
+    defaultValueSource: (id2, member) => declarationDefaultSource(
       id2,
       indexed.valueById(id2),
-      virtual.virtualInstanceGraphForValue
+      (id3) => virtual.declarationDefaultGraph(id3, member)
     ),
     // Raw first, then virtual: a materialized row always wins over the
     // expansion that would otherwise answer for it.
@@ -143677,12 +144695,8 @@ function inspectClass(options, member) {
       );
     }
   }
-  const start = options.classEntryRange?.offset ?? 0;
-  const end = options.classEntryRange === void 0 ? schema.length : Math.min(schema.length, start + options.classEntryRange.limit);
   const children3 = [];
-  for (let index = start; index < end; index++) {
-    const entry = schema[index];
-    if (entry === void 0) continue;
+  for (const entry of schema) {
     const childRecord = options.index.member(entry.memberId);
     if (childRecord === void 0) {
       fail(
@@ -143716,8 +144730,7 @@ function inspectClass(options, member) {
     kind: "class",
     effectiveClassId,
     dependencies: [],
-    children: children3,
-    totalChildSlots: schema.length
+    children: children3
   };
 }
 function storedRowClassId(options, member) {
@@ -161059,6 +162072,7 @@ function valueLowerSchemaIndexes(manifest) {
       manifest.classes.map((entry) => [entry.name, entry])
     ),
     memberOverrides: indexMemberOverrides(members2),
+    variantDefaultMembers: /* @__PURE__ */ new Map(),
     manifestConstructors: new Map(
       manifest.constructors.map((constructor2) => [constructor2.id, constructor2])
     ),
@@ -162674,6 +163688,12 @@ function memberInitializerRequiresEvaluation(context, member, expression, source
   return requiresEvaluation;
 }
 function slotForwardsTypeParameter2(context, member, ownerClassId) {
+  if (member.kind === "generic") {
+    if (ownerClassId === void 0) return true;
+    return classGenericBindings(context.classes, ownerClassId).get(
+      member.genericParamId
+    )?.kind !== "member";
+  }
   if (member.kind === "tuple")
     return member.elementMemberIds.some((id2) => {
       const element = context.members.get(id2);
@@ -164986,7 +166006,7 @@ function lowerValueBody(context, member, expression, base, source, environment,
     case "color":
       return {
         ...next,
-        value: lowerStructuredLeaf(context, member, expression)
+        value: lowerStructuredLeaf(context, member, expression, source)
       };
     case "enum":
       return { ...next, value: lowerEnum2(context, member, expression) };
@@ -165005,7 +166025,7 @@ function lowerValueBody(context, member, expression, base, source, environment,
     case "sprite":
       return {
         ...next,
-        value: lowerStructuredLeaf(context, member, expression)
+        value: lowerStructuredLeaf(context, member, expression, source)
       };
     case "audio":
       return { ...next, value: lowerFileValue(context, member, expression) };
@@ -166701,7 +167721,7 @@ function lowerFileValue(context, member, expression) {
     throw new Error(`Audio member ${member.name} has an invalid file.`);
   return { fileId };
 }
-function lowerStructuredLeaf(context, member, expression) {
+function lowerStructuredLeaf(context, member, expression, source) {
   const kind = structuredLeafKindForSlug(member.kind);
   if (kind === null) {
     throw new Error(
@@ -166721,7 +167741,7 @@ function lowerStructuredLeaf(context, member, expression) {
       kind,
       label,
       partial,
-      structuredLeafLowering(context)
+      structuredLeafLowering(context, source, label)
     );
   }
   if (member.kind === "sprite") {
@@ -166731,12 +167751,23 @@ function lowerStructuredLeaf(context, member, expression) {
     kind,
     label,
     expression,
-    structuredLeafLowering(context)
+    structuredLeafLowering(context, source, label)
   );
 }
-function structuredLeafLowering(context) {
+function structuredLeafLowering(context, source, label) {
   return {
-    number: (expression) => requiredNumber2(expression),
+    number: (expression) => {
+      if (source.purpose !== "memberDefault") return requiredNumber2(expression);
+      return requiredNumber2(expression, () => {
+        const message = `${label} in "${source.label}" default has a computed component. Structured leaf components must be numeric literals.`;
+        context.loweringFailures.push({
+          code: "computed-structured-leaf-component",
+          message,
+          site: referenceSiteAt(source, leftmostPosition(expression))
+        });
+        throw new ReportedLoweringFailure(message);
+      });
+    },
     fileId: (expression) => fileTargetId(context, expression, "Images")
   };
 }
@@ -166745,13 +167776,14 @@ function requiredBoolean(expression) {
     throw new Error("Expected a bool literal.");
   return expression.value;
 }
-function requiredNumber2(expression) {
+function requiredNumber2(expression, onNonLiteral) {
   if (expression.kind === "litInt" || expression.kind === "litFloat") {
     return expression.value;
   }
   if (expression.kind === "unary" && expression.op === "-") {
-    return -requiredNumber2(expression.operand);
+    return -requiredNumber2(expression.operand, onNonLiteral);
   }
+  if (onNonLiteral !== void 0) return onNonLiteral();
   throw new Error("Expected a numeric literal.");
 }
 function requiredDecimal(expression) {
@@ -167615,6 +168647,34 @@ function pendingLocalizedTextId(binding, path) {
   }
   return `__pending__:localized-text:${encodeURIComponent(binding.source.uri)}:${binding.source.range.start.line}:${binding.source.range.start.character}:${encodeURIComponent(path)}`;
 }
+function variantDefaultMember(context, member) {
+  if (context.variantDefaultMembers.has(member.id))
+    return context.variantDefaultMembers.get(member.id) ?? null;
+  const path = [];
+  const seen = /* @__PURE__ */ new Set();
+  let current = member;
+  let owner = null;
+  while (current?.kind === "variant" && !seen.has(current.id)) {
+    if (context.variantDefaultMembers.has(current.id)) {
+      owner = context.variantDefaultMembers.get(current.id) ?? null;
+      break;
+    }
+    seen.add(current.id);
+    path.push(current);
+    if (current.defaultValue !== null) {
+      owner = current;
+      break;
+    }
+    current = current.overrideOf === null ? void 0 : context.members.get(current.overrideOf);
+  }
+  for (let index = path.length - 1; index >= 0; index--) {
+    const entry = path[index];
+    if (entry.required && entry !== owner && owner?.defaultValue && "value" in owner.defaultValue && owner.defaultValue.value === null)
+      owner = null;
+    context.variantDefaultMembers.set(entry.id, owner);
+  }
+  return owner;
+}
 function freshChildReplaysDeclaredDefault(args) {
   const { context, childMember, childId, rows, localizedTexts, environment } = args;
   if (!isPendingId(childId)) return false;
@@ -167632,11 +168692,12 @@ function freshChildReplaysDeclaredDefault(args) {
     childMember,
     environment
   );
+  const defaultMember = resolved.kind === "variant" ? variantDefaultMember(context, resolved) : resolved;
   let defaultValue = null;
-  if (resolved.defaultValue && "value" in resolved.defaultValue) {
-    defaultValue = resolved.defaultValue;
-  } else if (resolved.defaultValue && "serverValueId" in resolved.defaultValue) {
-    const storedMember = context.state[`member:${resolved.id}`]?.data;
+  if (defaultMember?.defaultValue && "value" in defaultMember.defaultValue) {
+    defaultValue = defaultMember.defaultValue;
+  } else if (defaultMember?.defaultValue && "serverValueId" in defaultMember.defaultValue) {
+    const storedMember = context.state[`member:${defaultMember.id}`]?.data;
     const storedDefault = isObjectRecord(storedMember) ? storedMember.defaultValue : null;
     if (isObjectRecord(storedDefault) && "value" in storedDefault) {
       defaultValue = {
@@ -206469,7 +207530,7 @@ function interfaceClassConstraintTarget(ctx, constraint, declaration, path, save
       ({ id: id2 }) => id2 === binding.genericParamId
     ) : void 0;
     const member = isForwardedGenericBinding(binding) ? null : resolveMemberById(ctx, binding.memberId, argPath);
-    const argument2 = forwarded?.name ?? (member === null ? null : csharpValueType(ctx, member, saved));
+    const argument2 = forwarded?.name ?? (member === null ? null : csharpGenericArgumentMemberType(ctx, member, void 0, saved));
     if (argument2 === null) return null;
     projected.push(argument2);
   }
@@ -207274,6 +208335,12 @@ function generateNeoSchemaClassLines(ctx, classId, constructions) {
   const inheritedPropertyAdapters = generateInheritedPropertyInterfaceAdapters(
     ctx,
     classDef,
+    new Map(
+      mergedMemberEntries.map(({ schemaKey, memberId }) => [
+        schemaKey,
+        memberId
+      ])
+    ),
     memberEnv
   );
   const projectedAncestorCloneAdapters = generateProjectedAncestorCloneAdapters(
@@ -207316,7 +208383,8 @@ function generateNeoSchemaClassLines(ctx, classId, constructions) {
       true,
       extendsClassId !== void 0,
       className,
-      memberEnv
+      memberEnv,
+      classDef.id
     )
   );
   const readOnlyInterface = generateReadOnlyNeoSchemaClassInterface(
@@ -208357,7 +209425,8 @@ function generateExplicitInterfaceMember(ctx, schemaKey, memberId, interfaceName
     ownerClassName,
     null,
     genericEnv,
-    ownerClassId
+    ownerClassId,
+    interfaceContract
   );
   const setter = isMemberNSPropertyBase(member) && typeof member.setterCode === "string" && !suppressesInheritedSetter(interfaceContract) ? nsPropertyWriteExpression(ctx, member, schemaKey) : null;
   return [
@@ -208530,7 +209599,7 @@ function generateExplicitFunctionInterfaceAdapter(ctx, member, interfaceType2, r
     )
   ];
 }
-function generateInheritedPropertyInterfaceAdapters(ctx, classDef, genericEnv) {
+function generateInheritedPropertyInterfaceAdapters(ctx, classDef, effectiveMembers, genericEnv) {
   let chain;
   try {
     chain = resolveInheritanceChain(classDef.id, ctx.classes);
@@ -208572,14 +209641,15 @@ function generateInheritedPropertyInterfaceAdapters(ctx, classDef, genericEnv) {
         true,
         genericEnv
       )?.valueType ?? null;
-      const interfaceValueType = emittedGeneratedMemberContract(
+      const interfaceContract = emittedGeneratedMemberContract(
         ctx,
         declarationClass.id,
         schemaKey,
         memberId,
         false,
         genericEnv
-      )?.valueType ?? null;
+      );
+      const interfaceValueType = interfaceContract?.valueType ?? null;
       if (classType === null || interfaceValueType === null || classType === interfaceValueType) {
         continue;
       }
@@ -208590,30 +209660,56 @@ function generateInheritedPropertyInterfaceAdapters(ctx, classDef, genericEnv) {
         false,
         declarationClass.id
       );
-      const getter = isMemberWithEntries(member) ? [
-        ...detachedReadExpression(
-          ctx,
-          member,
-          schemaKey,
-          memberSaved,
-          null,
-          genericEnv,
-          declarationClass.id,
-          false
-        ),
-        ...collectionReadExpression(
+      const referenceTarget = referenceContractTarget(interfaceContract);
+      const effectiveId = effectiveMembers.get(schemaKey);
+      const effectiveMember = effectiveId === void 0 ? null : resolveMemberById(ctx, effectiveId, `members.${effectiveId}`);
+      let getter;
+      if (effectiveMember !== null && isMemberLookupBase(effectiveMember) && !isMultiSelectionMember(effectiveMember)) {
+        getter = readExpression(
           ctx,
-          member,
-          `node.Get<${neoMemberNodeType(member)}>("${escapeCSharpString(schemaKey)}")`,
+          effectiveMember,
           schemaKey,
-          resolveMemberById(ctx, member.entryMemberId, "entryMemberId"),
+          "NeoMemberLookup",
           memberSaved,
+          classDef.name,
           null,
           genericEnv,
-          interfaceValueType,
-          false
-        )
-      ] : [`return (${interfaceValueType})(object)${source}!;`];
+          classDef.id,
+          interfaceContract
+        );
+      } else if (referenceTarget !== null) {
+        const missing = interfaceValueType.endsWith("?") ? "" : ` ?? ${REQUIRED_LOOKUP_MISSING}`;
+        getter = [
+          `return NeoGeneratedTypesSupport.ReadReference<${referenceTarget}>(client, ${source}?.TargetId)${missing};`
+        ];
+      } else if (isMemberWithEntries(member)) {
+        getter = [
+          ...detachedReadExpression(
+            ctx,
+            member,
+            schemaKey,
+            memberSaved,
+            null,
+            genericEnv,
+            declarationClass.id,
+            false
+          ),
+          ...collectionReadExpression(
+            ctx,
+            member,
+            `node.Get<${neoMemberNodeType(member)}>("${escapeCSharpString(schemaKey)}")`,
+            schemaKey,
+            resolveMemberById(ctx, member.entryMemberId, "entryMemberId"),
+            memberSaved,
+            null,
+            genericEnv,
+            interfaceValueType,
+            false
+          )
+        ];
+      } else {
+        getter = [`return (${interfaceValueType})(object)${source}!;`];
+      }
       const hasSetter = isMemberNSPropertyBase(member) && typeof member.setterCode === "string";
       const adapter = [
         `${interfaceValueType} ${interfaceType2}.${memberName}`,
@@ -208752,7 +209848,7 @@ function generateFunctionHandlerProperty(ctx, classDef, className, genericParams
     "}"
   ];
 }
-function generateChangeSubscriptionMembers(ctx, entries, saved, hideBaseMembers, ownerClassName, genericEnv) {
+function generateChangeSubscriptionMembers(ctx, entries, saved, hideBaseMembers, ownerClassName, genericEnv, ownerClassId) {
   const fields = entries.flatMap(([schemaKey, memberId]) => {
     const memberName = validateSchemaMemberName(
       ctx,
@@ -208762,8 +209858,27 @@ function generateChangeSubscriptionMembers(ctx, entries, saved, hideBaseMembers,
     if (memberName === null) return [];
     const member = resolveMemberById(ctx, memberId, `members.${memberId}`);
     if (member === null) return [];
-    const valueType = csharpPropertyValueType(ctx, member, saved, genericEnv);
-    if (valueType === null) return [];
+    const rawValueType = csharpPropertyValueType(
+      ctx,
+      member,
+      saved,
+      genericEnv
+    );
+    if (rawValueType === null) return [];
+    const contract = isMemberLookupBase(member) || isMemberVariantBase(member) ? inheritedGeneratedMemberContract(
+      ctx,
+      ownerClassId,
+      schemaKey,
+      memberId,
+      saved,
+      genericEnv
+    ) : null;
+    const valueType = narrowedMemberValueType(
+      ctx,
+      member,
+      rawValueType,
+      contract
+    );
     return [{ schemaKey, memberName, valueType, member }];
   });
   const members2 = [
@@ -210025,7 +211140,7 @@ function genericParamConstraintClauses(ctx, classDef, scope, saved, env) {
         continue;
       }
       const member = resolveMemberById(ctx, binding.memberId, path);
-      const argument2 = member === null ? null : csharpValueType(ctx, member, saved, env);
+      const argument2 = member === null ? null : csharpGenericArgumentMemberType(ctx, member, env, saved);
       if (argument2 === null) {
         complete2 = false;
         break;
@@ -210059,7 +211174,12 @@ function baseClauseGenericArguments(ctx, classDef, extendsClassId, saved, env) {
     }
     const bindingMember = resolveMemberById(ctx, binding.memberId, path);
     if (bindingMember === null) return inScope.param.name;
-    const argType = csharpValueType(ctx, bindingMember, saved, env);
+    const argType = csharpGenericArgumentMemberType(
+      ctx,
+      bindingMember,
+      env,
+      saved
+    );
     if (argType === null) {
       ctx.diagnostics.push({
         severity: "error",
@@ -211262,7 +212382,9 @@ function generateMember(ctx, schemaKey, memberId, saved, modifier, emitBody, own
     ownerClassName,
     memberSaved && saved && !memberHasPinnedWritableStorage(ctx, memberId, ownerClassId) ? `${ownerClassName}.${memberName}` : null,
     genericEnv,
-    ownerClassId
+    ownerClassId,
+    inheritedContract,
+    valueType
   );
   const declaredPropertySetter = isMemberNSPropertyBase(member) && typeof member.setterCode === "string" ? nsPropertyWriteExpression(ctx, member, schemaKey) : null;
   const propertySetter = suppressesInheritedSetter(inheritedContract) ? null : declaredPropertySetter;
@@ -212258,7 +213380,7 @@ function isAnimationClipMember(ctx, memberId) {
 }
 function factoryParameterType(ctx, member, optional2 = true, genericEnv) {
   if (isMemberTupleBase(member)) {
-    const info = memberTypeInfoForCodegen(ctx, member);
+    const info = storedMemberTypeInfoForCodegen(ctx, member);
     return info === null ? "object?" : csharpTypeInfoValueType(
       ctx,
       { ...info, required: !optional2 },
@@ -212666,7 +213788,7 @@ function nsGetterGenericResultExpression(ctx, typeInfo, valueExpression, saved,
     if (constraint !== void 0 && isClassGenericConstraint(constraint)) {
       return `NeoGeneratedTypesSupport.ResolveNativeFunctionClassArgument<${projected2}>(client, ${valueExpression}, ${typeInfo.required ? "true" : "false"}, ${ctx.projectClassName}.NeoReadOnlyValueFactories, ${ctx.projectClassName}.NeoWritableValueFactories, "NSProperty result")!`;
     }
-    return `${valueExpression} is null || ${valueExpression} is ${projected2} ? (${projected2})${valueExpression}! : (${projected2})Convert.ChangeType(${valueExpression}, Nullable.GetUnderlyingType(typeof(${projected2})) ?? typeof(${projected2}), System.Globalization.CultureInfo.InvariantCulture)!`;
+    return `NeoGeneratedTypesSupport.ReadTypeArgument<${projected2}>(client, ${valueExpression}, "${escapeCSharpString(projected2)}", ${ctx.projectClassName}.NeoReadOnlyValueFactories, ${ctx.projectClassName}.NeoWritableValueFactories)`;
   }
   const required2 = isRequiredMember(binding);
   if (isMemberBoolBase(binding)) {
@@ -212725,7 +213847,47 @@ function nsGetterGenericResultExpression(ctx, typeInfo, valueExpression, saved,
   const projected = csharpValueType(ctx, binding, saved, genericEnv) ?? "object?";
   return `(${projected})${valueExpression}!`;
 }
-function readExpression(ctx, member, schemaKey, nodeType, saved, ownerClassName, writeGuardMemberName, genericEnv, ownerClassId) {
+function referenceContractTarget(contract) {
+  if (contract?.valueTypeInfo?.type !== 29 /* Reference */) return null;
+  const type2 = contract.valueType;
+  if (!type2.startsWith("NeoReference<")) return null;
+  return type2.slice("NeoReference<".length, type2.endsWith("?") ? -2 : -1);
+}
+function readExpression(ctx, member, schemaKey, nodeType, saved, ownerClassName, writeGuardMemberName, genericEnv, ownerClassId, contract = null, projectedValueType) {
+  const rawValueType = contract !== null && isMemberLookupBase(member) ? csharpPropertyValueType(ctx, member, saved, genericEnv) : null;
+  if (rawValueType !== null && contract !== null && referenceImplementsValueContract(ctx, member, rawValueType, contract)) {
+    const key = escapeCSharpString(schemaKey);
+    const missing = isRequiredMember(member) ? `${REQUIRED_LOOKUP_MISSING};` : `return default(${contract.valueType}) is null ? default! : throw new InvalidOperationException("An absent optional reference cannot supply a non-nullable value.");`;
+    return [
+      ...ownerClassId !== void 0 && classSupportsDetachedViews(ctx, ownerClassId) ? [
+        `if (TryReadDetached("${key}", out object? detachedValue))`,
+        "{",
+        ...indent([
+          `var reference = NeoGeneratedTypesSupport.ReadReference<${contract.valueType}>(client, detachedValue);`,
+          `if (reference is null) ${missing}`,
+          "return reference.Value;"
+        ]),
+        "}"
+      ] : [],
+      `var selected = node.Get<${nodeType}>("${key}").GetFirstSelected();`,
+      `if (selected is null) ${missing}`,
+      `return NeoGenericBindings.Referenced<${contract.valueType}, ${contract.valueType}>(client, selected);`
+    ];
+  }
+  const referenceTarget = referenceContractTarget(contract);
+  if (referenceTarget !== null && contract !== null && isMemberLookupBase(member) && !isMultiSelectionMember(member)) {
+    const key = escapeCSharpString(schemaKey);
+    const read = (value) => `NeoGeneratedTypesSupport.ReadReference<${referenceTarget}>(client, ${value})${contract.valueType.endsWith("?") ? "" : ` ?? ${REQUIRED_LOOKUP_MISSING}`}`;
+    return [
+      ...ownerClassId !== void 0 && classSupportsDetachedViews(ctx, ownerClassId) ? [
+        `if (TryReadDetached("${key}", out object? detachedValue))`,
+        "{",
+        ...indent([`return ${read("detachedValue")};`]),
+        "}"
+      ] : [],
+      `return ${read(`node.Get<${nodeType}>("${key}")`)};`
+    ];
+  }
   return [
     ...detachedReadExpression(
       ctx,
@@ -212745,7 +213907,8 @@ function readExpression(ctx, member, schemaKey, nodeType, saved, ownerClassName,
       ownerClassName,
       writeGuardMemberName,
       genericEnv,
-      ownerClassId
+      ownerClassId,
+      projectedValueType
     )
   ];
 }
@@ -212895,7 +214058,7 @@ function detachedValueExpression(ctx, member, value, required2, saved, genericEn
   }
   return null;
 }
-function storedReadExpression(ctx, member, schemaKey, nodeType, saved, ownerClassName, writeGuardMemberName, genericEnv, ownerClassId) {
+function storedReadExpression(ctx, member, schemaKey, nodeType, saved, ownerClassName, writeGuardMemberName, genericEnv, ownerClassId, projectedValueType) {
   const getNode = `node.Get<${nodeType}>("${escapeCSharpString(schemaKey)}")`;
   if (isMemberTupleBase(member)) {
     const info = memberTypeInfoForCodegen(ctx, member);
@@ -212944,7 +214107,7 @@ function storedReadExpression(ctx, member, schemaKey, nodeType, saved, ownerClas
     ] : [`return NeoDecimalValues.ParseOrNull(${getNode}.value?.value);`];
   }
   if (isMemberVariantBase(member)) {
-    const targetType = variantTargetCSharpType(ctx, member, genericEnv) ?? UNRESOLVED_VARIANT_TARGET;
+    const targetType = projectedValueType?.match(/^NeoVariant<(.+)>\??$/)?.[1] ?? variantTargetCSharpType(ctx, member, genericEnv) ?? UNRESOLVED_VARIANT_TARGET;
     const valueType = variantValueCSharpType(ctx, member, genericEnv);
     const expression = valueType === null ? `NeoGeneratedTypesSupport.ResolveVariantValue<${targetType}>(${getNode})` : `NeoGeneratedTypesSupport.ResolveLookupVariantValue<${targetType}, ${valueType}>(${getNode})`;
     return isRequiredMember(member) ? [
@@ -213461,9 +214624,10 @@ function lookupReferenceRead(ctx, member, node, genericEnv) {
   const read = `NeoGeneratedTypesSupport.ReadReference<${slotReferenceValueType(ctx, member, genericEnv)}>(client, ${node})`;
   return isRequiredMember(member) ? `${read} ?? ${missing}` : read;
 }
-function lookupReferenceSetItem(ctx, member, node, genericEnv) {
+function lookupReferenceSetItem(ctx, member, node, genericEnv, selection2 = "child") {
   const collection = lookupCollectionView(ctx, member, genericEnv);
-  if (collection !== null) return `child => ${collection.read}(client, child)`;
+  if (collection !== null)
+    return `${selection2} => ${collection.read}(client, ${selection2})`;
   return `(string id) => NeoGeneratedTypesSupport.ReferenceEntry<${slotReferenceValueType(ctx, member, genericEnv)}>(client, ${node}, id)`;
 }
 function slotReferenceResult(ctx, typeInfo, valueExpression, genericEnv, genericBindingSaved = false) {
@@ -213511,7 +214675,12 @@ function lookupSelectionFactory(ctx, member, selection2, saved, writeGuardMember
   );
   if (interfaceSelection !== null) return interfaceSelection;
   const targetClass = lookupTargetClassProjection(ctx, member, genericEnv);
-  if (targetClass === null) return null;
+  if (targetClass === null) {
+    const target = lookupReferenceTarget(ctx, member);
+    if (target?.type !== 21 /* Generic */) return null;
+    const valueType = csharpTypeInfoValueType(ctx, target, true, genericEnv);
+    return valueType === null ? null : `NeoGenericBindings.Resolve<${valueType}>(client, ${selection2}).Read(${selection2})`;
+  }
   const typeName = ctx.typeNames.get(targetClass.classId) ?? "NeoNode";
   const savedTypeRef = `${qualifyGeneratedType(ctx, savedTypeName(typeName))}${targetClass.constructedSuffix}`;
   const writable = `writable${selection2[0].toUpperCase()}${selection2.slice(1)}`;
@@ -213725,6 +214894,32 @@ function childConverter(ctx, member, saved = false, branchOnReadOnly = false, ge
     return isMultiSelectionMember(member) ? saved ? `new ${setType}(client, (NeoMemberEnum)child, () => (NeoMemberEnumWritable)child${enumKeyCodecArguments(ctx, member.enumId)})` : `new ${setType}(client, (NeoMemberEnum)child${enumKeyCodecArguments(ctx, member.enumId)})` : isRequiredMember(member) ? `NeoGeneratedTypesSupport.ReadEnumSingle(((NeoMemberEnum)child).Selected(), ${parser}) ?? throw new InvalidOperationException("Required enum '${escapeCSharpString(member.name)}' has no selected option.")` : `NeoGeneratedTypesSupport.ReadEnumSingle(((NeoMemberEnum)child).Selected(), ${parser})`;
   }
   if (isMemberLookupBase(member)) {
+    if (isMultiSelectionMember(member)) {
+      const node = "((NeoMemberLookup)child)";
+      const guardName = branchOnReadOnly ? member.name : null;
+      const factory2 = lookupSelectionFactory(
+        ctx,
+        member,
+        "selectedEntry",
+        saved,
+        guardName,
+        genericEnv
+      );
+      let createItem;
+      if (lookupProjection(ctx, member) !== "class" /* Class */) {
+        createItem = lookupReferenceSetItem(
+          ctx,
+          member,
+          node,
+          genericEnv,
+          "selectedEntry"
+        );
+      } else {
+        createItem = factory2 === null ? "(string id) => new NeoLookupSelection(id)" : `selectedEntry => ${factory2}`;
+      }
+      const setType = csharpValueType(ctx, member, saved, genericEnv);
+      return saved ? `new ${setType}(client, ${node}, () => (NeoMemberLookupWritable)child, ${createItem}${collectionGuardArguments(member, guardName)})` : `new ${setType}(client, ${node}, ${createItem})`;
+    }
     if (lookupProjection(ctx, member) !== "class" /* Class */)
       return lookupReferenceRead(
         ctx,
@@ -238699,7 +239894,7 @@ var releaseWorkspaceLock = () => void 0;
 async function main() {
   const args = parseArgs(process.argv.slice(2));
   if (args.command === "--version") {
-    console.log("0.89.4");
+    console.log("0.89.6");
     return;
   }
   if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {