@neocompose/cli 0.89.4 → 0.89.6

package/dist/test-worker.mjs

@@ -3090,7 +3090,7 @@ function relativeDebugUri(uri) {
 }
 
 // ../packages/neoscript-language/src/strict-ir.ts
-var NEOSCRIPT_COMPILER_REVISION = 17;
+var NEOSCRIPT_COMPILER_REVISION = 18;
 var NeoScriptDialogueOp = /* @__PURE__ */ ((NeoScriptDialogueOp2) => {
   NeoScriptDialogueOp2["TryTrigger"] = "TryTrigger";
   NeoScriptDialogueOp2["CanTrigger"] = "CanTrigger";
@@ -4515,6 +4515,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);
 }
@@ -10349,6 +10351,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;
@@ -17711,11 +17716,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 document2 = args.document;
+    const rows = resolved.rowsById;
+    args = {
+      ...args,
+      document: {
+        ...document2,
+        valueById: (id) => rows.get(id) ?? document2.valueById?.(id) ?? null,
+        defaultValueSource: (id, child) => {
+          const value = rows.get(id);
+          return value === void 0 ? document2.defaultValueSource?.(id, child) ?? null : { value };
+        }
+      }
+    };
+  }
   if (capture === void 0)
     return cloneDefaultValueForMemberCore(args, source);
   const start = source.changeListeners === void 0 ? void 0 : capture.begin();
@@ -22913,6 +22943,13 @@ var FunctionTypeInference = class {
       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];
@@ -25228,6 +25265,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(
@@ -25552,11 +25608,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
       ),
@@ -27700,6 +27760,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,
@@ -27719,7 +27785,7 @@ function evalInstructions(instructions, scope, ctx, options) {
               const selection = encodeLookupInitializerSelection(
                 lookupMember,
                 value,
-                [],
+                /* @__PURE__ */ new Set(),
                 ctx,
                 lookupTarget
               );
@@ -27732,7 +27798,7 @@ function evalInstructions(instructions, scope, ctx, options) {
               );
               value = selection;
             }
-            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 ? {
@@ -28412,6 +28478,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) {
@@ -28429,7 +28512,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,
@@ -28438,6 +28520,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) {
@@ -28482,6 +28571,14 @@ function applyOverlayAssignment(target, targetTypeInfo, value, scope, ctx, desti
   const object = 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) {
+      object[stringKey] = slot.id;
+      if (replaceEntryRowValue(receiver, slot.id, value, targetTypeInfo, ctx))
+        return;
+    }
+  }
   if (referenceValueId !== null) {
     const parentId = findKnownRowIdByValueReference(receiver, ctx);
     if (parentId !== null) {
@@ -28548,6 +28645,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(
@@ -28619,20 +28719,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;
   }
-  if (targetTypeInfo.type === 5 /* Dictionary */ && typeof value === "object" && value !== null && !cache.referenceEntryKeysByRecord.has(value)) {
-    cache.referenceEntryKeysByRecord.set(value, /* @__PURE__ */ new Set());
+  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 open = ctx.__executionState?.openConstructions;
+  if (open === void 0 || open.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 id = pending.pop();
+    if (id === void 0 || visited.has(id)) continue;
+    visited.add(id);
+    const row = evalValueById(
+      ctx,
+      id,
+      ctx.__runtimeSessionValues,
+      ctx.__valueOverlay
+    );
+    if (row === null) continue;
+    if (typeof row.value === "object" && row.value !== null && open.has(row.value))
+      roots.add(id);
+    for (const owner of currentOwnedValueAttachments(
+      id,
+      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), id)) {
+      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,
+        id,
+        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;
+      }
+    }
+  }
+  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 id = valueId ?? findKnownRowIdByValueReference(raw, ctx);
+    if (id === null) return 0 /* Continue */;
+    if (attached.has(id))
+      throw new NSGetterRuntimeError(
+        `Aggregate value '${id}' is already owned by another entry of '${row.id}'. Call Clone() explicitly.`
+      );
+    attached.add(id);
+    const placement = Array.isArray(collection) ? "index" : "slot";
+    assertOwnedValueAttachable(
+      id,
+      { identity: `value:${row.id}:${placement}:${key}`, label: row.id },
+      `${row.id}[${key}]`,
+      ctx,
+      false,
+      "assign",
+      preflight
+    );
+    return 0 /* Continue */;
+  });
+  for (const [id, destination] of preflight.constructorArgumentTransfers)
+    ctx.__executionState?.ownedValueAttachments.set(id, destination);
+  for (const [id, destination] of preflight.dependencies)
+    recordConstructorGroupDependency(id, 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) {
@@ -28719,7 +28995,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);
@@ -29064,7 +29340,7 @@ function materializeSlotRow(place, targetId, ctx) {
   const value = member === null ? read : encodeLookupInitializerSelection(
     member,
     read,
-    [],
+    /* @__PURE__ */ new Set(),
     ctx,
     lookupTargetTypeInfo(member, owner, ctx)
   );
@@ -29515,8 +29791,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) {
@@ -29544,6 +29824,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;
@@ -29602,6 +29889,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,
@@ -29673,7 +29961,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({
@@ -29819,6 +30128,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 [id, previous] of reservations) {
+      if (previous === void 0) attachments?.delete(id);
+      else attachments?.set(id, 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;
@@ -30564,6 +30957,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(reference, ctx) {
   if (!(reference instanceof NSSlotReference)) return reference;
   if (reference.place !== null) {
@@ -30815,7 +31241,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);
     }
@@ -33466,7 +33898,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);
@@ -33475,10 +33921,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);
@@ -36069,7 +36531,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);
@@ -36390,7 +36852,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(
@@ -36718,11 +37180,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 : (id, member) => {
+      ctx.valueDependencies?.add(id);
+      return database.defaultValueSource(id, member);
+    },
     // The declaration rows a default clones are reads of this evaluation.
     ...database === void 0 ? {} : {
       valueById: (id) => {
         ctx.valueDependencies?.add(id);
-        return database.defaultValueById !== void 0 ? database.defaultValueById(id) : database.valueById(id);
+        return database.valueById(id);
       }
     },
     ...entryIdsOf === void 0 ? {} : {
@@ -37402,9 +37868,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;
@@ -37412,7 +37881,19 @@ function evaluateInitializerInContext(init, member, ctx, createdValues, argument
   }
   const created = result.createdSessionValues ?? [];
   if (isMemberLookupBase(member)) {
-    return encodeLookupInitializerResult(member, result.value, created, ctx);
+    const declaredTarget = lookupTargetTypeInfo(member, null, ctx);
+    const target = typeInfoContainsGeneric2(declaredTarget) ? substituteRuntimeTypeInfo(
+      declaredTarget,
+      genericEnv,
+      ctx
+    ) : declaredTarget;
+    return encodeLookupInitializerResult(
+      member,
+      result.value,
+      created,
+      ctx,
+      target
+    );
   }
   let rootRow = initializerRootRow(result.value, created);
   for (const row of created) {
@@ -37502,12 +37983,13 @@ function ensureInitializerCompiled(args) {
   }
   return compiled;
 }
-function encodeLookupInitializerResult(member, value, created, ctx) {
+function encodeLookupInitializerResult(member, value, created, ctx, target = lookupTargetTypeInfo(member, null, ctx)) {
   const selection = encodeLookupInitializerSelection(
     member,
     value,
-    created,
-    ctx
+    new Set(created.map((row) => row.id)),
+    ctx,
+    target
   );
   if (created.length > 0) {
     for (const row of created) {
@@ -37517,11 +37999,11 @@ function encodeLookupInitializerResult(member, value, created, ctx) {
   }
   return { value: selection, 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) {
@@ -37530,7 +38012,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) {
@@ -37538,9 +38020,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) {
@@ -37552,7 +38034,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.`
       );
@@ -37731,7 +38213,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;
   }
@@ -37744,7 +38230,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;
@@ -38561,6 +39051,7 @@ function constructDeclaredClassValue(info, scope, ctx) {
   const descriptor = validateClassConstructorDescriptor(info, ctx, false);
   const schemaClass2 = descriptor.schemaClass;
   const record4 = 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(
@@ -38570,6 +39061,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();
   }
@@ -38641,6 +39139,9 @@ function constructDeclaredClassValueWithinFrame(descriptor, record4, 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 (record4 !== null) {
@@ -38778,7 +39279,14 @@ function constructDeclaredClassValueWithinFrame(descriptor, record4, info, scope
   });
   return root.value;
 }
-function assertOwnedValueAttachable(valueId, destination, destinationName, 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, destinationName, ctx, reserveUntilPublished = false, mode = "assign", preflight) {
   const row = evalValueById(
     ctx,
     valueId,
@@ -38790,8 +39298,13 @@ function assertOwnedValueAttachable(valueId, destination, destinationName, ctx,
       `Aggregate assignment to '${destinationName}' 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 '${destinationName}'. Call Clone() explicitly.`
     );
@@ -38807,9 +39320,14 @@ function assertOwnedValueAttachable(valueId, destination, destinationName, 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(
@@ -38819,7 +39337,9 @@ function assertOwnedValueAttachable(valueId, destination, destinationName, 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;
@@ -38840,7 +39360,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 = (child, key) => {
+      if (typeof child !== "string") return;
+      const keys = indexed.get(child);
+      if (keys === void 0) indexed.set(child, [key]);
+      else keys.push(key);
+    };
+    if (Array.isArray(value)) value.forEach(add);
+    else for (const [key, child] of Object.entries(value)) add(child, 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];
@@ -38903,7 +39441,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);
@@ -38920,7 +39465,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}`,
@@ -38930,8 +39482,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
@@ -38940,8 +39501,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
@@ -39268,8 +39837,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);
@@ -39305,15 +39878,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) {
@@ -39356,6 +39932,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,
@@ -39440,6 +40024,7 @@ function materializeConstructorArgumentValue(args) {
       }
     }
     row.value = ids;
+    args.collectionAliases?.set(row, collectionAlias);
     return row;
   }
   if (isMemberDictionaryBase(args.member)) {
@@ -39494,6 +40079,7 @@ function materializeConstructorArgumentValue(args) {
       }).id;
     }
     row.value = record4;
+    args.collectionAliases?.set(row, collectionAlias);
     return row;
   }
   return registerConstructorArgumentRow(args, args.value);
@@ -44096,7 +44682,11 @@ function materializeMemberDefaultValue(args) {
       valueById: (id) => {
         args.readTracking?.valueIds.add(id);
         const database2 = evaluatorLookups();
-        return database2.defaultValueById !== void 0 ? database2.defaultValueById(id) : database2.valueById(id);
+        return database2.valueById(id);
+      },
+      defaultValueSource: (id, member) => {
+        args.readTracking?.valueIds.add(id);
+        return evaluatorLookups().defaultValueSource?.(id, member) ?? null;
       },
       unorderedListEntryIds: (containerId) => {
         args.readTracking?.containerIds.add(containerId);
@@ -44178,9 +44768,14 @@ function materializeMemberDefaultValue(args) {
 
 // ../packages/neoscript-runtime/src/declaration-default-source.ts
 function declarationDefaultSource(id, stored, resolveGraph) {
-  if (stored !== null && !isCollapseStampedInstanceRoot(stored)) return stored;
+  if (stored !== null && !isCollapseStampedInstanceRoot(stored))
+    return { value: stored };
   const graph = resolveGraph(id);
-  return defaultSourceWithListeners(graph?.rowsById.get(id) ?? stored, graph);
+  const value = defaultSourceWithListeners(
+    graph?.rowsById.get(id) ?? stored,
+    graph
+  );
+  return value === null ? null : { value, rowsById: graph?.rowsById };
 }
 
 // ../packages/models/src/members/stored-value-placement-index.ts
@@ -45353,6 +45948,7 @@ function rowGenericEnvironment(document2, row, contextualRootMember) {
   for (const [paramId, binding] of envFromStamp(row.genericBindings)) {
     env.set(paramId, binding);
   }
+  closeForwardedGenericParams(env);
   return env;
 }
 function tryResolveTypeInfo(document2, rawTypeInfo, env) {
@@ -46592,6 +47188,9 @@ function prepareStoredClassValueResolution(args) {
     readRecorder: args.readRecorder
   };
 }
+function resolveStoredClassValue(args) {
+  return resolveVirtualInstanceGraph(prepareStoredClassValueResolution(args));
+}
 function expandStoredClassValue(args) {
   const placement = resolveMember(args.rootMember, args.document.members);
   if (isClassSlotMember(placement) && placement.payload === 1 /* Partial */) {
@@ -49296,6 +49895,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);
@@ -49442,7 +50056,7 @@ function initializerEvaluatorLookups(document2, readTracking) {
       },
       memberById: (id) => databaseVM.memberById(id),
       valueById: (id) => databaseVM.valueById(id),
-      defaultValueById: (id) => databaseVM.defaultValueById?.(id) ?? databaseVM.valueById(id),
+      defaultValueSource: databaseVM.defaultValueSource?.bind(databaseVM),
       onInitializerRead: databaseVM.onInitializerRead,
       localizedTextById: (id) => databaseVM.localizedTextById?.(id) ?? null,
       ...databaseVM.hasStoredValueId === void 0 ? {} : {
@@ -49513,10 +50127,10 @@ function initializerEvaluatorLookups(document2, readTracking) {
   const lookups = {
     ...indexedLookups,
     changeListenerDefaultsForOwner: headlessVirtualResolver.changeListenerDefaultsForOwner,
-    defaultValueById: (id) => declarationDefaultSource(
+    defaultValueSource: (id, member) => declarationDefaultSource(
       id,
       indexedLookups.valueById(id),
-      headlessVirtualResolver.virtualInstanceGraphForValue
+      (id2) => headlessVirtualResolver.declarationDefaultGraph(id2, member)
     ),
     valueById: (id) => indexedLookups.valueById(id) ?? headlessVirtualResolver.valueById(id),
     rowForValueReference: (value) => indexedLookups.rowForValueReference?.(value) ?? headlessVirtualResolver.rowForValueReference(value),
@@ -49572,7 +50186,8 @@ function defaultValuePlans(document2) {
     projectFiles: document2.projectFiles,
     textureTemplates: document2.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: document2.databaseVM?.unorderedListEntryIds === void 0 && document2.databaseVM !== void 0 ? void 0 : lookups.unorderedListEntryIds
   });
@@ -49912,10 +50527,10 @@ function headlessVirtualInstanceLookups(document2, options = {}) {
   const lookups = {
     ...indexed,
     changeListenerDefaultsForOwner: virtual.changeListenerDefaultsForOwner,
-    defaultValueById: (id) => declarationDefaultSource(
+    defaultValueSource: (id, member) => declarationDefaultSource(
       id,
       indexed.valueById(id),
-      virtual.virtualInstanceGraphForValue
+      (id2) => virtual.declarationDefaultGraph(id2, member)
     ),
     // Raw first, then virtual: a materialized row always wins over the
     // expansion that would otherwise answer for it.
@@ -52606,6 +53221,8 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
    * 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;
@@ -54819,7 +55436,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       );
     }
     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;
@@ -54901,6 +55518,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       ...bindings.length > 0 ? { bindings } : {},
       target: {
         pointer: capturedTarget.pointer,
+        ...target.structuredLeafKind === void 0 ? {} : { structuredLeafKind: target.structuredLeafKind },
         typeInfo: target.wireType ?? toWireType(target.type, this.project),
         writability
       },
@@ -55967,8 +56585,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
   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);
@@ -56031,7 +56648,11 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
   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,
@@ -58800,6 +59421,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     }
     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: {
@@ -58821,7 +59443,8 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         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 }
@@ -61934,10 +62557,13 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       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);
@@ -61998,9 +62624,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     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((parameter3, parameterIndex) => {
@@ -62011,8 +62635,14 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         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),
@@ -62036,9 +62666,17 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
           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)
       );
@@ -62053,8 +62691,8 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
           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);
@@ -62072,7 +62710,8 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     }
     return {
       typeArguments: inference.arguments(),
-      resolved: resolvedArguments
+      resolved: resolvedArguments,
+      lambdas
     };
   }
   callableSignatureForReceiver(symbol, receiver, typeArguments, pos, inferred) {
@@ -65592,7 +66231,7 @@ function variable(id, 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((parameter3) => {
@@ -65636,7 +66275,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)}.`,
@@ -67204,7 +67843,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":
@@ -67257,7 +67896,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)
@@ -67297,7 +67936,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")
           )
         } : {}
       };
@@ -67309,7 +67948,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: {
@@ -67322,11 +67966,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.
@@ -67345,7 +67999,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;
     }
@@ -67353,12 +68012,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";
@@ -67373,6 +68027,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])
@@ -76894,6 +77551,15 @@ function isCallableMemberForCodegen(value) {
 var DEFAULT_NAMESPACE = "Assets.Scripts.Neo";
 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();
@@ -76987,6 +77653,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(
@@ -77205,12 +77872,25 @@ function inheritedGeneratedMemberContract(ctx, ownerClassId, schemaKey, memberId
   }
   return null;
 }
+function declaredGeneratedPropertyValueType(ctx, member, memberSaved, saved, genericEnv) {
+  const declared = lookupDeclaredTypeInfo2(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 = lookupDeclaredTypeInfo2(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,
@@ -77221,11 +77901,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)
   };
 }
@@ -77234,7 +77941,8 @@ function suppressesInheritedSetter(contract) {
 }
 function generatedValueTypeInfo(ctx, member) {
   const required = isRequiredMember(member);
-  if (isMemberTupleBase(member)) return memberTypeInfoForCodegen(ctx, member);
+  if (isMemberTupleBase(member) || isMemberVariantBase(member))
+    return memberTypeInfoForCodegen(ctx, member);
   const slotType = classSlotTypeInfo(ctx, member, required);
   if (slotType !== null) return slotType;
   const returnType = nsPropertyReturnTypeInfo(member);
@@ -77249,8 +77957,8 @@ function generatedValueTypeInfo(ctx, member) {
   return null;
 }
 function genericParamTypeInfo2(ctx, genericParamId, required) {
-  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.`,
@@ -77261,7 +77969,7 @@ function genericParamTypeInfo2(ctx, genericParamId, required) {
   return {
     type: 21 /* Generic */,
     required,
-    ownerClassId: declaration.declaringClass.id,
+    ownerClassId: declaration.declaringClassId,
     genericParamId
   };
 }
@@ -77282,7 +77990,7 @@ function classSlotTypeInfo(ctx, member, required) {
         "classArguments"
       );
       if (argument2 === null) return null;
-      const typeInfo = memberTypeInfoForCodegen(ctx, argument2);
+      const typeInfo = storedMemberTypeInfoForCodegen(ctx, argument2);
       if (typeInfo === null) return null;
       typeArguments[parameterId] = typeInfo;
     }
@@ -77310,9 +78018,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 = genericParamTypeInfo2(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 */ && (lookupDeclaredTypeInfo2(member)?.type === 21 /* Generic */ || projection === "collection" /* Collection */))
+    return true;
+  if (projection !== "slot" /* Slot */) return false;
+  const target = lookupDeclaredTypeInfo2(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;
   }
@@ -77331,6 +78093,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;
@@ -77433,8 +78202,13 @@ function calculateDeclarationSignature(ctx, projectionClassId, schemaKey, declar
     true,
     declaration.classDef.id
   );
-  const declaredLookupType = lookupDeclaredTypeInfo2(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,
@@ -77791,11 +78565,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.`,
@@ -77843,7 +78617,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",
@@ -77983,7 +78757,7 @@ var InterfaceConstructionEnv = class extends Map {
 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;
@@ -78003,10 +78777,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
     );
@@ -78508,6 +79288,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) {
@@ -78693,7 +79587,7 @@ function typeInfoConstructedSuffix(ctx, typeInfo, saved, genericEnv, genericBind
       });
       return null;
     }
-    const argType = csharpTypeInfoValueType(
+    const argType = csharpGenericArgumentType(
       ctx,
       argInfo,
       true,
@@ -79429,24 +80323,29 @@ function pointerOwnershipForStorage(storage) {
       return "asset";
   }
 }
+function tupleMemberTypeInfo(ctx, member) {
+  const elements = [];
+  for (const [index, id] of member.elementMemberIds.entries()) {
+    const descriptor = resolveMemberById(ctx, id, "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 required = isRequiredMember(member);
   if (isMemberGenericBase(member))
     return genericParamTypeInfo2(ctx, member.genericParamId, required);
-  if (isMemberTupleBase(member)) {
-    const elements = [];
-    for (const [index, id] of member.elementMemberIds.entries()) {
-      const descriptor = resolveMemberById(ctx, id, "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, elements };
-  }
+  if (isMemberTupleBase(member)) return tupleMemberTypeInfo(ctx, member);
   const slotType = classSlotTypeInfo(ctx, member, required);
   if (slotType !== null) return slotType;
   if (isMemberLookupBase(member)) {
@@ -79491,9 +80390,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);
   }