@neocompose/cli 0.81.5 → 0.82.0

package/dist/test-worker.mjs

@@ -1492,6 +1492,7 @@ var MemberKind = /* @__PURE__ */ ((MemberKind7) => {
   MemberKind7[MemberKind7["NSAction"] = 26] = "NSAction";
   MemberKind7[MemberKind7["Variant"] = 27] = "Variant";
   MemberKind7[MemberKind7["Set"] = 28] = "Set";
+  MemberKind7[MemberKind7["Reference"] = 29] = "Reference";
   return MemberKind7;
 })(MemberKind || {});
 
@@ -1508,7 +1509,7 @@ var TAXONOMY = {
   [6 /* List */]: [1 /* Direct */, BINDABLE, "collection", null, 12],
   [7 /* Class */]: [1 /* Direct */, BINDABLE, "class", null, 14],
   [8 /* Enum */]: [1 /* Direct */, BINDABLE, "core", null, 15],
-  [9 /* Lookup */]: [1 /* Direct */, STORED, "collection", null, 16],
+  [9 /* Lookup */]: [1 /* Direct */, BINDABLE, "collection", null, 16],
   [10 /* NSProperty */]: [1 /* Direct */, 0, "code", null, 18],
   [11 /* Sprite */]: [1 /* Direct */, BINDABLE, "core", null, 24],
   [12 /* Audio */]: [1 /* Direct */, BINDABLE, "core", null, 25],
@@ -1557,7 +1558,8 @@ var TAXONOMY = {
     21
   ],
   [27 /* Variant */]: [1 /* Direct */, STORED, "world", null, 22],
-  [28 /* Set */]: [1 /* Direct */, BINDABLE, "collection", null, 13]
+  [28 /* Set */]: [1 /* Direct */, BINDABLE, "collection", null, 13],
+  [29 /* Reference */]: [0 /* None */, 0, null, null, null]
 };
 var ALL_MEMBER_KINDS = [
   0 /* Null */,
@@ -1588,7 +1590,8 @@ var ALL_MEMBER_KINDS = [
   25 /* NSDelegate */,
   26 /* NSAction */,
   27 /* Variant */,
-  28 /* Set */
+  28 /* Set */,
+  29 /* Reference */
 ];
 var DIRECT_MEMBER_KINDS = ALL_MEMBER_KINDS.filter(
   (kind) => TAXONOMY[kind][0] === 1 /* Direct */
@@ -1662,7 +1665,9 @@ var AUTOMATIC_MEMBER_DISTRIBUTION = {
   /** Fixed class, variant, and optional bound-row ids. */
   [27 /* Variant */]: 1 /* Packed */,
   /** Entry count grows with content. */
-  [28 /* Set */]: { sparse: "entryCount" }
+  [28 /* Set */]: { sparse: "entryCount" },
+  /** Type-info only; a stored reference is a Lookup. */
+  [29 /* Reference */]: "valueLess"
 };
 function memberKindSupportsDistribution(kind) {
   return memberKindSupportsStorage(kind);
@@ -2152,6 +2157,9 @@ var NEO_LOOKUP_VARIANT_TYPE_NAME = "NeoLookupVariant";
 var NEO_VARIANT_SCOPE_NAME = "Variants";
 var NEO_VARIANT_RESERVED_NAME = "Base";
 var NEO_VARIANT_FOLDER_PATH_SEPARATOR = "/";
+function isNeoVariantTypeName(name) {
+  return name === NEO_VARIANT_TYPE_NAME || name === NEO_LOOKUP_VARIANT_TYPE_NAME;
+}
 var NEOSCRIPT_OPERATORS = [
   "===",
   "!==",
@@ -2349,6 +2357,15 @@ var NEOSCRIPT_DELEGATE_MAX_PARAMETERS = 16;
 function delegateArityMessage(provided) {
   return `Type 'NeoDelegate' expects a return type followed by up to ${NEOSCRIPT_DELEGATE_MAX_PARAMETERS} parameter types, but ${provided} type arguments were provided.`;
 }
+function referenceNamesCodeMessage(reference) {
+  return `${reference} names code. A reference names a stored value, and a delegate or action member is already an indirection.`;
+}
+function referenceNeedsValueTypeMessage(reference) {
+  return `${reference} needs a value type.`;
+}
+function referenceNamesObjectMessage(reference, required) {
+  return `${reference} names an object, which is never null. Write Reference<${required}>? for a reference that may be unset.`;
+}
 function neoScriptRegistryReferenceType(entryTypeName) {
   for (const definition of Object.values(REGISTRY_ENTRY_TYPES)) {
     if (definition.entryType === entryTypeName) return definition.refType;
@@ -3101,7 +3118,19 @@ function isNSTypeInfo(value) {
   return isNSTypeInfoInternal(value, /* @__PURE__ */ new Set());
 }
 function isNSTypeInfoInternal(value, ancestors) {
-  return isNSTypeInfoUnknown(value) || isNSTypeInfoPrimitive(value) || isNSTypeInfoAsset(value) || isNSTypeInfoVector(value) || isNSTypeInfoColor(value) || isNSTypeInfoDialogueLookup(value) || isNSTypeInfoClassInternal(value, ancestors) || isNSTypeInfoInterface(value) || isNSTypeInfoGenericParam(value) || isNSTypeInfoDelegateInternal(value, ancestors) || isNSTypeInfoActionInternal(value, ancestors) || isNSTypeInfoCollectionInternal(value, ancestors) || isNSTypeInfoLookupInternal(value, ancestors) || isNSTypeInfoEnum(value);
+  return isNSTypeInfoUnknown(value) || isNSTypeInfoPrimitive(value) || isNSTypeInfoAsset(value) || isNSTypeInfoVector(value) || isNSTypeInfoColor(value) || isNSTypeInfoDialogueLookup(value) || isNSTypeInfoClassInternal(value, ancestors) || isNSTypeInfoInterface(value) || isNSTypeInfoGenericParam(value) || isNSTypeInfoDelegateInternal(value, ancestors) || isNSTypeInfoActionInternal(value, ancestors) || isNSTypeInfoCollectionInternal(value, ancestors) || isNSTypeInfoLookupInternal(value, ancestors) || isNSTypeInfoEnum(value) || isNSTypeInfoReferenceInternal(value, ancestors);
+}
+function isNSTypeInfoReferenceInternal(value, ancestors) {
+  if (!isNSTypeInfoBase(value)) return false;
+  if (value.type !== 29 /* Reference */) return false;
+  const reference = value;
+  if (ancestors.has(reference)) return false;
+  ancestors.add(reference);
+  try {
+    return isNSTypeInfoInternal(reference.targetTypeInfo, ancestors);
+  } finally {
+    ancestors.delete(reference);
+  }
 }
 function isNSArgumentTypeInfo(value) {
   return isRequiredType(value, isNSArgumentTypeInfoUnsafe);
@@ -3336,6 +3365,17 @@ function isNSPointerForceUnwrap(value) {
   if (v?.type !== "forceUnwrap" /* forceUnwrap */) return false;
   return isNSPointer(v.pointer);
 }
+function isNSPointerRowOf(value) {
+  const v = value;
+  if (v?.type !== "rowOf" /* rowOf */) return false;
+  if (v.typeInfo !== void 0 && !isNSTypeInfo(v.typeInfo)) return false;
+  return isNSPointer(v.place);
+}
+function isNSPointerDeref(value) {
+  const v = value;
+  if (v?.type !== "deref" /* deref */) return false;
+  return isNSPointer(v.pointer);
+}
 function isNSPointerIsCheck(value) {
   const v = value;
   if (v?.type !== "isCheck" /* isCheck */) return false;
@@ -3494,7 +3534,7 @@ function isNSPointerMemberTarget(value) {
   return isNSCallReceiver(pointer.receiver);
 }
 function isNSPointer(value) {
-  return isNSPointerReference(value) || isNSPointerVariable(value) || isNSPointerStaticMember(value) || isNSPointerValue(value) || isNSPointerOperation(value) || isNSPointerFunction(value) || isNSPointerKeyOf(value) || isNSPointerListLiteral(value) || isNSPointerDictLiteral(value) || isNSPointerForceUnwrap(value) || isNSPointerIsCheck(value) || isNSPointerCallGetter(value) || isNSPointerCoalesce(value) || isNSPointerConditional(value) || isNSPointerMemberTarget(value) || isNSPointerDelegateClosure(value) || isNSPointerObjectInitializer(value) || isNSPointerToBool(value) || isNSPointerStringify(value) || isNSPointerTileConvert(value) || isNSPointerCallFunction(value) || isNSPointerCallDelegate(value) || isNSPointerCallAction(value) || isNSPointerVariant(value) || isNSPointerFunctionErrorCheck(value);
+  return isNSPointerReference(value) || isNSPointerVariable(value) || isNSPointerStaticMember(value) || isNSPointerValue(value) || isNSPointerOperation(value) || isNSPointerFunction(value) || isNSPointerKeyOf(value) || isNSPointerListLiteral(value) || isNSPointerDictLiteral(value) || isNSPointerForceUnwrap(value) || isNSPointerRowOf(value) || isNSPointerDeref(value) || isNSPointerIsCheck(value) || isNSPointerCallGetter(value) || isNSPointerCoalesce(value) || isNSPointerConditional(value) || isNSPointerMemberTarget(value) || isNSPointerDelegateClosure(value) || isNSPointerObjectInitializer(value) || isNSPointerToBool(value) || isNSPointerStringify(value) || isNSPointerTileConvert(value) || isNSPointerCallFunction(value) || isNSPointerCallDelegate(value) || isNSPointerCallAction(value) || isNSPointerVariant(value) || isNSPointerFunctionErrorCheck(value);
 }
 function isNSPointers(value) {
   return Array.isArray(value) && value.every(isNSPointer);
@@ -4268,6 +4308,9 @@ function typeInfosInvariantlyEqual(left, right) {
       (argument2, index) => typeInfosInvariantlyEqual(argument2, right.argumentTypes[index])
     );
   }
+  if (left.type === 29 /* Reference */ && right.type === 29 /* Reference */) {
+    return typeInfosInvariantlyEqual(left.targetTypeInfo, right.targetTypeInfo);
+  }
   if (left.type === 9 /* Lookup */ && right.type === 9 /* Lookup */) {
     if (left.collectionMemberId !== right.collectionMemberId) return false;
     if ((left.collectionValueId ?? void 0) !== (right.collectionValueId ?? void 0))
@@ -4277,6 +4320,45 @@ function typeInfosInvariantlyEqual(left, right) {
   return true;
 }
 
+// ../packages/models/src/members/reference-kind.ts
+function referenceKindCategory(target) {
+  if (target.type === NS_TYPE_UNKNOWN) return "ineligible" /* Ineligible */;
+  switch (target.type) {
+    case 7 /* Class */:
+    case 22 /* Interface */:
+    case 6 /* List */:
+    case 28 /* Set */:
+    case 5 /* Dictionary */:
+    case 9 /* Lookup */:
+      return "handle" /* Handle */;
+    case 1 /* Bool */:
+    case 2 /* Int */:
+    case 3 /* String */:
+    case 4 /* Float */:
+    case 20 /* Decimal */:
+    case 8 /* Enum */:
+    case 11 /* Sprite */:
+    case 12 /* Audio */:
+    case 14 /* Vector2 */:
+    case 15 /* Vector2Int */:
+    case 16 /* Vector3 */:
+    case 17 /* Vector3Int */:
+    case 19 /* Color */:
+    case 18 /* DialogueLookup */:
+    case 29 /* Reference */:
+      return "slot" /* Slot */;
+    case 21 /* Generic */:
+      return "deferred" /* Deferred */;
+    case 0 /* Null */:
+    case 25 /* NSDelegate */:
+    case 26 /* NSAction */:
+      return "ineligible" /* Ineligible */;
+  }
+}
+function isReferenceEligibleTypeInfo(target) {
+  return referenceKindCategory(target) !== "ineligible" /* Ineligible */;
+}
+
 // ../packages/models/src/members/structured-leaf-fields.ts
 var STRUCTURED_LEAF_FIELDS = {
   [11 /* Sprite */]: [
@@ -4770,7 +4852,7 @@ function isMemberTypeLookupBase(value) {
 }
 function isLookupTargetTypeInfo(value) {
   if (!isNSTypeInfo(value)) return false;
-  return value.type === 7 /* Class */ || value.type === 21 /* Generic */;
+  return isReferenceEligibleTypeInfo(value);
 }
 function isMemberLookupBase(value) {
   return isMemberCollectionLookupBase(value) || isMemberTypeLookupBase(value);
@@ -8878,6 +8960,15 @@ var GENERIC_WORLD_SYSTEM_CLASS_KINDS = new Set(
 var WORLD_SYSTEM_ALL_KINDS = new Set(
   WORLD_SYSTEM_CLASS_DEFINITIONS.map((definition) => definition.worldKind)
 );
+function requireWorldSystemClassDefinition(worldKind) {
+  const definition = WORLD_SYSTEM_CLASS_DEFINITION_BY_KIND.get(worldKind);
+  if (definition === void 0) {
+    throw new Error(
+      `World system kind "${worldKind}" has no class definition in the generated table.`
+    );
+  }
+  return definition;
+}
 var WORLD_SYSTEM_SCHEMA_FIELD_SITES_BY_MEMBER_ID = new Map(
   WORLD_SYSTEM_CLASS_DEFINITIONS.flatMap(
     (definition) => (definition.schemaFields ?? []).map(
@@ -9305,6 +9396,12 @@ function mapGenericTypeInfo(typeInfo, close) {
       entryTypeInfo: mapGenericTypeInfo(typeInfo.entryTypeInfo, close)
     };
   }
+  if (typeInfo.type === 29 /* Reference */) {
+    return {
+      ...typeInfo,
+      targetTypeInfo: mapGenericTypeInfo(typeInfo.targetTypeInfo, close)
+    };
+  }
   if (typeInfo.type === 7 /* Class */) {
     const typeArguments = typeInfo.typeArguments;
     if (typeArguments === void 0) return typeInfo;
@@ -9374,6 +9471,19 @@ function typeInfoFromArgumentSignature(signature) {
       entryTypeInfo: { ...enumTypeInfo, required: true }
     } : enumTypeInfo;
   }
+  if (signature.type === 9 /* Lookup */) {
+    const lookupSignature = signature;
+    const reference = {
+      type: 29 /* Reference */,
+      required: lookupSignature.multiselect || lookupSignature.required,
+      targetTypeInfo: lookupSignature.target
+    };
+    return lookupSignature.multiselect ? {
+      type: 9 /* Lookup */,
+      required: lookupSignature.required,
+      entryTypeInfo: reference
+    } : reference;
+  }
   if (signature.type === 6 /* List */) {
     const listSignature = signature;
     return {
@@ -9516,6 +9626,19 @@ function typeArgumentSignatureOfMember(member, env, members, seen = /* @__PURE__
       )
     };
   }
+  if (isMemberLookupBase(resolved)) {
+    if (resolved.declaredTypeInfo === void 0) {
+      throw new Error(
+        `typeArgumentSignatureOfMember: Lookup "${resolved.name}" has no declared type; a type argument can't be a Lookup bound to a collection.`
+      );
+    }
+    return {
+      type: 9 /* Lookup */,
+      required,
+      multiselect: isMultiSelectionMember(resolved),
+      target: substituteNestedTypeInfo(resolved.declaredTypeInfo, env, members)
+    };
+  }
   if (isMemberStringBase(resolved)) {
     return {
       type: 3 /* String */,
@@ -9608,6 +9731,12 @@ function signaturesEqual(a, b) {
     if (ad.keyEnumId !== bd.keyEnumId) return false;
     return signaturesEqual(ad.entry, bd.entry);
   }
+  if (a.type === 9 /* Lookup */ && b.type === 9 /* Lookup */) {
+    const al = a;
+    const bl = b;
+    if (al.multiselect !== bl.multiselect) return false;
+    return typeInfosInvariantlyEqual(al.target, bl.target);
+  }
   if (a.type === 25 /* NSDelegate */ && b.type === 25 /* NSDelegate */) {
     return typeInfosInvariantlyEqual(
       a,
@@ -13199,6 +13328,56 @@ function classImplementsInterface(classId, interfaceId, classes, interfaces) {
   );
 }
 
+// ../packages/models/src/neoscript/type-info-compatibility.ts
+function isTypeInfoAssignable(from, to, context) {
+  if (to.type === NS_TYPE_UNKNOWN) return true;
+  if (from.type === NS_TYPE_UNKNOWN) return false;
+  if (from.required === false && to.required === true) return false;
+  if (from.type === 0 /* Null */) return to.required === false;
+  if (from.type === 29 /* Reference */) {
+    if (to.type === 29 /* Reference */ && typeInfosInvariantlyEqual(from.targetTypeInfo, to.targetTypeInfo)) {
+      return true;
+    }
+    return isTypeInfoAssignable(referenceReadTypeInfo(from), to, context);
+  }
+  if (to.type === 29 /* Reference */) return false;
+  if (from.type === 2 /* Int */ && to.type === 4 /* Float */) {
+    return true;
+  }
+  if (from.type === 7 /* Class */ && to.type === 7 /* Class */) {
+    if (from.classId === to.classId) {
+      return typeInfosInvariantlyEqual({ ...from, required: to.required }, to);
+    }
+    return resolveInheritanceChain(from.classId, context.classes).some(
+      (schemaClass2) => schemaClass2.id === to.classId
+    );
+  }
+  if (from.type === 7 /* Class */ && to.type === 22 /* Interface */) {
+    return classImplementsInterface(
+      from.classId,
+      to.interfaceId,
+      context.classes,
+      context.interfaces
+    );
+  }
+  if (from.type === 22 /* Interface */ && to.type === 22 /* Interface */) {
+    return resolveInterfaceClosure(from.interfaceId, context.interfaces).some(
+      (neoInterface) => neoInterface.id === to.interfaceId
+    );
+  }
+  if (from.type === 22 /* Interface */ || to.type === 22 /* Interface */) {
+    return false;
+  }
+  const normalizedFrom = { ...from, required: to.required };
+  return typeInfosInvariantlyEqual(normalizedFrom, to);
+}
+function referenceReadTypeInfo(reference) {
+  return {
+    ...reference.targetTypeInfo,
+    required: reference.required && reference.targetTypeInfo.required
+  };
+}
+
 // ../packages/models/src/neoscript/function-type-arguments.ts
 function functionGenericParamsOf(member) {
   const kind = getField(member, "kind");
@@ -13301,6 +13480,9 @@ function bindTypeInfoList(list, table) {
   }
   return bound ?? list;
 }
+function functionGenericParamName(typeInfo, params) {
+  return params?.[typeInfo.index]?.name ?? `T${typeInfo.index}`;
+}
 
 // ../packages/manifest/src/value-comparison.ts
 function isObjectRecord(value) {
@@ -13412,6 +13594,11 @@ function compiledConstructionTypeMembers(members, bodies, projectId) {
         };
       } else if (type.type === 26 /* NSAction */) {
         return { argumentTypes: namedArguments(type.argumentTypes) };
+      } else if (type.type === 29 /* Reference */) {
+        return {
+          kind: 9 /* Lookup */,
+          declaredTypeInfo: type.targetTypeInfo
+        };
       } else if (type.type === 22 /* Interface */ || type.type === 9 /* Lookup */ || type.type === 18 /* DialogueLookup */) {
         return null;
       } else {
@@ -13616,6 +13803,60 @@ function neoScriptMemberLookupType(type) {
   }
   return nullable2 && current.nullable !== true ? { ...current, nullable: true } : current;
 }
+function isNeoScriptHandleReferenceTarget(target, isValueType) {
+  switch (target.kind) {
+    case "list":
+    case "set":
+    case "dictionary":
+      return true;
+    case "named":
+      return !isValueType(target);
+    case "typeParameter": {
+      const bound = neoScriptMemberLookupType(target);
+      return bound.kind === "named" && !isValueType(bound);
+    }
+    default:
+      return false;
+  }
+}
+function neoScriptReferenceType(target, nullable2, isValueType) {
+  if (isNeoScriptHandleReferenceTarget(target, isValueType)) {
+    return nullable2 ? { ...target, nullable: true } : target;
+  }
+  return { kind: "reference", target, ...nullable2 ? { nullable: nullable2 } : {} };
+}
+function isNeoScriptValueNamedType(type, project) {
+  const declared = project.typeById.get(type.typeId);
+  if (declared === void 0) return false;
+  return declared.kind === "enum" || isNeoVariantTypeName(declared.name);
+}
+var NON_VALUE_PRIMITIVES = /* @__PURE__ */ new Set([
+  "null",
+  "unknown",
+  "void"
+]);
+function neoScriptReferenceTargetError(target, project) {
+  const reference = `Reference<${formatType(target, project)}>`;
+  if (target.kind === "delegate" || target.kind === "action") {
+    return referenceNamesCodeMessage(reference);
+  }
+  if (target.kind === "primitive") {
+    return NON_VALUE_PRIMITIVES.has(target.name) ? referenceNeedsValueTypeMessage(reference) : null;
+  }
+  if (target.kind !== "named" || target.nullable !== true) return null;
+  if (isNeoScriptValueNamedType(target, project)) return null;
+  const required = formatType({ ...target, nullable: false }, project);
+  return referenceNamesObjectMessage(reference, required);
+}
+function neoScriptReadType(type) {
+  let current = type;
+  let nullable2 = type.nullable === true;
+  while (current.kind === "reference") {
+    current = current.target;
+    nullable2 ||= current.nullable === true;
+  }
+  return nullable2 && current.nullable !== true ? { ...current, nullable: true } : current;
+}
 function neoScriptParameterIsOmittable(parameter3) {
   return parameter3.defaultValue !== void 0;
 }
@@ -13944,6 +14185,19 @@ function isNeoScriptTypeAssignable(source, target, project) {
       return expected !== void 0 && isNeoScriptTypeAssignable(parameter3, expected, project) && isNeoScriptTypeAssignable(expected, parameter3, project);
     });
   }
+  if (source.kind !== "reference" && target.kind === "reference" && isNeoScriptHandleReferenceTarget(
+    target.target,
+    (named) => isNeoScriptValueNamedType(named, project)
+  )) {
+    return isNeoScriptTypeAssignable(
+      source,
+      { ...target.target, nullable: target.nullable === true },
+      project
+    );
+  }
+  if (source.kind === "reference" && target.kind === "reference") {
+    return isNeoScriptTypeAssignable(source.target, target.target, project) && isNeoScriptTypeAssignable(target.target, source.target, project);
+  }
   if (source.kind === "action" && target.kind === "action") {
     return source.parameterTypes.length === target.parameterTypes.length && source.parameterTypes.every((parameter3, index) => {
       const expected = target.parameterTypes[index];
@@ -14017,6 +14271,8 @@ function formatType(type, project) {
       return `Dictionary<${formatType(type.keyType, project)}, ${formatType(type.valueType, project)}>${suffix}`;
     case "typeParameter":
       return `${type.name}${suffix}`;
+    case "reference":
+      return `Reference<${formatType(type.target, project)}>${suffix}`;
     case "delegate":
       return `NeoDelegate<${[
         formatType(type.returnType, project),
@@ -14379,14 +14635,16 @@ var UncompiledInitializerRuntimeError = class extends NSGetterRuntimeError {
 
 // ../packages/neoscript-runtime/src/neoscript/runtime-set.ts
 var RuntimeSet = class {
-  constructor(source, reference, enumEntries) {
+  constructor(source, reference, enumEntries, slotReferences = null) {
     this.source = source;
     this.reference = reference;
     this.enumEntries = enumEntries;
+    this.slotReferences = slotReferences;
   }
   source;
   reference;
   enumEntries;
+  slotReferences;
   entries = /* @__PURE__ */ new Map();
   validations = /* @__PURE__ */ new Map();
   snapshot;
@@ -14432,6 +14690,21 @@ var RuntimeSet = class {
   }
 };
 
+// ../packages/neoscript-runtime/src/neoscript/slot-reference.ts
+var NSSlotReference = class {
+  constructor(targetId, place, target, memberId) {
+    this.targetId = targetId;
+    this.place = place;
+    this.target = target;
+    this.memberId = memberId;
+    Object.freeze(this);
+  }
+  targetId;
+  place;
+  target;
+  memberId;
+};
+
 // ../packages/neoscript-runtime/src/listener-write-index.ts
 var indexes = /* @__PURE__ */ new WeakMap();
 var empty = /* @__PURE__ */ new Map();
@@ -16771,6 +17044,339 @@ function readClassMember(args) {
   return { kind: "missing" };
 }
 
+// ../packages/models/src/members/reference-category.ts
+var variantClassIds;
+function isVariantClassId(classId) {
+  variantClassIds ??= /* @__PURE__ */ new Set([
+    requireWorldSystemClassDefinition(NeoWorldSystemClassKind.Variant).classId,
+    requireWorldSystemClassDefinition(NeoWorldSystemClassKind.LookupVariant).classId
+  ]);
+  return variantClassIds.has(classId);
+}
+var NO_CONSTRAINTS = () => false;
+var CLASS_CONSTRAINED = /* @__PURE__ */ new WeakMap();
+function classConstrainedGenerics(classes) {
+  const cached = CLASS_CONSTRAINED.get(classes);
+  if (cached !== void 0) return cached;
+  const constrained = /* @__PURE__ */ new Set();
+  for (const schemaClass2 of classes) {
+    for (const param of schemaClass2.genericParams ?? []) {
+      if (param.constraint === void 0) continue;
+      if (!isClassGenericConstraint(param.constraint)) continue;
+      constrained.add(`${schemaClass2.id}:${param.id}`);
+    }
+  }
+  const isClassConstrained = (generic) => constrained.has(`${generic.ownerClassId}:${generic.genericParamId}`);
+  CLASS_CONSTRAINED.set(classes, isClassConstrained);
+  return isClassConstrained;
+}
+function referenceCategory(target, isClassConstrained = NO_CONSTRAINTS) {
+  if (target.type === 7 /* Class */ && isVariantClassId(target.classId)) {
+    return "slot" /* Slot */;
+  }
+  if (target.type === 21 /* Generic */ && isClassGenericParamTypeInfo(target) && isClassConstrained(target)) {
+    return "handle" /* Handle */;
+  }
+  return referenceKindCategory(target);
+}
+function referenceExpressionTypeInfo(target, required, isClassConstrained = NO_CONSTRAINTS) {
+  if (referenceCategory(target, isClassConstrained) !== "handle" /* Handle */) {
+    return { type: 29 /* Reference */, required, targetTypeInfo: target };
+  }
+  const handle = expressionTypeInfo(target, isClassConstrained);
+  return { ...handle, required: required && handle.required };
+}
+function expressionTypeInfo(stored, isClassConstrained = NO_CONSTRAINTS) {
+  if (stored.type === NS_TYPE_UNKNOWN) return stored;
+  switch (stored.type) {
+    case 29 /* Reference */:
+      return referenceExpressionTypeInfo(
+        stored.targetTypeInfo,
+        stored.required,
+        isClassConstrained
+      );
+    case 6 /* List */:
+    case 28 /* Set */:
+    case 5 /* Dictionary */:
+    case 9 /* Lookup */:
+      return {
+        ...stored,
+        entryTypeInfo: expressionTypeInfo(
+          stored.entryTypeInfo,
+          isClassConstrained
+        )
+      };
+    default:
+      return stored;
+  }
+}
+
+// ../packages/models/src/neoscript/type-info-format.ts
+function formatTypeInfo(typeInfo, names) {
+  const suffix = typeInfo.required ? "" : "?";
+  switch (typeInfo.type) {
+    case NS_TYPE_UNKNOWN:
+      return `unknown${suffix}`;
+    case NS_TYPE_VOID:
+      return "void";
+    case 2 /* Int */:
+      return `int${suffix}`;
+    case 4 /* Float */:
+      return `float${suffix}`;
+    case 1 /* Bool */:
+      return `bool${suffix}`;
+    case 3 /* String */:
+      return `string${suffix}`;
+    case 11 /* Sprite */:
+      return `SpriteInfo${suffix}`;
+    case 12 /* Audio */:
+      return `AudioClipInfo${suffix}`;
+    case 14 /* Vector2 */:
+      return `Vector2${suffix}`;
+    case 15 /* Vector2Int */:
+      return `Vector2Int${suffix}`;
+    case 16 /* Vector3 */:
+      return `Vector3${suffix}`;
+    case 17 /* Vector3Int */:
+      return `Vector3Int${suffix}`;
+    case 19 /* Color */:
+      return `Color${suffix}`;
+    case 20 /* Decimal */:
+      return `decimal${suffix}`;
+    case 7 /* Class */:
+      return `${names.schemaClassName(typeInfo.classId)}${suffix}`;
+    case 22 /* Interface */:
+      return `${names.interfaceName(typeInfo.interfaceId)}${suffix}`;
+    case 8 /* Enum */:
+      return `${names.enumName(typeInfo.enumId)}${suffix}`;
+    case 6 /* List */:
+      return `List<${formatTypeInfo(typeInfo.entryTypeInfo, names)}>${suffix}`;
+    case 28 /* Set */:
+      return `Set<${formatTypeInfo(typeInfo.entryTypeInfo, names)}>${suffix}`;
+    case 5 /* Dictionary */:
+      return `Dictionary<string, ${formatTypeInfo(typeInfo.entryTypeInfo, names)}>${suffix}`;
+    case 9 /* Lookup */:
+      return `Set<${formatTypeInfo(typeInfo.entryTypeInfo, names)}>${suffix}`;
+    case 18 /* DialogueLookup */:
+      return `NeoDialogueReference${suffix}`;
+    case 29 /* Reference */:
+      return `Reference<${formatTypeInfo(typeInfo.targetTypeInfo, names)}>${suffix}`;
+    case 0 /* Null */:
+      return "null";
+    case 21 /* Generic */:
+      if (!isClassGenericParamTypeInfo(typeInfo)) {
+        return `${functionGenericParamName(typeInfo, names.functionGenericParams)}${suffix}`;
+      }
+      return `Generic<${typeInfo.genericParamId}>${suffix}`;
+    case 25 /* NSDelegate */:
+      return `NeoDelegate<${[
+        formatTypeInfo(typeInfo.returnTypeInfo, names),
+        ...typeInfo.argumentTypes.map(
+          (argument2) => formatTypeInfo(argument2, names)
+        )
+      ].join(", ")}>${suffix}`;
+    case 26 /* NSAction */:
+      return `NeoAction<${typeInfo.argumentTypes.map((argument2) => formatTypeInfo(argument2, names)).join(", ")}>`;
+  }
+}
+
+// ../packages/models/src/variants/variant-member.ts
+function neoVariantSystemClass(classes, lookup = false) {
+  const declared = classes.find(
+    (item) => item.system?.worldKind === (lookup ? NeoWorldSystemClassKind.LookupVariant : NeoWorldSystemClassKind.Variant)
+  );
+  if (declared === void 0) {
+    throw new Error(
+      `Canonical ${lookup ? "NeoLookupVariant" : "NeoVariant"} system class is missing.`
+    );
+  }
+  const targetParamId = declared.genericParams?.[0]?.id;
+  if (targetParamId === void 0) {
+    throw new Error(
+      `Canonical ${lookup ? "NeoLookupVariant" : "NeoVariant"} system class "${declared.id}" is missing its target generic parameter.`
+    );
+  }
+  const valueParamId = declared.genericParams?.[1]?.id;
+  if (lookup && valueParamId === void 0) {
+    throw new Error(
+      `Canonical NeoLookupVariant system class "${declared.id}" is missing its value generic parameter.`
+    );
+  }
+  return {
+    classId: declared.id,
+    targetParamId,
+    ...valueParamId === void 0 ? {} : { valueParamId }
+  };
+}
+function variantMemberDeclaredTypeInfo(member, systemClass) {
+  return {
+    type: 7 /* Class */,
+    required: memberRequirementOf(member) === 1 /* Required */,
+    classId: systemClass.classId,
+    typeArguments: {
+      [systemClass.targetParamId]: member.targetTypeInfo,
+      ...member.valueTypeInfo == null || systemClass.valueParamId === void 0 ? {} : { [systemClass.valueParamId]: member.valueTypeInfo }
+    }
+  };
+}
+
+// ../packages/models/src/members/slot-type-info.ts
+function slotTypeInfo(member, schema, env) {
+  return slotTypeInfoInternal(member, schema, env, /* @__PURE__ */ new Set());
+}
+function slotTypeInfoInternal(member, schema, env, seen) {
+  const resolved = env === void 0 ? resolveMember(member, schema.members) : substituteMember(member, env, schema.members);
+  const id = getField(resolved, "id");
+  if (typeof id === "string" && seen.has(id)) return null;
+  const nextSeen = typeof id === "string" ? /* @__PURE__ */ new Set([...seen, id]) : seen;
+  const byId = memberIndexFor(schema.members);
+  const nested = (memberId) => {
+    const found = byId.get(memberId);
+    return found === void 0 ? null : slotTypeInfoInternal(found, schema, env, nextSeen);
+  };
+  const required = isRequiredMember(resolved);
+  if (isMemberLookupBase(resolved)) {
+    const target = resolved.declaredTypeInfo ?? collectionEntryType(resolved, nested);
+    if (target === null) return null;
+    if (isMultiSelectionMember(resolved)) {
+      return {
+        type: 9 /* Lookup */,
+        required,
+        entryTypeInfo: {
+          type: 29 /* Reference */,
+          required: true,
+          targetTypeInfo: target
+        }
+      };
+    }
+    return { type: 29 /* Reference */, required, targetTypeInfo: target };
+  }
+  switch (resolved.kind) {
+    case 1 /* Bool */:
+    case 2 /* Int */:
+    case 3 /* String */:
+    case 4 /* Float */:
+    case 20 /* Decimal */:
+    case 11 /* Sprite */:
+    case 12 /* Audio */:
+    case 14 /* Vector2 */:
+    case 15 /* Vector2Int */:
+    case 16 /* Vector3 */:
+    case 17 /* Vector3Int */:
+    case 19 /* Color */:
+      return { type: resolved.kind, required };
+    case 18 /* DialogueLookup */:
+      return isMultiSelectionMember(resolved) ? {
+        type: 9 /* Lookup */,
+        required,
+        entryTypeInfo: { type: 18 /* DialogueLookup */, required: true }
+      } : { type: 18 /* DialogueLookup */, required };
+    case 8 /* Enum */: {
+      const enumId = getField(resolved, "enumId");
+      if (typeof enumId !== "string") return null;
+      return isMultiSelectionMember(resolved) ? {
+        type: 9 /* Lookup */,
+        required,
+        entryTypeInfo: { type: 8 /* Enum */, required: true, enumId }
+      } : { type: 8 /* Enum */, required, enumId };
+    }
+    case 6 /* List */:
+    case 28 /* Set */:
+    case 5 /* Dictionary */: {
+      const entryMemberId = getField(resolved, "entryMemberId");
+      if (typeof entryMemberId !== "string") return null;
+      const entryTypeInfo = nested(entryMemberId);
+      if (entryTypeInfo === null) return null;
+      if (resolved.kind === 28 /* Set */) {
+        return { type: 9 /* Lookup */, required, entryTypeInfo };
+      }
+      return {
+        type: resolved.kind,
+        required,
+        entryTypeInfo,
+        ...isMemberDictionaryBase(resolved) && resolved.keyEnumId ? { keyEnumId: resolved.keyEnumId } : {}
+      };
+    }
+    case 7 /* Class */: {
+      if (!isMemberClassBase(resolved)) return null;
+      const typeArguments = {};
+      for (const [paramId, binding] of Object.entries(
+        resolved.classArguments ?? {}
+      )) {
+        if (!isMemberGenericBinding(binding)) continue;
+        const argument2 = nested(binding.memberId);
+        if (argument2 !== null) typeArguments[paramId] = argument2;
+      }
+      return {
+        type: 7 /* Class */,
+        required,
+        classId: resolved.classId,
+        ...Object.keys(typeArguments).length === 0 ? {} : { typeArguments }
+      };
+    }
+    case 27 /* Variant */:
+      if (!isMemberVariantBase(resolved)) return null;
+      return variantMemberDeclaredTypeInfo(
+        resolved,
+        neoVariantSystemClass(schema.classes, resolved.valueTypeInfo != null)
+      );
+    case 21 /* Generic */:
+      if (!isMemberGenericBase(resolved)) return null;
+      return {
+        type: 21 /* Generic */,
+        required: true,
+        ownerClassId: genericOwnerClassId(resolved.genericParamId, schema),
+        genericParamId: resolved.genericParamId
+      };
+    case 0 /* Null */:
+    case 9 /* Lookup */:
+    case 10 /* NSProperty */:
+    case 13 /* Function */:
+    case 23 /* NSFunction */:
+    case 24 /* FunctionRef */:
+    case 25 /* NSDelegate */:
+    case 26 /* NSAction */:
+    case 22 /* Interface */:
+    case 29 /* Reference */:
+      return null;
+  }
+}
+function referenceTargetFits(stored, target, context) {
+  switch (referenceCategory(target)) {
+    case "handle" /* Handle */:
+      if (stored.type === 29 /* Reference */) return false;
+      return isTypeInfoAssignable(stored, target, context);
+    case "slot" /* Slot */:
+      return typeInfosInvariantlyEqual(stored, target);
+    case "deferred" /* Deferred */:
+      return true;
+    case "ineligible" /* Ineligible */:
+      return false;
+  }
+}
+function referenceFitError(subject, targetId, stored, target, names) {
+  const storedName = formatTypeInfo(stored, names);
+  const article = /^[aeiou]/i.test(storedName) ? "an" : "a";
+  return `${subject} target '${targetId}' is ${article} ${storedName}, but the reference declares ${formatTypeInfo(target, names)}.`;
+}
+function collectionEntryType(member, nested) {
+  if (member.collectionMemberId === void 0) return null;
+  const collection = nested(member.collectionMemberId);
+  if (collection === null) return null;
+  if (collection.type !== 6 /* List */ && collection.type !== 9 /* Lookup */ && collection.type !== 5 /* Dictionary */) {
+    return null;
+  }
+  return collection.entryTypeInfo;
+}
+function genericOwnerClassId(genericParamId, schema) {
+  for (const schemaClass2 of schema.classes) {
+    if (schemaClass2.genericParams?.some(({ id }) => id === genericParamId)) {
+      return schemaClass2.id;
+    }
+  }
+  return "";
+}
+
 // ../packages/neoscript-language/src/declared-constructors.ts
 function neoScriptArgumentNameSetKey(names) {
   return [...names].map((name) => name.toLowerCase()).sort().join(",");
@@ -17670,6 +18276,7 @@ function forgetLocalListIndexes(ctx, list) {
 function trackedRowForValueReference(value, ctx) {
   if (value instanceof RuntimeSet) value = value.source;
   if (typeof value !== "object" || value === null) return null;
+  if (value instanceof NSSlotReference) return null;
   const indexes3 = evaluatorIndexes(ctx);
   const indexed = indexes3.rowByValueReference.get(value) ?? indexes3.baseRowByValueReference?.get(value) ?? ctx.vm.databaseVM?.rowForValueReference?.(value) ?? null;
   if (indexed !== null) return indexed;
@@ -17772,6 +18379,7 @@ function evaluatorResolutionCache(ctx) {
       schemaRevision
     ),
     callableSignatureByKey: /* @__PURE__ */ new Map(),
+    collectionLookupTargets: /* @__PURE__ */ new WeakMap(),
     compiledFunctionByMemberId: /* @__PURE__ */ new Map(),
     compiledGetterByMemberId: /* @__PURE__ */ new Map(),
     compiledSetterByMemberId: /* @__PURE__ */ new Map(),
@@ -17931,14 +18539,18 @@ function createdSessionValuesSince(ctx, checkpoint) {
 }
 function exportInitializerCollections(created, writes, ctx) {
   const assignedValues = /* @__PURE__ */ new Set();
+  const mutatedIds = /* @__PURE__ */ new Set();
   for (const write of writes) {
+    const destination = write.resolvedDestination;
+    if (destination !== void 0 && "containerValueId" in destination)
+      mutatedIds.add(destination.containerValueId);
     if (write.kind === "assign" && write.valueId === void 0 && typeof write.value === "object" && write.value !== null) {
       assignedValues.add(write.value);
     }
   }
   const candidates = /* @__PURE__ */ new Set();
   for (const row of created) {
-    if (assignedValues.has(row.value) || Array.isArray(row.value) && row.value.length > 0 && ctx.__unorderedListProjections?.byContainerId.has(row.id)) {
+    if (assignedValues.has(row.value) || row.classId === void 0 && mutatedIds.has(row.id) || Array.isArray(row.value) && row.value.length > 0 && ctx.__unorderedListProjections?.byContainerId.has(row.id)) {
       candidates.add(row.id);
     }
   }
@@ -17953,7 +18565,7 @@ function exportInitializerCollections(created, writes, ctx) {
     if (isMemberEntryCollectionBase(member) && listKindOf(member) === 1 /* Unordered */) {
       return { ...row, value: [] };
     }
-    if (!assignedValues.has(row.value)) return row;
+    if (!assignedValues.has(row.value) && !mutatedIds.has(row.id)) return row;
     const values = [];
     const declarations = /* @__PURE__ */ new Map();
     const genericEnv = runtimeGenericEnvForValueRow(row, ctx, /* @__PURE__ */ new Set());
@@ -17969,7 +18581,7 @@ function exportInitializerCollections(created, writes, ctx) {
       createdValues: values,
       createdById: /* @__PURE__ */ new Map(),
       storageKeyDeclarations: declarations,
-      collectionEntriesAreReferences: false,
+      collectionEntriesAreReferences: assignedValues.has(row.value) ? false : void 0,
       collectionOwnerId: row.id
     });
     const encoded = { ...row, value: materialized.value };
@@ -18321,7 +18933,8 @@ function withEvaluationRuntime(ctx, writes) {
       constructionTimestamp: Date.now(),
       ownedValueAttachments: /* @__PURE__ */ new Map(),
       constructionStack: [],
-      openConstructions: /* @__PURE__ */ new Map()
+      openConstructions: /* @__PURE__ */ new Map(),
+      detachedRowIds: /* @__PURE__ */ new Set()
     },
     __indexes: ctx.__executionState === void 0 || ctx.__valueOverlay === void 0 ? void 0 : ctx.__indexes
   };
@@ -18602,18 +19215,19 @@ function finalizeConstructorAllocations(ctx, returnValue, ownsInvocationState, r
         return;
       }
       if (!Array.isArray(row.value)) return;
-      for (const childId of row.value) {
-        if (typeof childId === "string") scanOwnedRow(childId, entryMember);
-      }
+      for (const entry of row.value) scanOwnedEntry(entry, entryMember);
       return;
     }
     if (member !== null && isMemberDictionaryBase(member) && isOwnedRecord(row.value)) {
       const entryMember = evalMemberById(ctx.vm, member.entryMemberId);
-      for (const childId of Object.values(row.value)) {
-        if (typeof childId === "string") scanOwnedRow(childId, entryMember);
-      }
+      for (const entry of Object.values(row.value))
+        scanOwnedEntry(entry, entryMember);
     }
   };
+  const scanOwnedEntry = (entry, entryMember) => {
+    if (typeof entry === "string") scanOwnedRow(entry, entryMember);
+    else scanReturnedValue(entry, void 0);
+  };
   const scannedReturnReferences = /* @__PURE__ */ new Set();
   const scanReturnedValue = (value, typeInfo) => {
     if (typeof value === "object" && value !== null) {
@@ -18938,7 +19552,11 @@ function executeCompiledFunction(action, ctx, args, allowFallthroughReturn, runt
   for (let index = 0; index < filledArgs.length; index += 1) {
     const parameter3 = action.parameters[index + 2];
     const runtimeTypeInfo = runtimeArgumentTypes[index];
-    const value2 = asDeclaredRuntimeSet(filledArgs[index], runtimeTypeInfo, ctx);
+    const value2 = asDeclaredRuntimeSet(
+      restoreExportedReferences(filledArgs[index], runtimeTypeInfo, ctx),
+      runtimeTypeInfo,
+      ctx
+    );
     if (!runtimeValueMatchesType(value2, runtimeTypeInfo, ctx)) {
       throw new NSGetterRuntimeError(
         `NSFunction argument ${index + 1} does not match its declared runtime type.`
@@ -19370,39 +19988,107 @@ function evalInstructions(instructions, scope, ctx, options) {
             );
             break;
           }
-          const destination = validateAssignmentTarget(
-            ins.target.pointer,
+          let target = ins.target;
+          let destination;
+          if (target.pointer.type === "deref" /* deref */) {
+            ({ target, destination } = writeThroughTarget(
+              target,
+              evalPointer(target.pointer.pointer, scope, ctx),
+              ctx
+            ));
+          }
+          destination = validateAssignmentTarget(
+            target.pointer,
             scope,
-            ctx
+            ctx,
+            destination
           );
-          const member = assignmentTargetMember(
-            ins.target.pointer,
+          let member = assignmentTargetMember(
+            target.pointer,
             scope,
             ctx,
             destination
           );
-          const lookupAssignment = member !== null && isMemberLookupBase(member);
-          if (lookupAssignment) {
-            value = encodeLookupInitializerSelection(member, value, [], ctx);
+          const through = genericSlotReference(member, destination, value, ctx);
+          if (through !== null) {
+            ({ target, destination } = writeThroughTarget(
+              target,
+              through,
+              ctx
+            ));
+            destination = validateAssignmentTarget(
+              target.pointer,
+              scope,
+              ctx,
+              destination
+            );
+            member = assignmentTargetMember(
+              target.pointer,
+              scope,
+              ctx,
+              destination
+            );
+          }
+          assertStoredClosureCaptures(
+            member,
+            target.pointer,
+            destination,
+            value,
+            ctx
+          );
+          const lookupMember = member !== null && isMemberLookup(member) ? member : null;
+          if (lookupMember !== null) {
+            materializeReferencedSlots(value, ctx);
+            const holder = destination === void 0 ? null : trackedRowForValueReference(destination.receiver, ctx);
+            const lookupTarget = lookupTargetTypeInfo(
+              lookupMember,
+              holder,
+              ctx
+            );
+            const selection = encodeLookupInitializerSelection(
+              lookupMember,
+              value,
+              [],
+              ctx,
+              lookupTarget
+            );
+            assertStoredReferenceTargets(
+              lookupMember,
+              lookupTarget,
+              slotStorage(target.pointer, lookupMember.id, holder, ctx),
+              selection,
+              ctx
+            );
+            value = selection;
           }
-          let targetTypeInfo = ins.target.typeInfo;
-          if (lookupAssignment && targetTypeInfo.type !== 9 /* Lookup */ && targetTypeInfo.type !== 18 /* DialogueLookup */) {
-            targetTypeInfo = member.collectionMemberId === void 0 ? {
+          let targetTypeInfo = target.typeInfo;
+          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 ? {
               type: 9 /* Lookup */,
               required: targetTypeInfo.required,
-              entryTypeInfo: targetTypeInfo
+              entryTypeInfo
             } : {
               type: 9 /* Lookup */,
               required: targetTypeInfo.required,
-              entryTypeInfo: targetTypeInfo,
-              collectionMemberId: member.collectionMemberId,
-              collectionValueId: member.collectionValueId
+              entryTypeInfo,
+              collectionMemberId: lookupMember.collectionMemberId,
+              collectionValueId: lookupMember.collectionValueId
             };
           }
+          if (isTypeInfoWithEntries(targetTypeInfo)) {
+            value = keptCollectionSlotValue(
+              target.pointer,
+              targetTypeInfo,
+              destination,
+              value,
+              ctx
+            );
+          }
           const assignedReferenceValueId = targetTypeInfo.type === 7 /* Class */ || targetTypeInfo.type === 6 /* List */ || targetTypeInfo.type === 28 /* Set */ || targetTypeInfo.type === 5 /* Dictionary */ ? findKnownRowIdByValueReference(value, ctx) : null;
           if (!bindOmittedConstantSlot(destination, member, value, ctx)) {
             applyOverlayAssignment(
-              ins.target.pointer,
+              target.pointer,
               targetTypeInfo,
               value,
               scope,
@@ -19411,20 +20097,20 @@ function evalInstructions(instructions, scope, ctx, options) {
             );
           }
           const unorderedReplacement = assignedReferenceValueId === null && member !== null && isMemberEntryCollectionBase(member) && listKindOf(member) === 1 /* Unordered */ && Array.isArray(value) ? unorderedReplacementProjection(
-            ins.target.pointer,
+            target.pointer,
             destination,
             scope,
             ctx
           ) : null;
           options.writes.push({
             kind: "assign",
-            target: targetTypeInfo === ins.target.typeInfo ? ins.target : { ...ins.target, typeInfo: targetTypeInfo },
+            target: targetTypeInfo === target.typeInfo ? target : { ...target, typeInfo: targetTypeInfo },
             value: unorderedReplacement ?? value,
             ...targetTypeInfo.type === 7 /* Class */ || targetTypeInfo.type === 6 /* List */ || targetTypeInfo.type === 28 /* Set */ || targetTypeInfo.type === 5 /* Dictionary */ ? {
               valueId: value === null || value === void 0 ? void 0 : assignedReferenceValueId ?? void 0
             } : {},
             ...resolvedDestinationFieldsForAssign(
-              ins.target.pointer,
+              target.pointer,
               scope,
               ctx,
               destination
@@ -19786,7 +20472,7 @@ function readNeoScriptChangeListenerValue(slot, ctx) {
     throw new NSGetterRuntimeError(
       `OnChanged cannot read '${slot.owner.id}/${slot.memberId}'.`
     );
-  return result.value;
+  return readThroughReference(result.value, ctx);
 }
 function resolveNeoScriptChangeListenerHandler(slot, target, ctx) {
   const raw = evalMemberById(ctx.vm, target.memberId);
@@ -20065,7 +20751,7 @@ function applyOverlayAssignment(target, targetTypeInfo, value, scope, ctx, desti
         "Stored construction replay cannot assign persisted static values."
       );
     }
-    applyOverlayStaticAssignment(target.memberId, value, ctx);
+    applyOverlayStaticAssignment(target.memberId, targetTypeInfo, value, ctx);
     return;
   }
   if (target.type !== "keyOf" /* keyOf */) {
@@ -20091,6 +20777,7 @@ function applyOverlayAssignment(target, targetTypeInfo, value, scope, ctx, desti
           `${parentId}[${index}]`,
           ctx
         );
+        noteDetachedRow(receiver[index], referenceValueId, ctx);
       }
       receiver[index] = referenceValueId;
       recordWrittenEntry(receiver, index, true, ctx);
@@ -20125,6 +20812,7 @@ function applyOverlayAssignment(target, targetTypeInfo, value, scope, ctx, desti
         `${parentId}.${stringKey}`,
         ctx
       );
+      noteDetachedRow(object[stringKey], referenceValueId, ctx);
     }
     object[stringKey] = referenceValueId;
     if (!field) recordWrittenEntry(object, stringKey, true, ctx);
@@ -20133,10 +20821,100 @@ function applyOverlayAssignment(target, targetTypeInfo, value, scope, ctx, desti
   }
   if (collectionReferences(object, ctx) === 0 /* RowIds */ && replaceEntryRowValue(object, object[stringKey], value, targetTypeInfo, ctx))
     return;
+  if (field && targetTypeInfo.type === 7 /* Class */)
+    noteDetachedRow(object[stringKey], value, ctx);
   object[stringKey] = value;
   if (!field) recordWrittenEntry(object, stringKey, false, ctx);
   invalidateEvaluatorIndexes(ctx, receiver);
 }
+function keptCollectionSlotValue(target, targetTypeInfo, destination, value, ctx) {
+  const sourceId = findKnownRowIdByValueReference(value, ctx);
+  if (sourceId === null) return value;
+  const slot = collectionSlotRow(target, destination, ctx);
+  if (slot === null) return value;
+  if (slot.id === sourceId) return value;
+  const source = evalValueById(
+    ctx,
+    sourceId,
+    ctx.__runtimeSessionValues,
+    ctx.__valueOverlay
+  );
+  if (source === null) return value;
+  const entryTypeInfo = typeInfoContainsGeneric2(targetTypeInfo.entryTypeInfo) ? substituteRuntimeTypeInfo(
+    targetTypeInfo.entryTypeInfo,
+    runtimeGenericEnvForValueRow(slot, ctx, /* @__PURE__ */ new Set()),
+    ctx
+  ) : targetTypeInfo.entryTypeInfo;
+  return copiedCollectionContents(source.value, entryTypeInfo, slot.id, ctx);
+}
+function collectionSlotRow(target, destination, ctx) {
+  let slotId = null;
+  if (target.type === "staticMember" /* staticMember */) {
+    const member = evalMemberById(ctx.vm, target.memberId);
+    slotId = member === null ? null : staticBindingTargetId(member, ctx);
+  } else if (destination !== void 0) {
+    const { receiver, key } = destination;
+    if (typeof receiver !== "object" || receiver === null) return null;
+    const entryKey = Array.isArray(receiver) ? Number(key) : String(key);
+    if (!isReferenceEntry(collectionReferences(receiver, ctx), entryKey))
+      return null;
+    slotId = Reflect.get(receiver, entryKey);
+  }
+  if (typeof slotId !== "string") return null;
+  return evalValueById(
+    ctx,
+    slotId,
+    ctx.__runtimeSessionValues,
+    ctx.__valueOverlay
+  );
+}
+function copiedCollectionContents(source, entryTypeInfo, slotId, ctx) {
+  const list = Array.isArray(source);
+  const copy = list ? [] : {};
+  const references = /* @__PURE__ */ new Set();
+  forEachRawCollectionEntry(source, ctx, ({ raw, key, valueId }) => {
+    let entry = raw;
+    if (valueId !== null) {
+      const row = evalValueById(
+        ctx,
+        valueId,
+        ctx.__runtimeSessionValues,
+        ctx.__valueOverlay
+      );
+      if (row !== null && isClassEntryRow(row)) {
+        assertOwnedValueAttachable(
+          valueId,
+          { identity: `value:${slotId}:entry:${key}`, label: slotId },
+          `${slotId}[${key}]`,
+          ctx
+        );
+        references.add(key);
+      } else if (row !== null) {
+        const stored = readRowValue(row, ctx);
+        entry = isTypeInfoWithEntries(entryTypeInfo) && stored !== null ? copiedCollectionContents(
+          stored,
+          entryTypeInfo.entryTypeInfo,
+          slotId,
+          ctx
+        ) : deepClonePlainData(stored);
+      }
+    }
+    if (Array.isArray(copy)) copy.push(entry);
+    else copy[String(key)] = entry;
+    return 0 /* Continue */;
+  });
+  const cache = unorderedListProjectionCache(ctx);
+  if (Array.isArray(copy))
+    cache.referenceEntryIndexesByArray.set(copy, references);
+  else cache.referenceEntryKeysByRecord.set(copy, references);
+  return copy;
+}
+function isClassEntryRow(row) {
+  return typeof row.classId === "string" && !isVariantClassId(row.classId);
+}
+function isTypeInfoWithEntries(typeInfo) {
+  return typeInfo.type === 6 /* List */ || typeInfo.type === 28 /* Set */ || typeInfo.type === 5 /* Dictionary */;
+}
 function replaceEntryRowValue(receiver, existing, value, targetTypeInfo, ctx) {
   if (typeof existing !== "string") return false;
   const row = evalValueById(
@@ -20176,7 +20954,7 @@ function replaceRowValue(row, value, receiver, ctx) {
   if (ctx.__valueOverlay instanceof LazyValueOverlay)
     indexes3.overlayRevision = ctx.__valueOverlay.revision;
 }
-function applyOverlayStaticAssignment(memberId, value, ctx) {
+function applyOverlayStaticAssignment(memberId, targetTypeInfo, value, ctx) {
   const member = evalMemberById(ctx.vm, memberId);
   if (member === null || !isStaticMember(member)) {
     throw new NSGetterRuntimeError(
@@ -20185,19 +20963,23 @@ function applyOverlayStaticAssignment(memberId, value, ctx) {
   }
   const bindings = writableStaticBindingMap(member, ctx);
   ctx.__getterSubscriptions?.noteStaticBinding(member.id);
+  const currentId = staticBindingTargetId(member, ctx);
+  const resolved = resolveMember(member, ctx.vm.members);
+  const classStatic = isMemberClassBase(resolved);
   if (value === null || value === void 0) {
     if (isRequiredMember(member)) {
       throw new NSGetterRuntimeError(
         `Required static member '${member.name}' cannot be cleared.`
       );
     }
-    bindings.set(member.id, null);
-    return;
+    if (classStatic || currentId === null) {
+      if (classStatic) noteDetachedRow(currentId, null, ctx);
+      bindings.set(member.id, null);
+      return;
+    }
   }
-  const currentId = staticBindingTargetId(member, ctx);
-  const resolved = resolveMember(member, ctx.vm.members);
-  const referenceAssignment = isMemberClassBase(resolved) || isMemberWithEntries(resolved);
-  const trackedId = findKnownRowIdByValueReference(value, ctx);
+  const referenceAssignment = classStatic || isMemberWithEntries(resolved);
+  const trackedId = currentId === null || classStatic ? findKnownRowIdByValueReference(value, ctx) : null;
   if (referenceAssignment && trackedId !== null) {
     assertOwnedValueAttachable(
       trackedId,
@@ -20208,27 +20990,40 @@ function applyOverlayStaticAssignment(memberId, value, ctx) {
       `${member.name} static binding`,
       ctx
     );
+    if (classStatic) noteDetachedRow(currentId, trackedId, ctx);
     bindings.set(member.id, trackedId);
     return;
   }
-  if (!referenceAssignment && currentId !== null) {
-    const row2 = evalValueById(
+  if (!classStatic && currentId !== null) {
+    const row = evalValueById(
       ctx,
       currentId,
       ctx.__runtimeSessionValues,
       ctx.__valueOverlay
     );
-    if (row2 === null) {
+    if (row === null) {
       throw new NSGetterRuntimeError(
         `Static member '${member.name}' is bound to missing value '${currentId}'.`
       );
     }
-    observeValueWrite(ctx, row2);
-    row2.value = value;
-    row2.updatedAt = Date.now();
+    observeValueWrite(ctx, row);
+    keepAssignedCollectionValues(value, targetTypeInfo, ctx);
+    row.value = value ?? null;
+    row.updatedAt = Date.now();
+    updateUnorderedListProjectionAfterAssignment(row, value, ctx);
     invalidateEvaluatorIndexes(ctx);
     return;
   }
+  bindMaterializedStatic(
+    member,
+    resolved,
+    value,
+    classStatic ? void 0 : virtualValueId(member.id, "static"),
+    ctx
+  );
+}
+function bindMaterializedStatic(member, resolved, value, rowId, ctx) {
+  const bindings = writableStaticBindingMap(member, ctx);
   const createdValues = [];
   const createdById = /* @__PURE__ */ new Map();
   const storageKeyDeclarations = /* @__PURE__ */ new Map();
@@ -20242,7 +21037,8 @@ function applyOverlayStaticAssignment(memberId, value, ctx) {
     ctx,
     createdValues,
     createdById,
-    storageKeyDeclarations
+    storageKeyDeclarations,
+    rowId
   });
   stampCreatedValuesMapKey(createdValues, null);
   applyDeclaredStorageKeyOverrides({
@@ -20309,6 +21105,405 @@ function bindOmittedConstantSlot(destination, member, value, ctx) {
 function touchUnknown(_ins) {
   void _ins;
 }
+function writeThroughTarget(target, reference, ctx) {
+  if (reference === null || reference === void 0) {
+    throw new NSGetterRuntimeError(
+      "Cannot write through a null reference. Check it for null first."
+    );
+  }
+  if (!(reference instanceof NSSlotReference)) {
+    throw new CorruptNeoScriptIRError(
+      `A write through a reference reached a ${typeof reference}, not a reference.`
+    );
+  }
+  let place = reference.place;
+  if (place === null) {
+    const row = referencedRow(reference, ctx);
+    place = slotPlaceOfRow(row, ctx);
+    if (place === null) return entryWriteTarget(target, row, reference, ctx);
+  }
+  const slotMember = evalMemberById(ctx.vm, place.memberId);
+  if (slotMember === null) {
+    throw new NSGetterRuntimeError(
+      `${referenceSubject(reference.memberId, ctx)} names a slot of missing member '${place.memberId}'.`
+    );
+  }
+  if (place.kind === 1 /* Static */) {
+    if (isReadOnlyMember(slotMember))
+      throw readonlyTargetError(slotMember, reference, ctx);
+    const storage = effectiveStaticStorage(slotMember.id, ctx);
+    if (storage === 1 /* Immutable */) throw assetTargetError();
+    return {
+      target: {
+        pointer: { type: "staticMember" /* staticMember */, memberId: slotMember.id },
+        typeInfo: target.typeInfo,
+        writability: storage === 2 /* Save */ ? "save" /* Save */ : "session" /* Session */
+      }
+    };
+  }
+  if (reference.place !== null) assertPlaceAttached(reference, place, ctx);
+  const { owner, key } = place;
+  if (isReadOnlyMember(slotMember) && ctx.__executionState?.openConstructions.has(owner) !== true) {
+    throw readonlyTargetError(slotMember, reference, ctx);
+  }
+  const ownerId = findKnownRowIdByValueReference(owner, ctx);
+  if (ownerId === null) {
+    throw new NSGetterRuntimeError(
+      `${referenceSubject(reference.memberId, ctx)} names '${key}' of a value with no stored row.`
+    );
+  }
+  if (constructorArgumentStorage(ownerId, ctx) === 1 /* Immutable */)
+    throw assetTargetError();
+  materializeSlotRow(place, reference.targetId, ctx);
+  return {
+    target: {
+      pointer: {
+        type: "keyOf" /* keyOf */,
+        memberId: slotMember.id,
+        keyOf: {
+          pointer: { type: "reference" /* reference */, valueId: ownerId },
+          key: {
+            type: "value" /* value */,
+            value: { typeInfo: STRING_TYPE_INFO, value: key }
+          }
+        }
+      },
+      typeInfo: target.typeInfo,
+      writability: "runtime" /* Runtime */
+    },
+    destination: { receiver: owner, key }
+  };
+}
+var STRING_TYPE_INFO = {
+  type: 3 /* String */,
+  required: true
+};
+var INT_TYPE_INFO = { type: 2 /* Int */, required: true };
+function assetTargetError() {
+  return new NSGetterRuntimeError(
+    "Cannot write runtime-owned target because its value is Asset-owned."
+  );
+}
+function readonlyTargetError(slotMember, reference, ctx) {
+  const writer = reference.memberId === null ? "a reference" : referenceSubject(reference.memberId, ctx);
+  return new NSGetterRuntimeError(
+    `\`${qualifiedMemberLabel(slotMember.id, ctx)}\` is readonly, so ${writer} can't write it.`
+  );
+}
+function entryWriteTarget(target, row, reference, ctx) {
+  const subject = referenceSubject(reference.memberId, ctx);
+  const containerId = evaluatorParentLinks(evaluatorIndexes(ctx), row.id).find(
+    (link) => link.key === ""
+  )?.parentId;
+  if (containerId === void 0) {
+    throw new NSGetterRuntimeError(
+      `${subject} target '${row.id}' is not held by a member slot.`
+    );
+  }
+  const containerRow = evalValueById(
+    ctx,
+    containerId,
+    ctx.__runtimeSessionValues,
+    ctx.__valueOverlay
+  );
+  const containerPlace = containerRow === null ? null : slotPlaceOfRow(containerRow, ctx);
+  if (containerPlace === null) {
+    throw new NSGetterRuntimeError(
+      `${subject} target '${row.id}' is an entry of '${containerId}', which no member slot holds.`
+    );
+  }
+  if (evalMemberById(ctx.vm, containerPlace.memberId)?.kind === 28 /* Set */) {
+    throw new NSGetterRuntimeError(
+      `${subject} names an entry of a Set, which can't be written in place. Remove it and add the new value.`
+    );
+  }
+  const collection = readSlot(containerPlace, ctx);
+  let key;
+  forEachRawCollectionEntry(collection, ctx, (entry) => {
+    if (entry.valueId !== row.id) return 0 /* Continue */;
+    key = entry.key;
+    return 1 /* Break */;
+  });
+  if (key === void 0) {
+    throw danglingReferenceError(reference.memberId, row.id, ctx);
+  }
+  return {
+    target: {
+      pointer: {
+        type: "keyOf" /* keyOf */,
+        memberId: memberForValueRow(row, ctx)?.id,
+        keyOf: {
+          pointer: { type: "reference" /* reference */, valueId: containerId },
+          key: {
+            type: "value" /* value */,
+            value: {
+              typeInfo: typeof key === "number" ? INT_TYPE_INFO : STRING_TYPE_INFO,
+              value: key
+            }
+          }
+        }
+      },
+      typeInfo: target.typeInfo,
+      writability: "runtime" /* Runtime */
+    },
+    destination: { receiver: collection, key }
+  };
+}
+function referencedRow(reference, ctx) {
+  const row = evalValueById(
+    ctx,
+    reference.targetId,
+    ctx.__runtimeSessionValues,
+    ctx.__valueOverlay
+  );
+  if (row === null || inDetachedRow(row.id, ctx)) {
+    throw danglingReferenceError(reference.memberId, reference.targetId, ctx);
+  }
+  assertReferenceFits(reference, row, ctx);
+  return row;
+}
+function inDetachedRow(rowId, ctx) {
+  const detached = ctx.__executionState?.detachedRowIds;
+  if (detached === void 0 || detached.size === 0) return false;
+  const pending = [rowId];
+  const seen = /* @__PURE__ */ new Set();
+  for (let cursor = 0; cursor < pending.length; cursor += 1) {
+    const id = pending[cursor];
+    if (id === void 0 || seen.has(id)) continue;
+    seen.add(id);
+    let rowOwned = false;
+    for (const owner of currentOwnedValueAttachments(id, ctx)) {
+      if (!owner.identity.startsWith("value:")) continue;
+      rowOwned = true;
+      pending.push(owner.label);
+    }
+    if (!rowOwned && detached.has(id) && activeStaticBindingRoot(id, ctx) === null) {
+      return true;
+    }
+  }
+  return false;
+}
+function assertPlaceAttached(reference, place, ctx) {
+  if (place.kind !== 0 /* Member */) return;
+  const detached = ctx.__executionState?.detachedRowIds;
+  if (detached === void 0 || detached.size === 0) return;
+  const ownerId = findKnownRowIdByValueReference(place.owner, ctx);
+  if (ownerId !== null && inDetachedRow(ownerId, ctx)) {
+    throw danglingReferenceError(reference.memberId, reference.targetId, ctx);
+  }
+}
+function noteDetachedRow(previous, replacement, ctx) {
+  if (typeof previous !== "string" || previous === replacement) return;
+  ctx.__executionState?.detachedRowIds.add(previous);
+}
+function slotPlaceOfRow(row, ctx) {
+  const member = memberForValueRow(row, ctx);
+  if (member === null) return null;
+  if (isStaticMember(member) && staticBindingTargetId(member, ctx) === row.id) {
+    return { kind: 1 /* Static */, memberId: member.id };
+  }
+  for (const link of evaluatorParentLinks(evaluatorIndexes(ctx), row.id)) {
+    if (link.key === "") continue;
+    const parent = evalValueById(
+      ctx,
+      link.parentId,
+      ctx.__runtimeSessionValues,
+      ctx.__valueOverlay
+    );
+    const owner = parent?.value;
+    if (typeof owner !== "object" || owner === null || Array.isArray(owner)) {
+      continue;
+    }
+    return {
+      kind: 0 /* Member */,
+      owner,
+      key: link.key,
+      memberId: member.id
+    };
+  }
+  return null;
+}
+function materializeSlotRow(place, targetId, ctx) {
+  const current = getField(place.owner, place.key);
+  if (typeof current === "string") return;
+  if (evalValueById(
+    ctx,
+    targetId,
+    ctx.__runtimeSessionValues,
+    ctx.__valueOverlay
+  ) !== null) {
+    return;
+  }
+  const ownerId = findKnownRowIdByValueReference(place.owner, ctx);
+  if (ownerId !== null && constructorArgumentStorage(ownerId, ctx) === 1 /* Immutable */) {
+    throw new NSGetterRuntimeError(
+      `Cannot bind missing member '${place.key}' on an immutable parent.`
+    );
+  }
+  ctx.beforeValueAllocation?.();
+  const read = readRecordKey(place.owner, place.key, place.memberId, ctx);
+  const owner = trackedRowForValueReference(place.owner, ctx);
+  const member = slotLookupMember(
+    evalMemberById(ctx.vm, place.memberId),
+    owner,
+    ctx
+  );
+  const value = member === null ? read : encodeLookupInitializerSelection(
+    member,
+    read,
+    [],
+    ctx,
+    lookupTargetTypeInfo(member, owner, ctx)
+  );
+  const row = {
+    ...buildNewValue(ctx.vm.project.id, { value: value ?? null }),
+    id: targetId
+  };
+  registerRuntimeSessionValue(ctx, row);
+  Reflect.set(place.owner, place.key, targetId);
+  invalidateEvaluatorIndexes(ctx, place.owner);
+}
+function slotLookupMember(member, owner, ctx) {
+  if (member === null) return null;
+  if (isMemberLookup(member)) return member;
+  if (member.kind !== 21 /* Generic */ || owner === null) return null;
+  const bound = substituteMember(
+    member,
+    runtimeGenericEnvForValueRow(owner, ctx),
+    ctx.vm.members
+  );
+  return isMemberLookup(bound) ? bound : null;
+}
+function genericSlotReference(member, destination, value, ctx) {
+  if (member === null || !isMemberLookup(member)) return null;
+  if (destination === void 0) return null;
+  if (member.declaredTypeInfo === void 0) return null;
+  if (!typeInfoContainsGeneric2(member.declaredTypeInfo)) return null;
+  if (value instanceof NSSlotReference) return null;
+  const owner = trackedRowForValueReference(destination.receiver, ctx);
+  const target = lookupTargetTypeInfo(member, owner, ctx);
+  if (referenceCategory(target) !== "slot" /* Slot */) return null;
+  if (typeof destination.receiver !== "object" || destination.receiver === null)
+    return null;
+  const current = readRecordKey(
+    destination.receiver,
+    String(destination.key),
+    member.id,
+    ctx
+  );
+  if (current instanceof NSSlotReference) return current;
+  throw new NSGetterRuntimeError(
+    `Cannot write through Reference \`${qualifiedMemberLabel(member.id, ctx)}\`, because it names no target.`
+  );
+}
+function materializeReferencedSlots(value, ctx) {
+  const entries = value instanceof RuntimeSet ? value.toArray() : Array.isArray(value) ? value : [value];
+  for (const entry of entries) {
+    if (!(entry instanceof NSSlotReference)) continue;
+    const place = entry.place;
+    if (place?.kind === 0 /* Member */) {
+      materializeSlotRow(place, entry.targetId, ctx);
+    }
+    if (place?.kind === 1 /* Static */) {
+      materializeStaticSlotRow(place.memberId, entry.targetId, ctx);
+    }
+  }
+}
+function materializeStaticSlotRow(memberId, targetId, ctx) {
+  const member = evalMemberById(ctx.vm, memberId);
+  if (member === null) return;
+  if (staticBindingTargetId(member, ctx) !== null) return;
+  bindMaterializedStatic(
+    member,
+    resolveMember(member, ctx.vm.members),
+    null,
+    targetId,
+    ctx
+  );
+}
+function assertStoredReferenceTargets(member, target, holderStorage, selection, ctx) {
+  if (selection === null || selection.length === 0) return;
+  const slot = referenceCategory(target) === "slot" /* Slot */;
+  for (const targetId of selection) {
+    if (slot) {
+      const row = evalValueById(
+        ctx,
+        targetId,
+        ctx.__runtimeSessionValues,
+        ctx.__valueOverlay
+      );
+      if (row === null) throw danglingReferenceError(member.id, targetId, ctx);
+      assertReferenceFits(
+        new NSSlotReference(targetId, null, target, member.id),
+        row,
+        ctx
+      );
+    }
+    assertReferenceLifetime(
+      `Reference \`${qualifiedMemberLabel(member.id, ctx)}\``,
+      holderStorage,
+      targetId,
+      ctx
+    );
+  }
+}
+function assertStoredClosureCaptures(member, pointer, destination, value, ctx) {
+  const memberId = getField(member, "id");
+  if (typeof memberId !== "string") return;
+  if (!isNSDelegateClosureValue(value)) return;
+  const holder = destination === void 0 ? null : trackedRowForValueReference(destination.receiver, ctx);
+  const holderStorage = slotStorage(pointer, memberId, holder, ctx);
+  if (holderStorage === null) return;
+  const subject = `Closure \`${qualifiedMemberLabel(memberId, ctx)}\``;
+  const visit = (captured) => {
+    if (captured instanceof NSSlotReference) {
+      assertReferenceLifetime(subject, holderStorage, captured.targetId, ctx);
+    } else if (captured instanceof RuntimeSet) {
+      captured.toArray().forEach(visit);
+    } else if (Array.isArray(captured)) {
+      captured.forEach(visit);
+    } else if (isNSDelegateClosureValue(captured)) {
+      captured.captures?.forEach(visit);
+    } else if (isPlainRecord(captured)) {
+      Object.values(captured).forEach(visit);
+    }
+  };
+  value.captures?.forEach(visit);
+}
+function slotStorage(pointer, memberId, holder, ctx) {
+  if (pointer.type === "staticMember" /* staticMember */) {
+    return effectiveStorageForMemberId(pointer.memberId, ctx);
+  }
+  if (holder === null) return null;
+  const owner = constructorArgumentStorage(holder.id, ctx);
+  if (owner === null) return null;
+  return childEffectiveStorage(
+    effectiveStorageResolver(ctx).declaredStorage(memberId),
+    owner
+  );
+}
+var STORE_LIFETIME = {
+  [1 /* Immutable */]: 4,
+  [5 /* User */]: 3,
+  [2 /* Save */]: 2,
+  [3 /* Session */]: 1
+};
+var STORE_NAMES = {
+  [1 /* Immutable */]: "Immutable",
+  [5 /* User */]: "User",
+  [2 /* Save */]: "Save",
+  [3 /* Session */]: "Session"
+};
+function assertReferenceLifetime(subject, holderStorage, targetId, ctx) {
+  if (holderStorage === null) return;
+  if (ctx.vm.databaseVM?.hasStoredValueId?.(targetId) === true) return;
+  const targetStorage = constructorArgumentStorage(targetId, ctx);
+  if (targetStorage === null) return;
+  if (STORE_LIFETIME[targetStorage] >= STORE_LIFETIME[holderStorage]) return;
+  throw new NSGetterRuntimeError(
+    `${subject} is ${STORE_NAMES[holderStorage]}-stored and can't name '${targetId}', which lives only in the ${STORE_NAMES[targetStorage]}.`
+  );
+}
 function validateAssignmentTarget(target, scope, ctx, destination) {
   if (target.type === "staticMember" /* staticMember */) {
     const member = evalMemberById(ctx.vm, target.memberId);
@@ -20594,7 +21789,7 @@ function evalCollectionMutationInstruction(ins, scope, ctx, options) {
   if (ins.mutation === "Add" /* Add */ && isArrayCollection(targetValue) && unorderedContainerValueId !== null && !isLookupSet && findKnownRowIdByValueReference(args[0], ctx) === null) {
     overlayArgs[0] = createUnorderedScalarProjectionEntry(
       unorderedContainerValueId,
-      args[0],
+      args[0] instanceof NSSlotReference ? [args[0].targetId] : args[0],
       ctx
     );
   }
@@ -20625,6 +21820,7 @@ function evalCollectionMutationInstruction(ins, scope, ctx, options) {
       );
     }
   }
+  const removableRowIds = isLookupSet || ins.reference === true ? null : removableEntryRowIds(targetValue, ins.mutation, overlayArgs, ctx);
   const removedIndex = applyLocalCollectionMutation(
     targetValue,
     ins.mutation,
@@ -20640,6 +21836,13 @@ function evalCollectionMutationInstruction(ins, scope, ctx, options) {
     removedIndex,
     ctx
   );
+  if (removableRowIds !== null) {
+    const key = Array.isArray(targetValue) ? removedIndex : String(args[0]);
+    for (const [entryKey, rowId] of removableRowIds) {
+      if (ins.mutation === "Clear" /* Clear */ || entryKey === key)
+        noteDetachedRow(rowId, null, ctx);
+    }
+  }
   if (writesEntry && !(targetValue instanceof RuntimeSet)) {
     const writtenAsRowId = attachedValueId !== null || unorderedContainerValueId !== null;
     if (Array.isArray(targetValue))
@@ -20784,6 +21987,7 @@ function flushRuntimeSets(ctx) {
 }
 function exportRuntimeSetValue(value, ctx, seen = /* @__PURE__ */ new Map()) {
   if (typeof value !== "object" || value === null) return value;
+  if (value instanceof NSSlotReference) return value.targetId;
   if (seen.has(value)) return seen.get(value);
   if (value instanceof RuntimeSet) {
     seen.set(value, value.source);
@@ -20818,7 +22022,7 @@ function exportRuntimeSetValue(value, ctx, seen = /* @__PURE__ */ new Map()) {
     seen.set(value, result);
     return result;
   }
-  if (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null) {
+  if (isPlainRecord(value)) {
     const copy = {};
     seen.set(value, copy);
     let changed = false;
@@ -20833,12 +22037,53 @@ function exportRuntimeSetValue(value, ctx, seen = /* @__PURE__ */ new Map()) {
   }
   return value;
 }
+function isPlainRecord(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
 function isArrayCollection(value) {
   return Array.isArray(value) || value instanceof RuntimeSet;
 }
+function restoreExportedReferences(value, type, ctx) {
+  if (type.type === 29 /* Reference */) {
+    return typeof value === "string" && holdsSlotReference(type) ? new NSSlotReference(value, null, type.targetTypeInfo, null) : value;
+  }
+  if (type.type !== 6 /* List */ && type.type !== 5 /* Dictionary */ || !holdsSlotReference(type.entryTypeInfo) || trackedRowForValueReference(value, ctx) !== null)
+    return value;
+  if (Array.isArray(value)) {
+    return value.map(
+      (entry) => restoreExportedReferences(entry, type.entryTypeInfo, ctx)
+    );
+  }
+  if (!isPlainRecord(value)) return value;
+  const restored = {};
+  for (const [key, entry] of Object.entries(value))
+    setOwnField(
+      restored,
+      key,
+      restoreExportedReferences(entry, type.entryTypeInfo, ctx)
+    );
+  return restored;
+}
+function holdsSlotReference(type) {
+  if (type.type === 29 /* Reference */)
+    return referenceCategory(type.targetTypeInfo) === "slot" /* Slot */;
+  if (type.type === 6 /* List */ || type.type === 5 /* Dictionary */)
+    return holdsSlotReference(type.entryTypeInfo);
+  return false;
+}
 function asDeclaredRuntimeSet(value, type, ctx) {
   if (type.type !== 9 /* Lookup */ || !Array.isArray(value) || storedSetEntryMember(value, ctx) !== null)
     return value;
+  if (type.entryTypeInfo.type === 29 /* Reference */) {
+    return slotReferenceSet(
+      value,
+      type.entryTypeInfo.targetTypeInfo,
+      null,
+      ctx
+    );
+  }
   const entry = type.entryTypeInfo.type;
   return runtimeSet(
     value,
@@ -20848,6 +22093,7 @@ function asDeclaredRuntimeSet(value, type, ctx) {
   );
 }
 function runtimeSetKey(value, set, ctx) {
+  if (set.slotReferences !== null) return slotReferenceKey(value);
   if (set.enumEntries && Array.isArray(value) && value.length === 1)
     value = value[0];
   return toSetEntryKey(value, null, set.reference, ctx);
@@ -20870,6 +22116,32 @@ function runtimeSet(array2, reference, enumEntries, ctx) {
   (ctx.__dirtyRuntimeSets ??= /* @__PURE__ */ new Set()).add(set);
   return set;
 }
+function slotReferenceSet(array2, target, memberId, ctx) {
+  const sets = ctx.__runtimeSets ??= /* @__PURE__ */ new WeakMap();
+  const existing = sets.get(array2);
+  if (existing !== void 0) return existing;
+  const set = new RuntimeSet(array2, true, false, { target, memberId });
+  for (const entry of array2) set.add(slotReferenceKey(entry), entry, false);
+  sets.set(array2, set);
+  (ctx.__dirtyRuntimeSets ??= /* @__PURE__ */ new Set()).add(set);
+  return set;
+}
+function slotReferenceKey(entry) {
+  if (entry instanceof NSSlotReference) return entry.targetId;
+  if (typeof entry === "string") return entry;
+  throw new NSGetterRuntimeError(
+    `A set of references holds a ${typeof entry} entry, not a value id.`
+  );
+}
+function slotReferenceEntry(raw, references) {
+  if (raw instanceof NSSlotReference) return raw;
+  return new NSSlotReference(
+    slotReferenceKey(raw),
+    null,
+    references.target,
+    references.memberId
+  );
+}
 function storedSetEntryMatch(raw, reference, entryMember, ctx) {
   const byIdentity = entryMember.kind === 7 /* Class */;
   const row = byIdentity || !reference || typeof raw !== "string" ? null : evalValueById(ctx, raw, ctx.__runtimeSessionValues, ctx.__valueOverlay);
@@ -20923,6 +22195,30 @@ function findStoredSetEntry(set, value, entryMember, ctx) {
   if (key === null) return null;
   return storedSetEntries(set, entryMember, ctx).get(key) ?? null;
 }
+function removableEntryRowIds(targetValue, mutation, args, ctx) {
+  if (mutation !== "Remove" /* Remove */ && mutation !== "RemoveAt" /* RemoveAt */ && mutation !== "Clear" /* Clear */) {
+    return null;
+  }
+  if (typeof targetValue !== "object" || targetValue === null) return null;
+  const references = collectionReferences(targetValue, ctx);
+  const rowIds = /* @__PURE__ */ new Map();
+  const keep = (key, entry) => {
+    if (typeof entry === "string" && isReferenceEntry(references, key))
+      rowIds.set(key, entry);
+  };
+  if (mutation === "RemoveAt" /* RemoveAt */) {
+    const index = Number(args[0]);
+    keep(index, Reflect.get(targetValue, index));
+  } else if (mutation === "Remove" /* Remove */ && !Array.isArray(targetValue)) {
+    const key = String(args[0]);
+    keep(key, Reflect.get(targetValue, key));
+  } else if (Array.isArray(targetValue)) {
+    for (const [index, entry] of targetValue.entries()) keep(index, entry);
+  } else {
+    for (const [key, entry] of Object.entries(targetValue)) keep(key, entry);
+  }
+  return rowIds;
+}
 function applyLocalCollectionMutation(targetValue, mutation, args, ctx, unique = false, resolveRemovalEntries = false, reference = false) {
   if (targetValue instanceof RuntimeSet) {
     (ctx.__dirtyRuntimeSets ??= /* @__PURE__ */ new Set()).add(targetValue);
@@ -21046,6 +22342,7 @@ function lookupSetSelectionValue(value, typeInfo, ctx) {
     return value[0];
   }
   if (typeof value === "string") return value;
+  if (value instanceof NSSlotReference) return value.targetId;
   return findKnownRowIdByValueReference(value, ctx) ?? value;
 }
 function validateCollectionMutation(targetValue, mutation, args) {
@@ -21117,16 +22414,18 @@ function finiteNumberArg(value, name) {
   throw new NSGetterRuntimeError(`${name} must be a finite number`);
 }
 function effectiveStorageForMemberId(memberId, ctx) {
+  const storages = [
+    ...effectiveStorageResolver(ctx).effectiveStorages(memberId)
+  ];
+  return storages.length === 1 ? storages[0] : null;
+}
+function effectiveStorageResolver(ctx) {
   const cache = evaluatorResolutionCache(ctx);
-  cache.effectiveStorageResolver ??= new EffectiveStorageResolver({
+  return cache.effectiveStorageResolver ??= new EffectiveStorageResolver({
     members: ctx.vm.members,
     classes: ctx.vm.classes,
     rootStorage: buildRootStorageMap(ctx.vm.project)
   });
-  const storages = [
-    ...cache.effectiveStorageResolver.effectiveStorages(memberId)
-  ];
-  return storages.length === 1 ? storages[0] : null;
 }
 function effectiveStaticStorage(memberId, ctx) {
   const storage = effectiveStorageForMemberId(memberId, ctx);
@@ -21196,7 +22495,162 @@ function evalStaticMember(memberId, ctx) {
       `Static member '${member.name}' is bound to missing value '${targetId}'.`
     );
   }
-  return shouldUnwrapSingleLookupValue(member) ? unwrapSingleLookupValue(readRowValue(row, ctx), ctx) : resolveLocalizedRowValueForMember(row, member, ctx);
+  return readLookupSelection(
+    member,
+    resolveLocalizedRowValueForMember(row, member, ctx),
+    row,
+    ctx
+  );
+}
+function evalRowOf(pointer, scope, ctx) {
+  const { place } = pointer;
+  switch (place.type) {
+    case "keyOf" /* keyOf */: {
+      const owner = evalPointer(place.keyOf.pointer, scope, ctx);
+      const key = String(evalPointer(place.keyOf.key, scope, ctx));
+      if (owner === null || owner === void 0) {
+        if (place.optional === true) return null;
+        throw new NSGetterRuntimeError(
+          `Cannot reference '${key}' of ${owner === null ? "null" : "undefined"}.`
+        );
+      }
+      if (typeof owner !== "object" || Array.isArray(owner)) {
+        throw new NSGetterRuntimeError(
+          `Cannot reference '${key}' of a ${Array.isArray(owner) ? "list" : typeof owner}, which has no member slots.`
+        );
+      }
+      const memberId = resolveRuntimeSchemaMember(owner, key, ctx)?.id ?? place.memberId;
+      if (memberId === void 0) {
+        throw new NSGetterRuntimeError(
+          `Cannot reference '${key}', which is not a declared member.`
+        );
+      }
+      if (genericSlotCategory(owner, memberId, ctx) === "handle" /* Handle */) {
+        return readRecordKey(owner, key, memberId, ctx);
+      }
+      return new NSSlotReference(
+        slotTargetId(owner, key, memberId, ctx),
+        { kind: 0 /* Member */, owner, key, memberId },
+        null,
+        null
+      );
+    }
+    case "staticMember" /* staticMember */: {
+      const member = evalMemberById(ctx.vm, place.memberId);
+      if (member === null) {
+        throw new NSGetterRuntimeError(
+          `Static member '${place.memberId}' is missing, so it has no row to reference.`
+        );
+      }
+      return new NSSlotReference(
+        staticBindingTargetId(member, ctx) ?? virtualValueId(member.id, "static"),
+        { kind: 1 /* Static */, memberId: member.id },
+        null,
+        null
+      );
+    }
+    case "reference" /* reference */: {
+      const row = resolveRuntimeReferenceRow(
+        place.valueId,
+        ctx,
+        place.withProvenance === true
+      );
+      return new NSSlotReference(
+        row?.id ?? place.valueId,
+        null,
+        pointer.typeInfo ?? null,
+        null
+      );
+    }
+    default:
+      throw new CorruptNeoScriptIRError(
+        `A row reference names a '${place.type}' pointer, not a member, static, or value id.`
+      );
+  }
+}
+function genericSlotCategory(owner, memberId, ctx) {
+  const member = evalMemberById(ctx.vm, memberId);
+  if (member === null || !isMemberGenericBase(member)) return null;
+  const row = trackedRowForValueReference(owner, ctx);
+  if (row === null) return null;
+  const bound = runtimeTypeInfoForMember(
+    member,
+    runtimeGenericEnvForValueRow(row, ctx),
+    ctx,
+    /* @__PURE__ */ new Set()
+  );
+  return referenceCategory(bound);
+}
+function slotTargetId(owner, key, memberId, ctx) {
+  const ownerId = findKnownRowIdByValueReference(owner, ctx);
+  if (ownerId === null) {
+    throw new NSGetterRuntimeError(
+      `Cannot reference '${key}', because its owner has no stored row.`
+    );
+  }
+  const at2 = getField(owner, key);
+  if (typeof at2 === "string") return at2;
+  const expanded = virtualExpandedRecordForReceiver(owner, ctx);
+  const virtual = expanded === null ? void 0 : getField(expanded, key);
+  if (typeof virtual === "string") return virtual;
+  return virtualValueId(ownerId, memberId);
+}
+function readThroughReference(reference, ctx) {
+  if (!(reference instanceof NSSlotReference)) return reference;
+  if (reference.place !== null) {
+    const row2 = evalValueById(
+      ctx,
+      reference.targetId,
+      ctx.__runtimeSessionValues,
+      ctx.__valueOverlay
+    );
+    if (row2 !== null) assertReferenceFits(reference, row2, ctx);
+    assertPlaceAttached(reference, reference.place, ctx);
+    return readSlot(reference.place, ctx);
+  }
+  const row = referencedRow(reference, ctx);
+  const place = slotPlaceOfRow(row, ctx);
+  return place === null ? resolveValueIfId(row.id, ctx) : readSlot(place, ctx);
+}
+function readSlot(place, ctx) {
+  return place.kind === 0 /* Member */ ? readRecordKey(place.owner, place.key, place.memberId, ctx) : evalStaticMember(place.memberId, ctx);
+}
+function assertReferenceFits(reference, row, ctx) {
+  const target = reference.target;
+  if (target === null) return;
+  const member = memberForValueRow(row, ctx);
+  if (member === null) {
+    throw danglingReferenceError(reference.memberId, row.id, ctx);
+  }
+  const declared = slotTypeInfo(member, ctx.vm);
+  const stored = declared === null || typeInfoContainsGeneric2(declared) ? slotTypeInfo(member, ctx.vm, runtimeGenericEnvForValueRow(row, ctx)) : declared;
+  if (stored === null) {
+    throw new NSGetterRuntimeError(
+      `${referenceSubject(reference.memberId, ctx)} target '${row.id}' is \`${qualifiedMemberLabel(member.id, ctx)}\`, which holds no value.`
+    );
+  }
+  const context = {
+    classes: ctx.vm.classes,
+    interfaces: ctx.vm.interfaces ?? []
+  };
+  if (referenceTargetFits(stored, target, context)) return;
+  throw new NSGetterRuntimeError(
+    referenceFitError(
+      referenceSubject(reference.memberId, ctx),
+      row.id,
+      stored,
+      target,
+      evaluatorTypeNames(ctx)
+    )
+  );
+}
+function evaluatorTypeNames(ctx) {
+  const schema = evaluatorSchemaIndex(ctx);
+  return {
+    schemaClassName: (classId) => schema.class(classId)?.name ?? classId,
+    enumName: (enumId) => schema.enum(enumId)?.name ?? enumId,
+    interfaceName: (interfaceId) => ctx.vm.interfaces?.find(({ id }) => id === interfaceId)?.name ?? interfaceId
+  };
 }
 function evalPointer(pointer, scope, ctx, resultUsage = "value") {
   try {
@@ -21291,6 +22745,13 @@ function evalPointerCore(pointer, scope, ctx, resultUsage = "value") {
       };
     case "staticMember" /* staticMember */:
       return evalStaticMember(pointer.memberId, ctx);
+    case "rowOf" /* rowOf */:
+      return evalRowOf(pointer, scope, ctx);
+    case "deref" /* deref */:
+      return readThroughReference(
+        evalPointer(pointer.pointer, scope, ctx),
+        ctx
+      );
     case "keyOf" /* keyOf */:
       return evalKeyOf(pointer, scope, ctx);
     case "operation" /* operation */:
@@ -22307,6 +23768,9 @@ function substituteRuntimeTypeInfo(typeInfo, env, ctx) {
     )
   };
 }
+function lookupEntryTypeInfo(target, required) {
+  return referenceCategory(target) === "slot" /* Slot */ ? { type: 29 /* Reference */, required, targetTypeInfo: target } : { ...target, required };
+}
 function runtimeTypeInfoForMember(rawMember, env, ctx, seen) {
   if (seen.has(rawMember.id)) {
     throw new NSGetterRuntimeError(
@@ -22393,11 +23857,14 @@ function runtimeTypeInfoForMember(rawMember, env, ctx, seen) {
   }
   if (isMemberLookup(member)) {
     if (member.collectionMemberId === void 0) {
-      const entryTypeInfo2 = {
-        ...substituteRuntimeTypeInfo(member.declaredTypeInfo, env, ctx),
-        required: isMultiSelectionMember(member) ? true : false
-      };
-      return isMultiSelectionMember(member) ? { type: 9 /* Lookup */, required, entryTypeInfo: entryTypeInfo2 } : entryTypeInfo2;
+      const target = substituteRuntimeTypeInfo(
+        member.declaredTypeInfo,
+        env,
+        ctx
+      );
+      const multi = isMultiSelectionMember(member);
+      const entryTypeInfo2 = lookupEntryTypeInfo(target, multi || required);
+      return multi ? { type: 9 /* Lookup */, required, entryTypeInfo: entryTypeInfo2 } : entryTypeInfo2;
     }
     const collection = evalMemberById(ctx.vm, member.collectionMemberId);
     if (collection === null) {
@@ -22416,10 +23883,10 @@ function runtimeTypeInfoForMember(rawMember, env, ctx, seen) {
         `Lookup binding '${member.id}' does not target a collection.`
       );
     }
-    const entryTypeInfo = {
-      ...collectionTypeInfo.entryTypeInfo,
-      required: isMultiSelectionMember(member) ? true : false
-    };
+    const entryTypeInfo = lookupEntryTypeInfo(
+      collectionTypeInfo.entryTypeInfo,
+      isMultiSelectionMember(member) === true || required
+    );
     return isMultiSelectionMember(member) ? {
       type: 9 /* Lookup */,
       required,
@@ -22779,6 +24246,8 @@ function runtimeTypeCheck(value, checkType, ctx, seenCollections = /* @__PURE__
         ctx.vm.interfaces ?? []
       );
     }
+    case 29 /* Reference */:
+      return value instanceof NSSlotReference || typeInfoContainsGeneric2(checkType.targetTypeInfo);
     case 21 /* Generic */:
       if (!isClassGenericParamTypeInfo(checkType)) {
         return runtimeTypeCheck(
@@ -22910,35 +24379,37 @@ function evalKeyOf(pointer, scope, ctx, onDestination) {
     return resolveCollectionEntry(receiver, receiver[idx], idx, ctx);
   }
   if (typeof receiver === "object" && receiver !== null) {
-    const k = String(key);
-    if (k === "Id") {
-      if (receiver === ctx.thisValue && typeof ctx.thisValueRowId === "string") {
-        return ctx.thisValueRowId;
-      }
-      const rowId = findKnownRowIdByValueReference(receiver, ctx);
-      if (rowId) return rowId;
-      throw new NSGetterRuntimeError("Class value has no backing row id.");
-    }
-    const assetMember = resolveAssetRuntimeMember(receiver, k, ctx);
-    if (assetMember.kind === "ok") return assetMember.value;
-    const dispatched = dispatchSchemaMember(receiver, k, ctx);
-    if (dispatched.kind === "ok") return dispatched.value;
-    if (Object.prototype.hasOwnProperty.call(receiver, k)) {
-      const at2 = receiver[k];
-      return typeof at2 === "string" && (pointer.memberId !== void 0 || isReferenceEntry(collectionReferences(receiver, ctx), k)) ? resolveValueIfId(at2, ctx) : at2;
-    }
-    const expanded = virtualExpandedRecordForReceiver(receiver, ctx);
-    if (expanded !== null && Object.prototype.hasOwnProperty.call(expanded, k)) {
-      return resolveValueIfId(expanded[k], ctx);
-    }
-    throw new NSGetterRuntimeError(
-      `Missing key '${k}' on object. Check that the key exists before reading it.`
-    );
+    return readRecordKey(receiver, String(key), pointer.memberId, ctx);
   }
   throw new NSGetterRuntimeError(
     `Cannot index into ${typeof receiver} with key '${String(key)}'`
   );
 }
+function readRecordKey(receiver, k, memberId, ctx) {
+  if (k === "Id") {
+    if (receiver === ctx.thisValue && typeof ctx.thisValueRowId === "string") {
+      return ctx.thisValueRowId;
+    }
+    const rowId = findKnownRowIdByValueReference(receiver, ctx);
+    if (rowId) return rowId;
+    throw new NSGetterRuntimeError("Class value has no backing row id.");
+  }
+  const assetMember = resolveAssetRuntimeMember(receiver, k, ctx);
+  if (assetMember.kind === "ok") return assetMember.value;
+  const dispatched = dispatchSchemaMember(receiver, k, ctx);
+  if (dispatched.kind === "ok") return dispatched.value;
+  if (Object.prototype.hasOwnProperty.call(receiver, k)) {
+    const at2 = receiver[k];
+    return typeof at2 === "string" && (memberId !== void 0 || isReferenceEntry(collectionReferences(receiver, ctx), k)) ? resolveValueIfId(at2, ctx) : at2;
+  }
+  const expanded = virtualExpandedRecordForReceiver(receiver, ctx);
+  if (expanded !== null && Object.prototype.hasOwnProperty.call(expanded, k)) {
+    return resolveValueIfId(expanded[k], ctx);
+  }
+  throw new NSGetterRuntimeError(
+    `Missing key '${k}' on object. Check that the key exists before reading it.`
+  );
+}
 function dispatchSchemaMember(receiver, schemaKey, ctx) {
   if (typeof receiver !== "object" || receiver === null) {
     return { kind: "no-info", matchedMember: false };
@@ -22981,7 +24452,7 @@ function dispatchSchemaMember(receiver, schemaKey, ctx) {
     case "value":
       return {
         kind: "ok",
-        value: resolveValueIfIdForMember(slot.value, member, ctx)
+        value: resolveValueIfIdForMember(slot.value, member, ctx, receiverRow)
       };
     case "null":
       return { kind: "ok", value: null };
@@ -23111,8 +24582,8 @@ function readDeclarationDefault(member, ctx) {
   let value = member.defaultValue.value;
   if (isMemberString(member) && isLocalizedStringMember(member) !== false && typeof value === "string") {
     value = resolveLocalizedTextId(value, ctx);
-  } else if (shouldUnwrapSingleLookupValue(member)) {
-    value = unwrapSingleLookupValue(value, ctx);
+  } else {
+    value = readLookupSelection(member, value, null, ctx);
   }
   return { matched: true, value };
 }
@@ -23182,13 +24653,17 @@ function resolveValueIfId(at2, ctx) {
   if (member !== null && isMemberEntryCollectionBase(member) && listKindOf(member) === 1 /* Unordered */ && Array.isArray(row.value)) {
     return evaluatorUnorderedListEntryIds(row.id, ctx);
   }
-  const value = member === null ? resolveLocalizedRowValue(row, ctx) : resolveLocalizedRowValueForMember(row, member, ctx);
-  return shouldUnwrapSingleLookupValue(member) ? unwrapSingleLookupValue(value, ctx) : value;
+  if (member === null) return resolveLocalizedRowValue(row, ctx);
+  return readLookupSelection(
+    member,
+    resolveLocalizedRowValueForMember(row, member, ctx),
+    row,
+    ctx
+  );
 }
-function resolveValueIfIdForMember(at2, member, ctx) {
-  if (typeof at2 !== "string") {
-    return shouldUnwrapSingleLookupValue(member) ? unwrapSingleLookupValue(at2, ctx) : at2;
-  }
+function resolveValueIfIdForMember(at2, member, ctx, owner = null) {
+  if (typeof at2 !== "string")
+    return readLookupSelection(member, at2, owner, ctx);
   const row = evalValueById(
     ctx,
     at2,
@@ -23199,8 +24674,12 @@ function resolveValueIfIdForMember(at2, member, ctx) {
   if (isMemberEntryCollectionBase(member) && listKindOf(member) === 1 /* Unordered */ && Array.isArray(row.value)) {
     return evaluatorUnorderedListEntryIds(row.id, ctx);
   }
-  const value = resolveLocalizedRowValueForMember(row, member, ctx);
-  return shouldUnwrapSingleLookupValue(member) ? unwrapSingleLookupValue(value, ctx) : value;
+  return readLookupSelection(
+    member,
+    resolveLocalizedRowValueForMember(row, member, ctx),
+    row,
+    ctx
+  );
 }
 function createUnorderedListProjectionCache() {
   return {
@@ -23307,12 +24786,53 @@ function evaluatorUnorderedListEntryIds(containerValueId, ctx) {
   cache.containerIdByArray.set(projection, containerValueId);
   return projection;
 }
-function shouldUnwrapSingleLookupValue(member) {
-  if (member === null) return false;
-  if (!isMemberLookup(member)) return false;
-  return isMultiSelectionMember(member) !== true;
+function readLookupSelection(member, value, row, ctx) {
+  if (!isMemberLookup(member)) return value;
+  const multi = isMultiSelectionMember(member) === true;
+  const target = lookupTargetTypeInfo(member, row, ctx);
+  if (referenceCategory(target) !== "slot" /* Slot */) {
+    return multi ? value : unwrapSingleLookupValue(member, value, ctx);
+  }
+  if (value === null || value === void 0) return null;
+  if (!Array.isArray(value)) {
+    throw new NSGetterRuntimeError(
+      `Lookup member '${member.name}' holds a ${typeof value}, not a list of target ids.`
+    );
+  }
+  if (multi) return slotReferenceSet(value, target, member.id, ctx);
+  const targetId = value[0];
+  if (targetId === void 0) return null;
+  if (typeof targetId !== "string") {
+    throw new NSGetterRuntimeError(
+      `Lookup member '${member.name}' holds a ${typeof targetId} target, not a value id.`
+    );
+  }
+  return new NSSlotReference(targetId, null, target, member.id);
+}
+function lookupTargetTypeInfo(member, row, ctx) {
+  const declared = member.declaredTypeInfo ?? collectionLookupTarget(member, ctx);
+  if (row === null || !typeInfoContainsGeneric2(declared)) return declared;
+  const env = runtimeGenericEnvForValueRow(row, ctx, /* @__PURE__ */ new Set());
+  return substituteRuntimeTypeInfo(declared, env, ctx);
+}
+var UNKNOWN_LOOKUP_TARGET = {
+  type: NS_TYPE_UNKNOWN,
+  required: true
+};
+function isCollectionTypeInfo(typeInfo) {
+  return typeInfo.type === 6 /* List */ || typeInfo.type === 28 /* Set */ || typeInfo.type === 9 /* Lookup */ || typeInfo.type === 5 /* Dictionary */;
 }
-function unwrapSingleLookupValue(value, ctx) {
+function collectionLookupTarget(member, ctx) {
+  const targets = evaluatorResolutionCache(ctx).collectionLookupTargets;
+  const cached = targets.get(member);
+  if (cached !== void 0) return cached;
+  const stored = slotTypeInfo(member, ctx.vm);
+  const reference = stored?.type === 9 /* Lookup */ ? stored.entryTypeInfo : stored;
+  const target = reference?.type === 29 /* Reference */ ? reference.targetTypeInfo : UNKNOWN_LOOKUP_TARGET;
+  targets.set(member, target);
+  return target;
+}
+function unwrapSingleLookupValue(member, value, ctx) {
   if (Array.isArray(value) && value.length === 1 && typeof value[0] === "string") {
     const next = evalValueById(
       ctx,
@@ -23320,12 +24840,26 @@ function unwrapSingleLookupValue(value, ctx) {
       ctx.__runtimeSessionValues,
       ctx.__valueOverlay
     );
-    if (next) {
-      return readRowValue(next, ctx);
-    }
+    if (next === null) throw danglingReferenceError(member.id, value[0], ctx);
+    return readRowValue(next, ctx);
   }
   return value;
 }
+function danglingReferenceError(memberId, targetId, ctx) {
+  return new NSGetterRuntimeError(
+    `${referenceSubject(memberId, ctx)} names value '${targetId}', which no longer exists.`
+  );
+}
+function referenceSubject(memberId, ctx) {
+  if (memberId === null) return "A reference";
+  return `Reference \`${qualifiedMemberLabel(memberId, ctx)}\``;
+}
+function qualifiedMemberLabel(memberId, ctx) {
+  const member = evalMemberById(ctx.vm, memberId);
+  const name = member?.name ?? memberId;
+  const owner = evaluatorSchemaIndex(ctx).firstSchemaPlacement(memberId)?.ownerClass.name;
+  return owner === void 0 ? name : `${owner}.${name}`;
+}
 function readRowValue(row, ctx) {
   const onInitializerRead = ctx.vm.databaseVM?.onInitializerRead;
   if (onInitializerRead !== void 0 && isInitValueContent(row)) {
@@ -23379,6 +24913,8 @@ function resolveMemberForValueRow(row, ctx, visited) {
   }
   const rootMatch = rootMemberForValueRow(row, ctx);
   if (rootMatch !== null) return rootMatch;
+  const staticRoot = activeStaticBindingRoot(row.id, ctx);
+  if (staticRoot !== null) return staticRoot.member;
   const syntheticMemberId = memberIdFromSyntheticDefaultValueId(row.id);
   if (syntheticMemberId !== null) {
     return evalMemberById(ctx.vm, syntheticMemberId);
@@ -24180,6 +25716,9 @@ function jsEqual(a, b) {
   if ((a === null || a === void 0) && (b === null || b === void 0)) {
     return true;
   }
+  if (a instanceof NSSlotReference || b instanceof NSSlotReference) {
+    return a instanceof NSSlotReference && b instanceof NSSlotReference && a.targetId === b.targetId;
+  }
   if (a === b) return true;
   if (Array.isArray(a) && Array.isArray(b)) {
     if (a.length !== b.length) return false;
@@ -24206,9 +25745,15 @@ function jsEqual(a, b) {
   return false;
 }
 function referenceEqual(a, b, ctx) {
+  if (a instanceof NSSlotReference || b instanceof NSSlotReference) {
+    return jsEqual(readThroughReference(a, ctx), readThroughReference(b, ctx));
+  }
   if (a === b) return true;
   if (a === null || a === void 0) return b === null || b === void 0;
   if (b === null || b === void 0) return false;
+  if (typeof a === "object" && "variantId" in a && isVariantRefValue(a) && isVariantRefValue(b)) {
+    return a.classId === b.classId && a.variantId === b.variantId && (a.rowValueId ?? null) === (b.rowValueId ?? null);
+  }
   const aId = referenceIdOf(a, ctx);
   return aId !== null && aId === referenceIdOf(b, ctx);
 }
@@ -25568,6 +27113,18 @@ function applyConstructorFields(args) {
       overwriteConstructedLiteral(existing, value, ctx);
       continue;
     }
+    const keptId = existing !== void 0 && isMemberWithEntries(member) ? existing.id : void 0;
+    if (keptId !== void 0) {
+      let kept = 0;
+      for (const row of createdValues) {
+        if (row.id === keptId || row.containerId === keptId) {
+          createdById.delete(row.id);
+          continue;
+        }
+        createdValues[kept++] = row;
+      }
+      createdValues.length = kept;
+    }
     const materialized = materializeConstructorArgumentValue({
       member,
       value,
@@ -25575,7 +27132,8 @@ function applyConstructorFields(args) {
       ctx,
       createdValues,
       createdById,
-      storageKeyDeclarations
+      storageKeyDeclarations,
+      ...keptId === void 0 ? {} : { rowId: keptId }
     });
     rootRecord[schemaKey] = materialized.id;
   }
@@ -26611,9 +28169,11 @@ function encodeLookupInitializerResult(member, value, created, ctx) {
   }
   return { value: selection, classId: null };
 }
-function encodeLookupInitializerSelection(member, value, created, ctx) {
+function encodeLookupInitializerSelection(member, value, created, 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)];
   if (value instanceof RuntimeSet) value = value.toArray();
   if (Array.isArray(value)) {
     if (isMultiSelectionMember(member) !== true && value.length > 1) {
@@ -26634,6 +28194,7 @@ function encodeLookupInitializerSelection(member, value, created, ctx) {
 }
 function lookupInitializerSelectionId(member, entry, created, ctx) {
   if (typeof entry === "string") return entry;
+  if (entry instanceof NSSlotReference) return entry.targetId;
   if (typeof entry !== "object" || entry === null) {
     throw new NSGetterRuntimeError(
       `Lookup member '${member.name}' initializer produced a ${typeof entry} entry, which cannot name a collection row.`
@@ -28389,19 +29950,27 @@ function materializeConstructorArgumentValue(args) {
       for (const entry of rows) sourceEntries.push(entry.value);
     }
     const ids = [];
-    const referenceIndexes = args.ctx.__unorderedListProjections?.referenceEntryIndexesByArray.get(
-      sourceEntries
-    );
+    const references = recordedReferenceEntries(sourceEntries, args.ctx) ?? (args.collectionEntriesAreReferences === false ? 1 /* Values */ : collectionReferences(sourceEntries, args.ctx));
     for (const [index, rawEntry] of sourceEntries.entries()) {
+      if (args.collectionOwnerId !== void 0 && args.collectionEntriesAreReferences !== false && isReferenceEntry(references, index) && typeof rawEntry === "string" && evalValueById(
+        args.ctx,
+        rawEntry,
+        args.ctx.__runtimeSessionValues,
+        args.ctx.__valueOverlay
+      ) !== null) {
+        ids.push(rawEntry);
+        continue;
+      }
       const entryValue = constructorCollectionEntryValue(
         rawEntry,
         args.ctx,
-        isMemberClassBase(resolvedEntry) || isMemberWithEntries(resolvedEntry) || (referenceIndexes?.has(index) ?? args.collectionEntriesAreReferences ?? trackedValueId !== null)
+        isMemberClassBase(resolvedEntry) || isMemberWithEntries(resolvedEntry) || isReferenceEntry(references, index)
       );
       const child = materializeConstructorArgumentValue({
         ...args,
         collectionEntriesAreReferences: void 0,
         collectionOwnerId: void 0,
+        rowId: void 0,
         member: resolvedEntry,
         genericEnv: entryEnv,
         value: entryValue,
@@ -28440,16 +30009,27 @@ function materializeConstructorArgumentValue(args) {
     );
     const row = registerConstructorArgumentRow(args, {});
     const record4 = /* @__PURE__ */ Object.create(null);
+    const references = recordedReferenceEntries(args.value, args.ctx) ?? (args.collectionEntriesAreReferences === false ? 1 /* Values */ : collectionReferences(args.value, args.ctx));
     for (const [key, rawEntry] of Object.entries(args.value)) {
+      if (args.collectionOwnerId !== void 0 && args.collectionEntriesAreReferences !== false && isReferenceEntry(references, key) && typeof rawEntry === "string" && evalValueById(
+        args.ctx,
+        rawEntry,
+        args.ctx.__runtimeSessionValues,
+        args.ctx.__valueOverlay
+      ) !== null) {
+        record4[key] = rawEntry;
+        continue;
+      }
       const entry = constructorCollectionEntryValue(
         rawEntry,
         args.ctx,
-        isMemberClassBase(resolvedEntry) || isMemberWithEntries(resolvedEntry) || (args.collectionEntriesAreReferences ?? trackedValueId !== null)
+        isMemberClassBase(resolvedEntry) || isMemberWithEntries(resolvedEntry) || isReferenceEntry(references, key)
       );
       record4[key] = materializeConstructorArgumentValue({
         ...args,
         collectionEntriesAreReferences: void 0,
         collectionOwnerId: void 0,
+        rowId: void 0,
         member: resolvedEntry,
         genericEnv: entryEnv,
         value: entry,
@@ -28468,6 +30048,7 @@ function materializeConstructorArgumentValue(args) {
 function registerConstructorArgumentRow(args, value) {
   args.ctx.beforeValueAllocation?.();
   const row = buildNewValue(args.ctx.vm.project.id, { value });
+  if (args.rowId !== void 0) row.id = args.rowId;
   const genericBindings = rowGenericBindings(args);
   if (genericBindings !== void 0) row.genericBindings = genericBindings;
   args.createdValues.push(row);
@@ -29033,13 +30614,18 @@ function snapshotCollectionMembership(collection, ctx) {
 }
 function forEachRawCollectionEntry(c, ctx, callback) {
   if (c instanceof RuntimeSet) {
+    const slots = c.slotReferences;
     for (const [key, entry] of c.membership().entries()) {
-      if (callback({
+      const control = slots === null ? callback({
         raw: entry.raw,
         key,
         valueId: entry.reference && typeof entry.raw === "string" ? entry.raw : null
-      }) === 1 /* Break */)
-        break;
+      }) : callback({
+        raw: slotReferenceEntry(entry.raw, slots),
+        key,
+        valueId: null
+      });
+      if (control === 1 /* Break */) break;
     }
     return true;
   }
@@ -29402,15 +30988,21 @@ function projectListenerEndpoint(args) {
 }
 
 // ../packages/models/src/members/lookup-declared-type.ts
-function lookupDeclaredTypeInfo(member, collectionTypeInfo) {
-  const entryTypeInfo = lookupEntryTypeInfo(member, collectionTypeInfo);
-  if (entryTypeInfo === null) return null;
+function lookupDeclaredTypeInfo(member, collectionTypeInfo, isClassConstrained) {
+  const targetTypeInfo = lookupEntryTypeInfo2(member, collectionTypeInfo);
+  if (targetTypeInfo === null) return null;
   if (isMultiSelectionMember(member) !== true) {
-    return {
-      ...entryTypeInfo,
-      required: isRequiredMember(member)
-    };
+    return referenceExpressionTypeInfo(
+      targetTypeInfo,
+      isRequiredMember(member),
+      isClassConstrained
+    );
   }
+  const entryTypeInfo = referenceExpressionTypeInfo(
+    targetTypeInfo,
+    true,
+    isClassConstrained
+  );
   if (member.collectionMemberId === void 0) {
     return {
       type: 9 /* Lookup */,
@@ -29426,7 +31018,7 @@ function lookupDeclaredTypeInfo(member, collectionTypeInfo) {
     collectionValueId: member.collectionValueId ?? null
   };
 }
-function lookupEntryTypeInfo(member, collectionTypeInfo) {
+function lookupEntryTypeInfo2(member, collectionTypeInfo) {
   if (member.collectionMemberId === void 0) return member.declaredTypeInfo;
   const collection = collectionTypeInfo(member.collectionMemberId);
   if (collection === null) return null;
@@ -29443,10 +31035,11 @@ function resolveMemberDeclaredTypeInfo(member, members, ownerClass = null, env)
     members,
     /* @__PURE__ */ new Set(),
     ownerClass,
-    env
+    env,
+    ownerClass === null ? void 0 : classConstrainedGenerics([ownerClass])
   );
 }
-function resolveMemberDeclaredTypeInfoInternal(member, members, seen, ownerClass, env) {
+function resolveMemberDeclaredTypeInfoInternal(member, members, seen, ownerClass, env, isClassConstrained) {
   const resolved = env === void 0 ? resolveMember(member, members) : substituteMember(member, env, members);
   const memberId = getField(resolved, "id");
   if (typeof memberId === "string" && seen.has(memberId)) return null;
@@ -29473,7 +31066,8 @@ function resolveMemberDeclaredTypeInfoInternal(member, members, seen, ownerClass
             members,
             nextSeen,
             ownerClass,
-            env
+            env,
+            isClassConstrained
           );
           return argumentType === null ? [] : [[genericParamId, argumentType]];
         }
@@ -29536,7 +31130,8 @@ function resolveMemberDeclaredTypeInfoInternal(member, members, seen, ownerClass
       members,
       nextSeen,
       ownerClass,
-      env
+      env,
+      isClassConstrained
     );
     if (entryTypeInfo === null) return null;
     return {
@@ -29547,19 +31142,24 @@ function resolveMemberDeclaredTypeInfoInternal(member, members, seen, ownerClass
     };
   }
   if (isMemberLookupBase(resolved)) {
-    return lookupDeclaredTypeInfo(resolved, (collectionMemberId) => {
-      const collection = members.find(
-        (candidate) => candidate.id === collectionMemberId
-      );
-      if (collection === void 0) return null;
-      return resolveMemberDeclaredTypeInfoInternal(
-        collection,
-        members,
-        nextSeen,
-        ownerClass,
-        env
-      );
-    });
+    return lookupDeclaredTypeInfo(
+      resolved,
+      (collectionMemberId) => {
+        const collection = members.find(
+          (candidate) => candidate.id === collectionMemberId
+        );
+        if (collection === void 0) return null;
+        return resolveMemberDeclaredTypeInfoInternal(
+          collection,
+          members,
+          nextSeen,
+          ownerClass,
+          env,
+          isClassConstrained
+        );
+      },
+      isClassConstrained
+    );
   }
   if (resolved.kind === 9 /* Lookup */) return null;
   if (!memberKindSupportsStorage(resolved.kind)) return null;
@@ -32419,18 +34019,55 @@ function evaluateInitializerMaterialization(args) {
   });
   return { evaluated, createdValues, storageKeyDeclarations };
 }
+function materializeInPlaceFields(document2, root, createdValues) {
+  const owners = [root, ...createdValues];
+  for (const owner of owners) {
+    const record4 = owner.value;
+    if (typeof owner.classId !== "string") continue;
+    if (typeof record4 !== "object" || record4 === null) continue;
+    if (Array.isArray(record4)) continue;
+    let memberIds;
+    for (const [schemaKey, value] of Object.entries(record4)) {
+      if (typeof value === "string" || value === null) continue;
+      memberIds ??= new Map(
+        resolvedClassSchema(
+          owner.classId,
+          document2.classes,
+          document2.members
+        ).surface.map((entry) => [entry.schemaKey, entry.memberId])
+      );
+      const memberId = memberIds.get(schemaKey);
+      if (memberId === void 0) {
+        throw new Error(
+          `Class "${owner.classId}" holds "${schemaKey}" in place, which its schema doesn't declare.`
+        );
+      }
+      const row = {
+        id: virtualValueId(owner.id, memberId),
+        projectId: owner.projectId,
+        createdAt: owner.createdAt,
+        updatedAt: owner.updatedAt,
+        value
+      };
+      createdValues.push(row);
+      record4[schemaKey] = row.id;
+    }
+  }
+}
 function finalizeMaterializedRoot(args) {
-  for (const created of args.allCreated) {
+  materializeInPlaceFields(args.document, args.root, args.createdValues);
+  const allCreated = [args.root, ...args.createdValues];
+  for (const created of allCreated) {
     if (created === args.root) continue;
     if (created.classId === void 0) delete created.classId;
   }
-  stampCreatedValuesMapKey(args.allCreated, args.mapKey);
+  stampCreatedValuesMapKey(allCreated, args.mapKey);
   if (args.supersededRootId !== void 0) {
     args.storageKeyDeclarations.delete(args.supersededRootId);
   }
   args.storageKeyDeclarations.delete(args.root.id);
   applyDeclaredStorageKeyOverrides({
-    createdValues: args.allCreated,
+    createdValues: allCreated,
     declarationByValueId: args.storageKeyDeclarations,
     existingParentContextById: /* @__PURE__ */ new Map([
       [
@@ -32474,21 +34111,21 @@ function materializeInitializerValue(args) {
     ...evaluated.genericBindings === void 0 ? {} : { genericBindings: { ...evaluated.genericBindings } },
     ...deepClonePlainData(pickInstanceProvenance(evaluated))
   };
-  const allCreated = [root, ...createdValues];
   if (evaluated.provisionalRootId !== void 0) {
     args.document.listenerDefaultCapture?.retarget(
       evaluated.provisionalRootId,
       root.id
     );
     retargetInitializerRootValueIds(
-      allCreated,
+      [root, ...createdValues],
       evaluated.provisionalRootId,
       root.id
     );
   }
   finalizeMaterializedRoot({
+    document: args.document,
     root,
-    allCreated,
+    createdValues,
     mapKey: args.row.mapKey,
     storageKeyDeclarations
   });
@@ -32603,12 +34240,12 @@ function materializeMemberDefaultValue(args) {
     ...built.classId === void 0 ? {} : { classId: built.classId },
     ...built.genericBindings == null ? {} : { genericBindings: { ...built.genericBindings } }
   };
-  const allCreated = [root, ...interior];
   args.document.listenerDefaultCapture?.retarget(built.id, root.id);
-  retargetInitializerRootValueIds(allCreated, built.id, root.id);
+  retargetInitializerRootValueIds([root, ...interior], built.id, root.id);
   finalizeMaterializedRoot({
+    document: args.document,
     root,
-    allCreated,
+    createdValues: interior,
     mapKey: args.envelope.mapKey,
     storageKeyDeclarations,
     supersededRootId: built.id
@@ -32628,7 +34265,7 @@ function isMaterializedSpine(location) {
   const virtual = location.virtualRow;
   if (!isLiteralValueContent(stored) || !isLiteralValueContent(virtual))
     return false;
-  return stored.id === virtual.id && (stored.instanceVariantId ?? null) === (virtual.instanceVariantId ?? null) && (stored.instanceVariantRowValueId ?? null) === (virtual.instanceVariantRowValueId ?? null) && (stored.instanceAppliedVariantId ?? null) === (virtual.instanceAppliedVariantId ?? null) && (stored.instanceAppliedVariantRowValueId ?? null) === (virtual.instanceAppliedVariantRowValueId ?? null);
+  return stored.id === virtual.id && (stored.instanceConstructorId ?? null) === (virtual.instanceConstructorId ?? null) && (stored.instanceVariantId ?? null) === (virtual.instanceVariantId ?? null) && (stored.instanceVariantRowValueId ?? null) === (virtual.instanceVariantRowValueId ?? null) && (stored.instanceAppliedVariantId ?? null) === (virtual.instanceAppliedVariantId ?? null) && (stored.instanceAppliedVariantRowValueId ?? null) === (virtual.instanceAppliedVariantRowValueId ?? null);
 }
 function buildVirtualInstanceMaterializedIndex(args) {
   const rowsById = new Map(
@@ -33321,14 +34958,21 @@ function resolveVirtualInstanceGraph(args) {
   };
   const rootLocation = resolvePath(ROOT_PATH, args.instanceRoot.id, null);
   const canonicalReceiver = (id) => locationsById.get(id)?.virtualRow.id ?? id;
+  const replayedId = (id) => {
+    const target = expansion.nodesByExpandedId.get(id);
+    return target === void 0 ? id : locationsByPath.get(target.pathKey)?.id ?? target.virtualId;
+  };
   for (const location of locationsByPath.values()) {
     if (location.materializedRow !== null) continue;
-    if (location.member.kind !== 25 /* NSDelegate */) continue;
     const effective = rowsById.get(location.id);
-    effective.value = remapMemberDelegateReceiver(effective.value, (id) => {
-      const target = expansion.nodesByExpandedId.get(id);
-      return target === void 0 ? id : locationsByPath.get(target.pathKey)?.id ?? target.virtualId;
-    });
+    if (location.member.kind === 25 /* NSDelegate */) {
+      effective.value = remapMemberDelegateReceiver(
+        effective.value,
+        replayedId
+      );
+    } else if (location.member.kind === 9 /* Lookup */) {
+      effective.value = remapLookupSelection(effective.value, replayedId);
+    }
   }
   let listenerDefaultsByOwner;
   const settled = /* @__PURE__ */ new Map();
@@ -34543,6 +36187,9 @@ function rewriteExpandedRow(node, expansion) {
   if (node.member.kind === 25 /* NSDelegate */) {
     row.value = remapMemberDelegateReceiver(row.value, rewrite);
   }
+  if (node.member.kind === 9 /* Lookup */) {
+    row.value = remapLookupSelection(row.value, rewrite);
+  }
   if (typeof row.containerId === "string") {
     row.containerId = rewrite(row.containerId);
   }
@@ -34563,6 +36210,10 @@ function createFromRow(prior, id, value, update) {
   };
   return create;
 }
+function remapLookupSelection(value, remap) {
+  if (!Array.isArray(value)) return value;
+  return value.map((id) => typeof id === "string" ? remap(id) : id);
+}
 function remapMemberDelegateReceiver(value, remap) {
   if (!isMemberDelegateTarget(value) || value.valueId === null) return value;
   const valueId = remap(value.valueId);
@@ -37097,23 +38748,28 @@ function sourcePositionMapper(source) {
 var SYSTEM_RECORD_ID_PREFIX2 = "system_";
 
 // ../packages/neoscript-language/src/type-substitution.ts
-function substituteTypeParameters(member, receiver, declaring) {
+function substituteTypeParameters(member, receiver, declaring, project) {
   const bindings = classTypeBindings({ type: receiver, declaring });
   return substituteBindings(
     member,
-    (type) => type.ownerMemberId === void 0 ? bindings.get(type.id) : void 0
+    (type) => type.ownerMemberId === void 0 ? bindings.get(type.id) : void 0,
+    project
   );
 }
-function substituteCallTypeArguments(member, functionArguments, typeParameters, receiver) {
+function substituteCallTypeArguments(member, functionArguments, typeParameters, receiver, project) {
   const classBindings = receiver && classTypeBindings(receiver);
   const declared = typeParameters?.[0]?.type;
   const owner = declared?.kind === "typeParameter" ? declared.ownerMemberId : void 0;
-  return substituteBindings(member, (type) => {
-    if (type.ownerMemberId === void 0) return classBindings?.get(type.id);
-    if (type.ownerMemberId !== owner) return void 0;
-    if (type.index === void 0) return void 0;
-    return functionArguments[type.index];
-  });
+  return substituteBindings(
+    member,
+    (type) => {
+      if (type.ownerMemberId === void 0) return classBindings?.get(type.id);
+      if (type.ownerMemberId !== owner) return void 0;
+      if (type.index === void 0) return void 0;
+      return functionArguments[type.index];
+    },
+    project
+  );
 }
 function classTypeBindings(receiver) {
   const parameters = receiver.declaring.typeParameters ?? [];
@@ -37125,7 +38781,7 @@ function classTypeBindings(receiver) {
   });
   return bindings;
 }
-function substituteBindings(member, bindingOf) {
+function substituteBindings(member, bindingOf, project) {
   const visit = (type) => {
     if (type.kind === "typeParameter") {
       const binding = bindingOf(type);
@@ -37155,8 +38811,19 @@ function substituteBindings(member, bindingOf) {
     if (type.kind === "action") {
       return { ...type, parameterTypes: type.parameterTypes.map(visit) };
     }
+    if (type.kind === "reference" && containsTypeParameter(type.target)) {
+      if (type.target.kind === "reference") {
+        return { ...type, target: visitReferenceTarget(type.target) };
+      }
+      return neoScriptReferenceType(
+        visit(type.target),
+        type.nullable === true,
+        (named) => isNeoScriptValueNamedType(named, project)
+      );
+    }
     return type;
   };
+  const visitReferenceTarget = (type) => type.kind === "reference" ? { ...type, target: visitReferenceTarget(type.target) } : visit(type);
   return visit(member);
 }
 function containsTypeParameter(type) {
@@ -37174,6 +38841,8 @@ function containsTypeParameter(type) {
       return containsTypeParameter(type.returnType) || type.parameterTypes.some(containsTypeParameter);
     case "action":
       return type.parameterTypes.some(containsTypeParameter);
+    case "reference":
+      return containsTypeParameter(type.target);
     default:
       return false;
   }
@@ -37269,7 +38938,8 @@ function createListenerAnnotationProvider(project, context = {}) {
       const observedType = substituteTypeParameters(
         symbol.type,
         owner,
-        declaration
+        declaration,
+        project
       );
       if (observedType.kind === "delegate" || observedType.kind === "action")
         continue;
@@ -37423,6 +39093,8 @@ var UserSafeTypeCheck = class {
       case "list":
       case "set":
         return this.unsafeName(type.elementType);
+      case "reference":
+        return this.unsafeName(type.target);
       case "dictionary":
         return this.unsafeName(type.keyType) ?? this.unsafeName(type.valueType);
       case "delegate":
@@ -37917,6 +39589,16 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     );
     this.requireAssignable(resolved.type, expected, expression.pos, "value");
   }
+  /** P112 §2.2. Checks a stored default's `Reference(place)` the push can't settle. */
+  resolvePersistedReference(expression, expected) {
+    const resolved = this.resolveExpression(
+      expression,
+      this.initialScope(),
+      expected
+    );
+    if (expected === void 0) return;
+    this.requireAssignable(resolved.type, expected, expression.pos, "value");
+  }
   persistedListenerCompletions(receiver, expected) {
     const scope = this.initialScope();
     let receiverType = this.context.thisClass;
@@ -38173,7 +39855,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
           );
         }
         const declared = statement.type ? this.resolveType(statement.type) : void 0;
-        const initial = this.resolveExpression(statement.init, scope, declared);
+        const initial = inferred ? this.resolveReferenceExpression(statement.init, scope) : this.resolveExpression(statement.init, scope, declared);
         if (inferred && isNull(initial.type)) {
           throw new CompileError(
             `Cannot infer the type of '${statement.name}' from null; use an explicit nullable type.`,
@@ -39260,7 +40942,10 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       );
     }
     if (statement.target.kind === "member" && statement.target.name === NEOSCRIPT_ON_CHANGED_MEMBER) {
-      const observed = this.resolveExpression(statement.target.receiver, scope);
+      const observed = this.resolveReferenceExpression(
+        statement.target.receiver,
+        scope
+      );
       const observedType = neoScriptMemberLookupType(observed.type);
       const declared = observedType.kind === "named" && this.project.typeById.get(observedType.typeId)?.members.some(
         (member) => member.name === NEOSCRIPT_ON_CHANGED_MEMBER
@@ -39292,14 +40977,19 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         statement.pos
       );
     }
-    const resolvedTarget = this.resolveExpression(statement.target, scope);
+    const placeTarget = this.resolveReferenceExpression(
+      statement.target,
+      scope
+    );
     const storageType = this.assignmentStorageType(
       statement.target,
-      resolvedTarget,
+      placeTarget,
       local,
       scope
     );
-    const target = statement.op === "=" ? { ...resolvedTarget, type: storageType } : resolvedTarget;
+    const reference = placeTarget.type.kind === "reference" ? this.referenceAssignment(statement, placeTarget, storageType, scope) : null;
+    const resolvedTarget = reference?.target ?? placeTarget;
+    const target = reference === null && statement.op === "=" ? { ...resolvedTarget, type: storageType } : resolvedTarget;
     const initSlot = target.initWritability !== void 0 ? {
       pointer: target.pointer,
       initWritability: target.initWritability
@@ -39376,7 +41066,9 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       );
     }
     let value;
-    if (statement.op === "=") {
+    if (reference?.value !== void 0) {
+      value = reference.value;
+    } else if (statement.op === "=") {
       if (!statement.value) {
         throw new CompileError(
           "Assignment operator '=' requires a right-hand value.",
@@ -39394,6 +41086,9 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       );
     }
     this.requireAssignable(value.type, target.type, statement.pos, "assign");
+    if (statement.op === "=" && this.holdsHandleReference(target)) {
+      this.requireStoredHandle(statement.target, value, scope);
+    }
     if (local && statement.op === "=") {
       scope.setOwnership(
         local,
@@ -39416,9 +41111,16 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         for (const [path, type] of retainedFacts) {
           scope.narrow(path, rootEntry, type);
         }
-        if (statement.op === "=" && !isNullable(value.type)) {
+        if (reference !== null && reference.through > 0) {
+          scope.narrow(
+            assignedPath,
+            rootEntry,
+            nonNullLayers(storageType, reference.through)
+          );
+        }
+        if (statement.op === "=" && !isNullable(value.type) && target.pointer.type !== "deref" /* Deref */) {
           scope.narrow(assignedPath, rootEntry, {
-            ...target.type,
+            ...reference === null ? target.type : storageType,
             nullable: false
           });
         }
@@ -39435,6 +41137,205 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       pointer: value.pointer
     };
   }
+  /**
+   * P112 §3.2. Where `target = value` writes. The first reference layer the
+   * value fits rebinds; every layer it doesn't fit is written through. A
+   * generic layer that doesn't fit statically keeps the Lookup assignment,
+   * and its evaluator decides at the write (§3.5). A compound operator always
+   * writes through.
+   */
+  referenceAssignment(statement, place, storageType, scope) {
+    const source = statement.op === "=" ? statement.value ?? void 0 : void 0;
+    const nullLiteral = source?.kind === "litNull";
+    const assigned = source === void 0 ? void 0 : this.resolveReferenceExpression(
+      source,
+      scope,
+      nullLiteral ? void 0 : neoScriptReadType(storageType)
+    );
+    const valueAt = (type) => {
+      if (source === void 0 || assigned === void 0) return void 0;
+      return nullLiteral ? this.resolveReferenceExpression(source, scope, type) : this.readReferences(assigned, type);
+    };
+    let layer = assigned === void 0 ? place : { ...place, type: storageType };
+    let narrowed = place.type;
+    let through = 0;
+    while (layer.type.kind === "reference") {
+      if (assigned !== void 0) {
+        const bound = narrowed.kind === "reference" ? narrowed : layer.type;
+        if (isNeoScriptTypeAssignable(
+          this.readReferences(assigned, bound).type,
+          bound,
+          this.project
+        )) {
+          return { target: layer, value: valueAt(layer.type), through };
+        }
+        if (layer.type.target.kind === "typeParameter") {
+          const target2 = layer.type.target;
+          return {
+            target: { ...layer, type: target2 },
+            value: valueAt(target2),
+            through
+          };
+        }
+      }
+      if (isNullable(narrowed)) {
+        throw new CompileError(
+          `${this.referenceSubject(statement.target, scope)} may be null. Narrow it with a null check before writing through it.`,
+          statement.pos
+        );
+      }
+      const target = layer.type.target;
+      layer = {
+        pointer: { type: "deref" /* Deref */, pointer: layer.pointer },
+        type: target,
+        writability: "runtime" /* Runtime */
+      };
+      narrowed = narrowed.kind === "reference" ? narrowed.target : target;
+      through += 1;
+    }
+    return { target: layer, value: valueAt(layer.type), through };
+  }
+  /** `Reference<target>` as an expression type (P112 §3.1). */
+  referenceType(target, nullable2) {
+    return neoScriptReferenceType(
+      target,
+      nullable2,
+      (named) => isNeoScriptValueNamedType(named, this.project)
+    );
+  }
+  /**
+   * P112 §2.2. `Reference(place)`: the row a stored member slot is, typed by
+   * the slot's stored type. A value that already is a reference, which every
+   * handle is, stays as it is.
+   */
+  resolveRowOf(place, scope) {
+    if (place.kind === "member") return this.resolveMemberRowOf(place, scope);
+    if (NEW_VALUE_EXPRESSION_KINDS.has(place.kind)) {
+      throw new CompileError(
+        "A new value has no row yet. Store it in a member, then reference the member.",
+        place.pos
+      );
+    }
+    const value = this.resolveReferenceExpression(place, scope);
+    if (value.type.kind === "reference") return value;
+    const constructs = value.pointer.type === "function" /* Function */ && CONSTRUCTION_FUNCTION_KINDS.has(value.pointer.function.type);
+    if (constructs) {
+      throw new CompileError(
+        "A new value has no row yet. Store it in a member, then reference the member.",
+        place.pos
+      );
+    }
+    const computed = value.pointer.type === "function" /* Function */;
+    if (!computed && this.referenceType(value.type, false) === value.type) {
+      return value;
+    }
+    const text = referencePlaceText(place);
+    switch (place.kind) {
+      case "ident":
+        throw new CompileError(
+          `\`${place.name}\` is a local, which has no stored row. Reference a member instead.`,
+          place.pos
+        );
+      case "index": {
+        const collection = this.resolveExpression(place.receiver, scope).type;
+        const element = collection.kind === "dictionary" ? "dictionary entry" : "list element";
+        throw new CompileError(
+          text === null ? `A reference can't name a ${element}. Reference a member instead.` : `\`${text}\` is a ${element}, which a reference can't name. Reference a member instead.`,
+          place.pos
+        );
+      }
+      case "call":
+        throw new CompileError(
+          text === null ? "A call's result is computed, so it has no row to reference." : `\`${text}\` is computed, so it has no row to reference.`,
+          place.pos
+        );
+      default:
+        throw new CompileError(
+          "A new value has no row yet. Store it in a member, then reference the member.",
+          place.pos
+        );
+    }
+  }
+  resolveMemberRowOf(place, scope) {
+    const optional2 = place.optional === true;
+    if ((this.context.kind === "initializer" || this.context.kind === "initializerExpression") && this.delegateCaptureContexts.length === 0 && referencePlaceRoot(place) === "this") {
+      const text = referencePlaceText(place) ?? "this";
+      throw new CompileError(
+        `A default runs before its instance exists, so \`${text}\` has no row to reference yet. Set the reference in a constructor instead.`,
+        place.pos
+      );
+    }
+    const slot = this.resolveMemberNatural(
+      place.receiver,
+      place.name,
+      scope,
+      place.pos,
+      optional2
+    );
+    const member = slot.symbol;
+    if (member === void 0) {
+      const owner = this.resolveExpression(place.receiver, scope).type;
+      const text = referencePlaceText(place);
+      const subject = text === null ? `\`${place.name}\`` : `\`${text}\``;
+      throw new CompileError(
+        `${subject} is part of a ${this.describe({ ...owner, nullable: false })} value, which a reference can't name. Reference the whole member instead.`,
+        place.pos
+      );
+    }
+    if (member.computed === true) {
+      throw new CompileError(
+        `\`${this.referenceLabel(place, scope)}\` is computed, so it has no row to reference.`,
+        place.pos
+      );
+    }
+    const read = slot.optionalChainType ?? slot.type;
+    const stored = member.lookup !== void 0 && member.lookup.multiselect !== true && read.kind !== "reference" ? {
+      kind: "reference",
+      target: { ...read, nullable: false },
+      ...isNullable(read) ? { nullable: true } : {}
+    } : read;
+    const type = this.referenceType(stored, optional2);
+    if (type.kind !== "reference") return slot;
+    return {
+      pointer: { type: "rowOf" /* RowOf */, place: slot.pointer },
+      type
+    };
+  }
+  /** Whether assigning `target` rebinds a reference to a handle. */
+  holdsHandleReference(target) {
+    if (target.type.kind === "reference") {
+      return this.referenceType(target.type.target, false).kind !== "reference";
+    }
+    const lookup = target.symbol?.lookup;
+    return lookup !== void 0 && lookup.multiselect !== true;
+  }
+  /** P112 §3.2. A reference never owns, so it rebinds only to a stored row. */
+  requireStoredHandle(place, value, scope) {
+    if (!makesNewValue(value)) return;
+    const noun = handleNoun(value.type);
+    throw new CompileError(
+      `${this.referenceSubject(place, scope)} can't hold a new ${this.describe({ ...value.type, nullable: false })}, because a reference never owns. Assign a stored ${noun}, or change the referenced ${noun}'s ${noun === "object" ? "members" : "entries"}.`,
+      place.pos
+    );
+  }
+  /** A reference-typed place as a message's subject: "Reference `Widget.TrackedStat`". */
+  referenceSubject(place, scope) {
+    if (place.kind !== "member") {
+      const text = referencePlaceText(place);
+      return text === null ? "This reference" : `Reference \`${text}\``;
+    }
+    return `Reference \`${this.referenceLabel(place, scope)}\``;
+  }
+  /** How a member place reads in a message: `Widget.TrackedStat`. */
+  referenceLabel(place, scope) {
+    if (place.receiver.kind === "ident" && !this.hasValueReceiver(place.receiver.name, scope)) {
+      return `${place.receiver.name}.${place.name}`;
+    }
+    const receiver = this.resolveExpression(place.receiver, scope);
+    const owner = neoScriptMemberLookupType(receiver.type);
+    const named = owner.kind === "named" ? { kind: "named", typeId: owner.typeId } : owner;
+    return `${this.describe({ ...named, nullable: false })}.${place.name}`;
+  }
   /**
    * The declared type of an assignment target, with any flow narrowing on the
    * path stripped back off. Locals carry their declaration on the scope entry;
@@ -39486,7 +41387,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     if (expression.kind !== "call" || expression.callee.kind !== "member" || expression.callee.name !== "Clear" || expression.callee.receiver.kind !== "member" || expression.callee.receiver.name !== NEOSCRIPT_ON_CHANGED_MEMBER)
       return null;
     const onChanged = expression.callee.receiver;
-    const observed = this.resolveExpression(onChanged.receiver, scope);
+    const observed = this.resolveReferenceExpression(onChanged.receiver, scope);
     const observedType = neoScriptMemberLookupType(observed.type);
     if (observedType.kind === "named" && this.project.typeById.get(observedType.typeId)?.members.some((member) => member.name === NEOSCRIPT_ON_CHANGED_MEMBER))
       return null;
@@ -39582,15 +41483,16 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       null,
       scope
     );
+    const listenedType = observed.type.kind === "reference" ? readReference(observed, observed.type).type : storageType;
     return this.changeListenerInstruction(
       edit,
       {
         owner: observed.pointer.keyOf.pointer,
         memberId: member.canonicalMemberId ?? observed.pointer.memberId,
-        typeInfo: toWireType(storageType, this.project),
+        typeInfo: toWireType(listenedType, this.project),
         writability
       },
-      storageType,
+      listenedType,
       scope,
       pos
     );
@@ -39933,7 +41835,8 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       type,
       listenerArguments,
       symbol.typeParameters,
-      receiver
+      receiver,
+      this.project
     );
     const signature = actionListenerSignature(symbol);
     if (signature === null) {
@@ -39955,7 +41858,17 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     }
   }
   resolveExpression(expression, scope, expected) {
-    const result = this.resolveReceiverExpression(expression, scope, expected);
+    return this.readReferences(
+      this.resolveReferenceExpression(expression, scope, expected),
+      expected
+    );
+  }
+  /**
+   * P112 §3.1. {@link resolveExpression} that keeps a slot reference a
+   * reference, for the positions that name a slot rather than read it.
+   */
+  resolveReferenceExpression(expression, scope, expected) {
+    const result = this.resolveRawExpression(expression, scope, expected);
     if (result.dialogues !== void 0) {
       throw new CompileError(
         dialogueValueError(result.dialogues),
@@ -39966,6 +41879,38 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
   }
   /** {@link resolveExpression} that also admits a `root.Dialogues` receiver. */
   resolveReceiverExpression(expression, scope, expected) {
+    return this.readReferences(
+      this.resolveRawExpression(expression, scope, expected),
+      expected
+    );
+  }
+  /**
+   * P112 §3.1. Reads a slot reference through as many layers as it takes to
+   * reach `expected`: all of them unless a reference is expected.
+   */
+  readReferences(result, expected) {
+    if (result.type.kind !== "reference") return result;
+    const wantsReference = expected?.kind === "reference";
+    let current = result;
+    while (current.type.kind === "reference") {
+      if (wantsReference && isNeoScriptTypeAssignable(current.type, expected, this.project))
+        return current;
+      current = readReference(current, current.type);
+    }
+    return wantsReference ? result : current;
+  }
+  /**
+   * P112 §3.4. A reference read down to its first layer that may be null,
+   * which is the layer a null check or `!` is about.
+   */
+  readToNullable(result) {
+    let current = result;
+    while (current.type.kind === "reference" && !isNullable(current.type)) {
+      current = readReference(current, current.type);
+    }
+    return current;
+  }
+  resolveRawExpression(expression, scope, expected) {
     let result = this.resolveExpressionCore(expression, scope, expected);
     if (result.pointer.type === "function" /* Function */ || result.pointer.type === "callFunction" /* CallFunction */ || result.pointer.type === "callDelegate" /* CallDelegate */ || result.pointer.type === "callAction" /* CallAction */ || result.pointer.type === "callGetter" /* CallGetter */) {
       result = {
@@ -40076,6 +42021,9 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
           expression.optional === true
         );
       case "call": {
+        if (expression.callee.kind === "ident" && expression.callee.name === "Reference" && expression.typeArguments === void 0 && expression.argumentNames === void 0 && expression.args.length === 1 && scope.lookup("Reference") === null) {
+          return this.resolveRowOf(expression.args[0], scope);
+        }
         const receiverValue = this.callReceiver(expression.callee, scope);
         if (expression.callee.kind === "ident" && expression.callee.name === "Reference") {
           if (expression.args.length === 1 && expression.argumentNames?.[0] == null) {
@@ -40158,13 +42106,17 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
             );
           }
           const referencedType = this.resolveType(referenceTypeArgument);
-          if (expected !== void 0 && !isNeoScriptTypeAssignable(referencedType, expected, this.project)) {
+          if (expected !== void 0 && !isNeoScriptTypeAssignable(
+            neoScriptReadType(referencedType),
+            neoScriptReadType(expected),
+            this.project
+          )) {
             throw new CompileError(
               `Reference target ${this.describe(referencedType)} is not assignable to ${this.describe(expected)}.`,
               expression.pos
             );
           }
-          if (isPrimitive(referencedType, "ImageRef") || isPrimitive(referencedType, "AudioClipRef")) {
+          if (expected?.kind !== "reference" && (isPrimitive(referencedType, "ImageRef") || isPrimitive(referencedType, "AudioClipRef"))) {
             if (hasProvenanceArgument) {
               throw new CompileError(
                 `Reference<${referenceTypeArgument.kind === "named" ? referenceTypeArgument.name : "file"}> does not support withProvenance because a project file reference is a file id, not a value-row reference.`,
@@ -40177,14 +42129,20 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
               this.project
             );
           }
-          return {
+          const row = {
+            type: "reference" /* Reference */,
+            valueId: expression.args[0].value,
+            ...expression.args[1]?.kind === "litBool" && expression.args[1].value ? { withProvenance: true } : {}
+          };
+          const reference = this.referenceType(referencedType, false);
+          return reference.kind === "reference" ? {
             pointer: {
-              type: "reference" /* Reference */,
-              valueId: expression.args[0].value,
-              ...expression.args[1]?.kind === "litBool" && expression.args[1].value ? { withProvenance: true } : {}
+              type: "rowOf" /* RowOf */,
+              place: row,
+              typeInfo: toWireType(referencedType, this.project)
             },
-            type: referencedType
-          };
+            type: reference
+          } : { pointer: row, type: reference };
         }
         if (expression.callee.kind === "member" && expression.callee.name === "TryConvert") {
           const conversion = this.resolveTileConversion(
@@ -40352,7 +42310,9 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         );
       }
       case "force": {
-        const operand = this.resolveExpression(expression.operand, scope);
+        const operand = this.readToNullable(
+          this.resolveReferenceExpression(expression.operand, scope)
+        );
         return {
           pointer: {
             type: "forceUnwrap" /* ForceUnwrap */,
@@ -40679,14 +42639,16 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       symbol.returnType ?? symbol.type,
       methodGroupArguments,
       symbol.typeParameters,
-      bound
+      bound,
+      this.project
     );
     const parameterTypes = (symbol.parameters ?? []).map(
       (parameter3) => substituteCallTypeArguments(
         parameter3.type,
         methodGroupArguments,
         symbol.typeParameters,
-        bound
+        bound,
+        this.project
       )
     );
     const expectedVoid = isVoid(expected.returnType);
@@ -40755,14 +42717,16 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       symbol.returnType ?? symbol.type,
       mockArguments,
       symbol.typeParameters,
-      receiver
+      receiver,
+      this.project
     );
     const parameterTypes = (symbol.parameters ?? []).map(
       (parameter3) => substituteCallTypeArguments(
         parameter3.type,
         mockArguments,
         symbol.typeParameters,
-        receiver
+        receiver,
+        this.project
       )
     );
     return { kind: "delegate", returnType, parameterTypes };
@@ -41157,10 +43121,17 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
   applyFactsToScope(targetScope, facts, mode = "all") {
     for (const fact of facts) {
       if (mode === "bindings-only" && !fact.bindingName) continue;
-      const natural = this.resolveExpression(fact.expression, targetScope);
+      const place = this.resolveReferenceExpression(
+        fact.expression,
+        targetScope
+      );
+      const natural = this.readReferences(place, void 0);
       const rootEntry = fact.path === null ? null : targetScope.lookup(pathRoot(fact.path));
       if (fact.nullValue) {
         if (fact.path === null || rootEntry === null) continue;
+        if (place.type.kind === "reference" && !isNullable(place.type)) {
+          continue;
+        }
         if (fact.loose === true && natural.type.kind === "primitive" && (natural.type.name === "string" || natural.type.name === "int" || natural.type.name === "float" || natural.type.name === "bool")) {
           continue;
         }
@@ -41177,7 +43148,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         const naturalDefinition = natural.type.kind === "named" ? this.project.typeById.get(natural.type.typeId) : void 0;
         const retainConcreteClass = !fact.bindingName && naturalDefinition?.kind === "class" && targetDefinition?.kind === "interface";
         const narrowed = retainConcreteClass ? { ...natural.type, nullable: false } : { ...target, nullable: false };
-        if (mode === "all" && fact.path !== null && rootEntry !== null) {
+        if (mode === "all" && fact.path !== null && rootEntry !== null && place.type.kind !== "reference") {
           targetScope.narrow(fact.path, rootEntry, narrowed);
         }
         if (fact.bindingName) {
@@ -41199,11 +43170,9 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         continue;
       }
       if (fact.path === null || rootEntry === null) continue;
-      if (!isNullable(natural.type)) continue;
-      targetScope.narrow(fact.path, rootEntry, {
-        ...natural.type,
-        nullable: false
-      });
+      const nonNull = withoutFirstNull(place.type);
+      if (nonNull === null) continue;
+      targetScope.narrow(fact.path, rootEntry, nonNull);
     }
   }
   /**
@@ -41566,7 +43535,8 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         type: receiver2.expression.type.kind === "named" ? substituteTypeParameters(
           symbol.type,
           receiver2.expression.type,
-          owner
+          owner,
+          this.project
         ) : symbol.type,
         writability: "readOnly" /* ReadOnly */,
         symbol
@@ -41817,7 +43787,8 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       const memberType2 = substituteTypeParameters(
         member.type,
         memberReceiverType,
-        type
+        type,
+        this.project
       );
       if (member.computed === true) {
         return {
@@ -41884,7 +43855,8 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     return substituteTypeParameters(
       key?.type ?? index.keyType,
       entry,
-      declaring
+      declaring,
+      this.project
     );
   }
   /** The indexes declared on a schema-backed List or Set, keyed by its member. */
@@ -43130,7 +45102,8 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         closedConstructorParameters(
           signature.parameters,
           this.constructorTargetType(schemaClass2, expression, expected),
-          schemaClass2
+          schemaClass2,
+          this.project
         ),
         expression.args.length
       ).map((name) => name.toLowerCase())
@@ -43181,7 +45154,8 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     const parameters = closedConstructorParameters(
       signature.parameters,
       targetType,
-      schemaClass2
+      schemaClass2,
+      this.project
     );
     const argumentsList2 = expression.args;
     if (expression.argumentNames !== void 0) {
@@ -43342,7 +45316,8 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
           type: substituteTypeParameters(
             parameter3.type,
             targetType,
-            schemaClass2
+            schemaClass2,
+            this.project
           )
         }))
       })
@@ -43568,7 +45543,8 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       const memberType2 = substituteTypeParameters(
         member.type,
         targetType,
-        schemaClass2
+        schemaClass2,
+        this.project
       );
       if (memberType2.kind === "action") {
         return {
@@ -44004,7 +45980,8 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       );
     }
     const args = argumentsList2.map((argument2, index) => {
-      let expected = requiredAt(parameters, index).type;
+      const parameter3 = requiredAt(parameters, index);
+      let expected = parameter3.type;
       if ((symbol.id === NEO_TEST_IDS.mockReturns || symbol.id === NEO_TEST_IDS.mockReturnsOnce) && receiver?.kind === "instance") {
         const delegate = this.delegateTypeFromMockHandle(
           receiver.expression.type
@@ -44018,6 +45995,12 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       }
       const resolved = isUnknown(expected) ? this.resolveExpression(argument2, scope) : this.resolveExpression(argument2, scope, expected);
       if (!isUnknown(expected)) {
+        this.requireReferenceArgument(
+          resolved.type,
+          expected,
+          parameter3.name,
+          argument2.pos
+        );
         this.requireAssignable(
           resolved.type,
           expected,
@@ -44045,14 +46028,15 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     const functionArguments = this.resolveFunctionTypeArguments(
       symbol,
       typeArguments,
-      (type) => substituteCallTypeArguments(type, [], void 0, bound),
+      (type) => substituteCallTypeArguments(type, [], void 0, bound, this.project),
       pos
     );
     const bind = (type) => substituteCallTypeArguments(
       type,
       functionArguments,
       symbol.typeParameters,
-      bound
+      bound,
+      this.project
     );
     return {
       parameters: (symbol.parameters ?? []).map((parameter3) => ({
@@ -45572,6 +47556,10 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         scope,
         preResolvedRight.type
       );
+    } else if (expression.right.kind === "litNull" && (expression.op === "==" || expression.op === "!=")) {
+      left = this.readToNullable(
+        this.resolveReferenceExpression(expression.left, scope)
+      );
     } else {
       left = this.resolveExpression(expression.left, scope);
     }
@@ -45583,7 +47571,9 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         expression.op === "&&" ? this.conditionFacts(expression.left, scope, true) : this.conditionFacts(expression.left, scope, false)
       );
     }
-    const right = preResolvedRight ?? this.resolveExpression(expression.right, rightScope, left.type);
+    const right = preResolvedRight ?? (expression.left.kind === "litNull" && (expression.op === "==" || expression.op === "!=") ? this.readToNullable(
+      this.resolveReferenceExpression(expression.right, rightScope)
+    ) : this.resolveExpression(expression.right, rightScope, left.type));
     if (expression.op === "==" || expression.op === "!=" || expression.op === "<" || expression.op === ">" || expression.op === "<=" || expression.op === ">=") {
       return this.booleanComparison(expression.op, left, right, expression.pos);
     }
@@ -45677,6 +47667,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       );
     }
     const kind = comparisonOperator(operator);
+    const deferred = equality && (isGenericRead(left) || isGenericRead(right));
     return {
       pointer: {
         type: "operation" /* Operation */,
@@ -45685,10 +47676,10 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
           expression: {
             condition: {
               type: kind,
-              operand1: left.pointer,
-              operand2: right.pointer,
+              operand1: deferred ? unreadGeneric(left) : left.pointer,
+              operand2: deferred ? unreadGeneric(right) : right.pointer,
               ...isPrimitive(left.type, "decimal") || isPrimitive(right.type, "decimal") ? { decimal: true } : {},
-              ...equality && (hasReferenceEquality(left.type, this.project) || hasReferenceEquality(right.type, this.project)) ? { reference: true } : {}
+              ...deferred || equality && (hasReferenceEquality(left.type, this.project) || hasReferenceEquality(right.type, this.project)) ? { reference: true } : {}
             }
           }
         }
@@ -45913,6 +47904,19 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       pos
     );
   }
+  /** P112 §3.1. A value never converts to a reference, since it has no row. */
+  requireReferenceArgument(source, target, parameter3, pos) {
+    if (target.kind !== "reference") return;
+    if (source.kind === "reference") return;
+    const read = neoScriptReadType(target);
+    if (!isNeoScriptTypeAssignable(source, read, this.project)) return;
+    const value = this.describe(source);
+    const article = /^[aeiou]/i.test(value) ? "an" : "a";
+    throw new CompileError(
+      `Argument \`${parameter3}\` needs a ${this.describe(target)}, not ${article} ${value}. Wrap a member path in Reference() to pass a stored ${this.describe(read)}.`,
+      pos
+    );
+  }
   requireCollectionOperationAssignable(source, target, receiver, collection, pos, usage) {
     if (isLookupSelectionCollection(receiver, collection) && isNeoScriptTypeAssignable(source, collection.valueType, this.project)) {
       return;
@@ -45997,6 +48001,141 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     return result;
   }
 };
+function isGenericRead(expression) {
+  return expression.pointer.type === "deref" /* Deref */ && expression.type.kind === "typeParameter";
+}
+function unreadGeneric(expression) {
+  return isGenericRead(expression) && expression.pointer.type === "deref" /* Deref */ ? expression.pointer.pointer : expression.pointer;
+}
+function readReference(reference, type) {
+  return {
+    pointer: { type: "deref" /* Deref */, pointer: reference.pointer },
+    type: type.nullable === true ? { ...type.target, nullable: true } : type.target,
+    // §3.6. The target row decides each write through the reference.
+    writability: "runtime" /* Runtime */
+  };
+}
+function nonNullLayers(type, count) {
+  if (count === 0 || type.kind !== "reference") return type;
+  return {
+    ...type,
+    nullable: false,
+    target: nonNullLayers(type.target, count - 1)
+  };
+}
+function withoutFirstNull(type) {
+  if (isNullable(type)) return { ...type, nullable: false };
+  if (type.kind !== "reference") return null;
+  const target = withoutFirstNull(type.target);
+  return target === null ? null : { ...type, target };
+}
+function makesNewValue(value) {
+  switch (value.pointer.type) {
+    case "listLiteral" /* ListLiteral */:
+    case "dictLiteral" /* DictLiteral */:
+    case "objectInitializer" /* ObjectInitializer */:
+      return true;
+    case "function" /* Function */:
+      return CONSTRUCTION_FUNCTION_KINDS.has(value.pointer.function.type) || COLLECTION_FUNCTION_KINDS.has(value.pointer.function.type);
+    default:
+      return false;
+  }
+}
+function handleNoun(type) {
+  switch (type.kind) {
+    case "list":
+      return "list";
+    case "set":
+      return "set";
+    case "dictionary":
+      return "dictionary";
+    default:
+      return "object";
+  }
+}
+var NEW_VALUE_EXPRESSION_KINDS = /* @__PURE__ */ new Set([
+  "litNull",
+  "litBool",
+  "litInt",
+  "litFloat",
+  "litString",
+  "litInterp",
+  "litTripleString",
+  "contextualEnum",
+  "litList",
+  "litDict",
+  "new",
+  "lambda"
+]);
+var CONSTRUCTION_FUNCTION_KINDS = /* @__PURE__ */ new Set(
+  [
+    "classConstructor" /* ClassConstructor */,
+    "declaredConstructor" /* DeclaredConstructor */,
+    "classClone" /* ClassClone */,
+    "variantInitialize" /* VariantInitialize */
+  ]
+);
+var COLLECTION_FUNCTION_KINDS = /* @__PURE__ */ new Set([
+  "collectionQuery" /* CollectionQuery */,
+  "select" /* Select */,
+  "where" /* Where */,
+  "listRepeat" /* ListRepeat */
+]);
+function referencePlaceRoot(expression) {
+  switch (expression.kind) {
+    case "ident":
+      return expression.name;
+    case "member":
+    case "index":
+      return referencePlaceRoot(expression.receiver);
+    case "force":
+      return referencePlaceRoot(expression.operand);
+    default:
+      return null;
+  }
+}
+function referencePlaceText(expression) {
+  switch (expression.kind) {
+    case "ident":
+      return expression.name;
+    case "litInt":
+      return expression.raw;
+    case "litString":
+      return JSON.stringify(expression.value);
+    case "litBool":
+      return String(expression.value);
+    case "member": {
+      const receiver = referencePlaceText(expression.receiver);
+      if (receiver === null) return null;
+      return `${receiver}${expression.optional ? "?." : "."}${expression.name}`;
+    }
+    case "index": {
+      const receiver = referencePlaceText(expression.receiver);
+      const key = referencePlaceText(expression.index);
+      if (receiver === null || key === null) return null;
+      return `${receiver}[${key}]`;
+    }
+    case "force": {
+      const operand = referencePlaceText(expression.operand);
+      return operand === null ? null : `${operand}!`;
+    }
+    case "call": {
+      if (expression.typeArguments !== void 0) return null;
+      const callee = referencePlaceText(expression.callee);
+      if (callee === null) return null;
+      const args = [];
+      for (const [index, argument2] of expression.args.entries()) {
+        const text = referencePlaceText(argument2);
+        if (text === null) return null;
+        const name = expression.argumentNames?.[index];
+        args.push(typeof name === "string" ? `${name}: ${text}` : text);
+      }
+      return `${callee}(${args.join(", ")})`;
+    }
+    default:
+      return null;
+  }
+}
 function canonicalPath(expression) {
   if (expression.kind === "ident") return expression.name;
   if (expression.kind !== "member") return null;
@@ -46235,12 +48374,13 @@ function variable(id, type, pointer, project) {
 function isGeneratedPositionalCall(target, expression) {
   return neoScriptRequiredConstructor(target) === null && target.constructorSignature !== void 0 && expression.argumentNames === void 0 && callHasPositionalArguments(expression);
 }
-function closedConstructorParameters(parameters, targetType, schemaClass2) {
+function closedConstructorParameters(parameters, targetType, schemaClass2, project) {
   return parameters.map((parameter3) => {
     const valueType = substituteTypeParameters(
       parameter3.valueType,
       targetType,
-      schemaClass2
+      schemaClass2,
+      project
     );
     return {
       ...parameter3,
@@ -46248,7 +48388,8 @@ function closedConstructorParameters(parameters, targetType, schemaClass2) {
       parameterType: substituteTypeParameters(
         parameter3.parameterType,
         targetType,
-        schemaClass2
+        schemaClass2,
+        project
       ),
       required: parameter3.required && valueType.nullable !== true
     };
@@ -46916,6 +49057,12 @@ function toWireType(type, project) {
         ownerClassId: type.ownerClassId ?? findGenericParameterOwner(type.id, project) ?? "",
         genericParamId: type.id
       };
+    case "reference":
+      return {
+        type: 29 /* Reference */,
+        required,
+        targetTypeInfo: toWireType(type.target, project)
+      };
     case "delegate":
       return {
         type: 25 /* Delegate */,
@@ -47012,6 +49159,13 @@ function fromWireType(type) {
       parameterTypes: type.argumentTypes.map(fromWireType)
     };
   }
+  if (type.type === 29 /* Reference */) {
+    return {
+      kind: "reference",
+      target: fromWireType(type.targetTypeInfo),
+      nullable: nullable2
+    };
+  }
   return { kind: "primitive", name: valueKindPrimitive(type.type), nullable: nullable2 };
 }
 function findGenericParameterOwner(parameterId, project) {
@@ -47254,7 +49408,7 @@ function collectionOperationValueType(expression, collection) {
   return collection.valueType;
 }
 function isLookupSelectionCollection(expression, collection) {
-  return collection.kind === "set" && expression.wireType?.type === 9 /* Lookup */;
+  return collection.kind === "set" && collection.valueType.kind !== "reference" && expression.wireType?.type === 9 /* Lookup */;
 }
 function assignableFieldList(owner) {
   if (!isNeoScriptStructuredLeafTypeName(owner)) return "a stored field";
@@ -47621,6 +49775,24 @@ function resolveNeoScriptType(type, context, project) {
         resolved = registryReference;
         break;
       }
+      if (type.name === "Reference") {
+        const [targetType] = (type.typeArguments ?? []).map(
+          (argument2) => resolveStoredReferenceTarget(argument2, context, project)
+        );
+        if (written !== 1 || targetType === void 0)
+          throw new CompileError(
+            typeArgumentArityMessage(type.name, 1, written),
+            type.pos
+          );
+        const ineligible = neoScriptReferenceTargetError(targetType, project);
+        if (ineligible !== null) throw new CompileError(ineligible, type.pos);
+        resolved = neoScriptReferenceType(
+          targetType,
+          false,
+          (named2) => isNeoScriptValueNamedType(named2, project)
+        );
+        break;
+      }
       if (type.name === "NeoDelegate") {
         if (written > NEOSCRIPT_DELEGATE_MAX_PARAMETERS + 1)
           throw new CompileError(delegateArityMessage(written), type.pos);
@@ -47660,12 +49832,15 @@ function resolveNeoScriptType(type, context, project) {
         elementType: resolveNeoScriptType(type.element, context, project)
       };
       break;
-    case "set":
+    case "set": {
+      const element = resolveNeoScriptType(type.element, context, project);
       resolved = {
         kind: "set",
-        elementType: resolveNeoScriptType(type.element, context, project)
+        // P105 §2.2. Multiselect dialogue elements are bare dialogue ids.
+        elementType: isPrimitive(element, "NeoDialogueReference") ? { kind: "primitive", name: "string" } : element
       };
       break;
+    }
     case "dict": {
       const key = resolveNeoScriptType(type.key, context, project);
       if (!isPrimitive(key, "string") && !isNamedEnum(key, project)) {
@@ -47684,6 +49859,14 @@ function resolveNeoScriptType(type, context, project) {
   }
   return { ...resolved, nullable: !type.required };
 }
+function resolveStoredReferenceTarget(type, context, project) {
+  const inner = type.kind === "named" && type.name === "Reference" && type.typeArguments?.length === 1 ? type.typeArguments[0] : void 0;
+  if (inner === void 0) return resolveNeoScriptType(type, context, project);
+  const target = resolveStoredReferenceTarget(inner, context, project);
+  const ineligible = neoScriptReferenceTargetError(target, project);
+  if (ineligible !== null) throw new CompileError(ineligible, type.pos);
+  return { kind: "reference", target, nullable: !type.required };
+}
 function methodGroupTypeArguments(symbol, mockTarget, pos) {
   return (symbol.typeParameters ?? []).map((parameter3) => {
     const declared = parameter3.type;
@@ -47723,7 +49906,12 @@ function assertTypeArgumentConstraints(declaring, type, pos, project) {
     const argument2 = type.typeArguments?.[index];
     const constraint = parameter3.type.kind === "typeParameter" ? parameter3.type.constraint : void 0;
     if (argument2 === void 0 || constraint === void 0) return;
-    const expected = substituteTypeParameters(constraint, type, declaring);
+    const expected = substituteTypeParameters(
+      constraint,
+      type,
+      declaring,
+      project
+    );
     if (isNeoScriptTypeAssignable(argument2, expected, project)) return;
     throw new CompileError(
       `Type argument '${formatType(argument2, project)}' does not satisfy '${parameter3.name} extends ${formatType(expected, project)}' on '${declaring.name}'.`,
@@ -49001,9 +51189,16 @@ function memberType(member, environment, visiting, field) {
     const collection = collectionMemberId === null ? void 0 : environment.members.get(collectionMemberId);
     const collectionType = collection ? memberType(collection, environment, next, `${field}.collection`) : unknownType();
     const declared = optionalRecord(member.declaredType);
-    const declaredType = declared ? manifestType(declared, environment, `${field}.declaredType`) : null;
+    const declaredType = declared ? manifestStoredType(declared, environment, `${field}.declaredType`) : null;
     const entryType = declaredType && !isUnknownType2(declaredType) ? declaredType : collectionElementType(collectionType) ?? unknownType();
-    return member.multiselect === true ? { kind: "set", elementType: entryType, nullable: nullable2 } : { ...entryType, nullable: nullable2 };
+    if (isUnknownType2(entryType)) {
+      return member.multiselect === true ? { kind: "set", elementType: entryType, nullable: nullable2 } : { ...entryType, nullable: nullable2 };
+    }
+    return member.multiselect === true ? {
+      kind: "set",
+      elementType: manifestReferenceType(entryType, false, environment),
+      nullable: nullable2
+    } : manifestReferenceType(entryType, nullable2, environment);
   }
   if (kind === "dialogueLookup") {
     return member.multiselect === true ? { kind: "set", elementType: primitive("string", false), nullable: nullable2 } : { ...primitive("NeoDialogueReference", false), nullable: nullable2 };
@@ -49071,10 +51266,39 @@ function manifestReturnType(value, environment, field) {
   const type = record2(value, field);
   return type.kind === "void" ? primitive("void", false) : manifestType(type, environment, field);
 }
+function isManifestValueType(typeId, environment) {
+  if (environment.enums.has(typeId)) return true;
+  const name = environment.classes.get(typeId)?.name;
+  return typeof name === "string" && isNeoVariantTypeName(name);
+}
+function manifestReferenceType(target, nullable2, environment) {
+  return neoScriptReferenceType(
+    target,
+    nullable2,
+    (named) => isManifestValueType(named.typeId, environment)
+  );
+}
+function manifestStoredType(value, environment, field) {
+  const type = record2(value, field);
+  if (type.kind !== "reference") return manifestType(type, environment, field);
+  const nullable2 = boolean(type.nullable, `${field}.nullable`);
+  return {
+    kind: "reference",
+    target: manifestStoredType(type.target, environment, `${field}.target`),
+    ...nullable2 ? { nullable: nullable2 } : {}
+  };
+}
 function manifestType(value, environment, field) {
   const type = record2(value, field);
   const kind = string(type.kind, `${field}.kind`);
   const nullable2 = boolean(type.nullable, `${field}.nullable`);
+  if (kind === "reference") {
+    return manifestReferenceType(
+      manifestStoredType(type.target, environment, `${field}.target`),
+      nullable2,
+      environment
+    );
+  }
   const primitiveName = manifestPrimitive(kind);
   if (primitiveName) return primitive(primitiveName, nullable2);
   if (kind === "unknown") return { ...unknownType(), nullable: nullable2 };
@@ -49777,35 +52001,6 @@ function getInterfaceMemberKeyOrder(neoInterface) {
   return result;
 }
 
-// ../packages/models/src/variants/variant-member.ts
-function neoVariantSystemClass(classes, lookup = false) {
-  const declared = classes.find(
-    (item) => item.system?.worldKind === (lookup ? NeoWorldSystemClassKind.LookupVariant : NeoWorldSystemClassKind.Variant)
-  );
-  if (declared === void 0) {
-    throw new Error(
-      `Canonical ${lookup ? "NeoLookupVariant" : "NeoVariant"} system class is missing.`
-    );
-  }
-  const targetParamId = declared.genericParams?.[0]?.id;
-  if (targetParamId === void 0) {
-    throw new Error(
-      `Canonical ${lookup ? "NeoLookupVariant" : "NeoVariant"} system class "${declared.id}" is missing its target generic parameter.`
-    );
-  }
-  const valueParamId = declared.genericParams?.[1]?.id;
-  if (lookup && valueParamId === void 0) {
-    throw new Error(
-      `Canonical NeoLookupVariant system class "${declared.id}" is missing its value generic parameter.`
-    );
-  }
-  return {
-    classId: declared.id,
-    targetParamId,
-    ...valueParamId === void 0 ? {} : { valueParamId }
-  };
-}
-
 // ../src/database/neoscript/project-file-registry.ts
 var PROJECT_FILE_REGISTRIES = [
   {
@@ -51046,11 +53241,16 @@ function memberRuntimeType(record4, context, seen = /* @__PURE__ */ new Set(), g
         genericEnvironment
       ));
       if (!entry) return UNKNOWN_TYPE;
-      return isMultiSelectionMember(member) ? {
-        kind: "set",
-        elementType: requiredType(entry),
-        nullable: !required
-      } : { ...entry, nullable: !required };
+      if (isMultiSelectionMember(member)) {
+        const element = analyzerReferenceType(entry, false, context);
+        return {
+          kind: "set",
+          elementType: element.kind === "reference" ? element : requiredType(entry),
+          nullable: !required
+        };
+      }
+      const reference = analyzerReferenceType(entry, !required, context);
+      return reference.kind === "reference" ? reference : { ...entry, nullable: !required };
     }
     case 10 /* NSProperty */:
       if (isMemberNSPropertyBase(member) || isMemberNSPropertyContractBase(member)) {
@@ -51142,6 +53342,7 @@ function memberRuntimeType(record4, context, seen = /* @__PURE__ */ new Set(), g
       };
     }
     case 22 /* Interface */:
+    case 29 /* Reference */:
       return UNKNOWN_TYPE;
   }
 }
@@ -51249,6 +53450,16 @@ function toLanguageType(type, context, genericEnvironment) {
     }
     case 22 /* Interface */:
       return namedType(type.interfaceId, required);
+    case 29 /* Reference */:
+      return {
+        kind: "reference",
+        target: toLanguageType(
+          type.targetTypeInfo,
+          context,
+          genericEnvironment
+        ),
+        nullable: !required
+      };
     case 8 /* Enum */:
       return namedType(type.enumId, required);
     case 6 /* List */:
@@ -51290,11 +53501,8 @@ function toLanguageType(type, context, genericEnvironment) {
     case 9 /* Lookup */:
       return {
         kind: "set",
-        elementType: toLanguageType(
-          type.entryTypeInfo,
-          context,
-          genericEnvironment
-        ),
+        // P105 §2.2. Multiselect dialogue elements are bare dialogue ids.
+        elementType: type.entryTypeInfo.type === 18 /* DialogueLookup */ ? primitive2("string", true) : toLanguageType(type.entryTypeInfo, context, genericEnvironment),
         nullable: !required
       };
     case 25 /* NSDelegate */:
@@ -51462,13 +53670,19 @@ function functionReturnType(type, context, genericEnvironment) {
 function primitive2(name, required) {
   return { kind: "primitive", name, nullable: !required };
 }
+function analyzerReferenceType(target, nullable2, context) {
+  return neoScriptReferenceType(target, nullable2, (named) => {
+    if (analyzerSchemaIndex(context).enum(named.typeId)) return true;
+    return isVariantClassId(named.typeId);
+  });
+}
 function namedType(typeId, required) {
   return { kind: "named", typeId, nullable: !required };
 }
 function requiredType(type) {
   return { ...type, nullable: false };
 }
-function collectionEntryType(type) {
+function collectionEntryType2(type) {
   if (type.kind === "list" || type.kind === "set") return type.elementType;
   if (type.kind === "dictionary") return type.valueType;
   return null;
@@ -51476,7 +53690,7 @@ function collectionEntryType(type) {
 function lookupCollectionEntryType(collectionMemberId, context, seen, genericEnvironment) {
   const collection = analyzerMemberById(context, collectionMemberId);
   if (!collection) return null;
-  return collectionEntryType(
+  return collectionEntryType2(
     memberRuntimeType(collection, context, new Set(seen), genericEnvironment)
   );
 }
@@ -52423,9 +54637,9 @@ function decodeConvexOpaqueJson(value, context) {
 // ../convex/projectRecordSnapshotStorage.ts
 function decodeProjectRecordSnapshotData(snapshot, context = `Project record snapshot for ${snapshot.recordKind} "${snapshot.recordId}" dataJson`) {
   const decoded = decodeConvexOpaqueJson(snapshot.dataJson, context);
-  if (!isPlainRecord(decoded)) return decoded;
+  if (!isPlainRecord2(decoded)) return decoded;
   const hydratedData = { ...decoded };
-  if (snapshot.recordKind === "enum" && !Object.hasOwn(hydratedData, "optionKeyOrder") && isPlainRecord(hydratedData.options)) {
+  if (snapshot.recordKind === "enum" && !Object.hasOwn(hydratedData, "optionKeyOrder") && isPlainRecord2(hydratedData.options)) {
     hydratedData.optionKeyOrder = Object.keys(hydratedData.options);
   }
   hydratedData.id = snapshot.recordId;
@@ -52437,7 +54651,7 @@ function decodeProjectRecordSnapshotData(snapshot, context = `Project record sna
   }
   return hydratedData;
 }
-function isPlainRecord(value) {
+function isPlainRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -54611,7 +56825,7 @@ var BOOL_TYPE_INFO = {
   type: 1 /* Bool */,
   required: true
 };
-var STRING_TYPE_INFO = {
+var STRING_TYPE_INFO2 = {
   type: 3 /* String */,
   required: true
 };
@@ -56435,6 +58649,17 @@ var schemaGenericParameterSchema = strictObject({
   source: schemaSourceSpanSchema,
   selectionSpan: schemaSourceSpanSchema
 });
+function isSchemaReferenceTarget(type) {
+  switch (type.kind) {
+    case "null":
+    case "unknown":
+    case "delegate":
+    case "action":
+      return false;
+    default:
+      return true;
+  }
+}
 var primitiveTypeKinds = [
   "null",
   "bool",
@@ -56519,6 +58744,9 @@ function schemaTypeOptionsAtDepth(depth) {
         "A lookup collection value requires a collection member."
       )
     ),
+    nullableTypeSchema("reference", {
+      target: schemaTypeAtDepth(depth + 1)
+    }),
     nullableTypeSchema("delegate", {
       returnType: schemaFunctionReturnTypeAtDepth(depth + 1),
       argumentTypes: pipe(
@@ -56811,8 +59039,8 @@ var schemaMemberSchema = variant("kind", [
       "A lookup collection value requires a collection member."
     ),
     check(
-      (member) => member.collectionMemberId !== null || member.declaredType?.kind === "class" || member.declaredType?.kind === "generic",
-      "A lookup without a collection needs a class or generic declared type."
+      (member) => member.collectionMemberId !== null || member.declaredType !== null && isSchemaReferenceTarget(member.declaredType),
+      "A lookup without a collection needs a value type."
     )
   ),
   memberSchema("dialogueLookup", {
@@ -56935,7 +59163,8 @@ var MEMBER_KIND = {
   NSDelegate: 25,
   NSAction: 26,
   Variant: 27,
-  Set: 28
+  Set: 28,
+  Reference: 29
 };
 var MEMBER_MODIFIERS = ["virtual", "sealed", "abstract", "static"];
 var MEMBER_ACCESS = ["public", "protected", "private"];
@@ -57889,6 +60118,17 @@ function documentTypeToManifest(value, record4, path) {
       )
     };
   }
+  if (kind === MEMBER_KIND.Reference) {
+    return {
+      kind: "reference",
+      nullable: nullable2,
+      target: documentTypeToManifest(
+        typeInfo.targetTypeInfo,
+        record4,
+        `${path}.targetTypeInfo`
+      )
+    };
+  }
   if (kind === MEMBER_KIND.Lookup) {
     const collectionValueId = optionalStringOrNull(typeInfo.collectionValueId);
     const collectionMemberId = optionalStringOrNull(
@@ -58054,6 +60294,13 @@ function manifestTypeToDocument(type) {
       argumentTypes: type.argumentTypes.map(manifestTypeToDocument)
     };
   }
+  if (type.kind === "reference") {
+    return {
+      type: MEMBER_KIND.Reference,
+      required,
+      targetTypeInfo: manifestTypeToDocument(type.target)
+    };
+  }
   if (type.kind === "action") {
     return {
       type: MEMBER_KIND.NSAction,
@@ -59638,7 +61885,7 @@ var INITIALIZER_KEY_PLACEHOLDER = new RegExp(
 
 // ../packages/manifest/schema-contract/registry.mjs
 var PROJECT_SCHEMA_CONTRACT = Object.freeze({
-  cliVersion: "0.81.5",
+  cliVersion: "0.82.0",
   projectFileUploadBatchSize: 32,
   documentRecords: {
     member: {
@@ -61479,7 +63726,7 @@ var SCRIPT_COLLECTION_READERS = {
 };
 
 // ../src/models/exports/unity-codegen-revision.ts
-var UNITY_CODEGEN_REVISION = "c3d56ed8b41f473d0023ec967df2a4f75507b760551edf58026f5163ee546006";
+var UNITY_CODEGEN_REVISION = "4eae63e39962f0ceb684c43fe8932b031b420c82ad6319670c46608bd9cd1470";
 
 // src/export-cache.ts
 var CACHE_BUILD = JSON.stringify([