@neocompose/cli 0.84.3 → 0.84.5

package/dist/neo-runtime.mjs

@@ -3100,14 +3100,14 @@ function isNSFunctionContains(value) {
   if (v?.type !== "contains" /* contains */) return false;
   const info = v.info;
   if (typeof info !== "object" || info === null) return false;
-  return isNSPointer(info.collectionPointer) && isNSPointer(info.valuePointer) && isReferenceFlag(info.reference);
+  return isNSPointer(info.collectionPointer) && isNSPointer(info.valuePointer) && isReferenceFlag(info.reference) && (info.float === void 0 || info.float === true) && (info.decimal === void 0 || info.decimal === true);
 }
 function isNSFunctionIndexOf(value) {
   const v = value;
   if (v?.type !== "indexOf" /* indexOf */) return false;
   const info = v.info;
   if (typeof info !== "object" || info === null) return false;
-  return isNSPointer(info.collectionPointer) && isNSPointer(info.valuePointer) && isReferenceFlag(info.reference);
+  return isNSPointer(info.collectionPointer) && isNSPointer(info.valuePointer) && isReferenceFlag(info.reference) && (info.float === void 0 || info.float === true) && (info.decimal === void 0 || info.decimal === true);
 }
 function isNSFunctionStringOp(value) {
   const v = value;
@@ -3255,7 +3255,7 @@ function isNSFunctionCollectionQuery(value) {
     case "Reverse":
       return true;
     case "ToSet":
-      return info.reference === void 0 || info.reference === true;
+      return (info.reference === void 0 || info.reference === true) && (info.decimalEntries === void 0 || info.decimalEntries === true);
     default:
       return false;
   }
@@ -17587,7 +17587,7 @@ var init_registry = __esm({
   "../packages/manifest/schema-contract/registry.mjs"() {
     "use strict";
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
-      cliVersion: "0.84.3",
+      cliVersion: "0.84.5",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -31651,13 +31651,22 @@ function neoScriptMemberLookupType(type) {
     nullable2 ||= current.constraint.nullable === true;
     current = current.constraint;
   }
+  if (current.kind === "named" && type.narrowedInterfaces !== void 0) {
+    current = {
+      ...current,
+      narrowedInterfaces: {
+        ...current.narrowedInterfaces,
+        ...type.narrowedInterfaces
+      }
+    };
+  }
   return nullable2 && current.nullable !== true ? { ...current, nullable: true } : current;
 }
 function neoScriptMemberReceiverType(type, memberName, project) {
   const primary = neoScriptMemberLookupType(type);
-  if (primary.kind !== "named" || primary.narrowedInterfaces === void 0)
+  if (primary.kind !== "named" && primary.kind !== "typeParameter" || primary.narrowedInterfaces === void 0)
     return primary;
-  const declaration = project.typeById.get(primary.typeId);
+  const declaration = primary.kind === "named" ? project.typeById.get(primary.typeId) : void 0;
   if (declaration?.kind === "class" && (memberName === NEOSCRIPT_CLASS_ID_MEMBER || memberName === "Clone"))
     return primary;
   if (declaration?.members.some((member) => member.name === memberName))
@@ -31986,12 +31995,12 @@ function isNeoScriptTypeAssignable(source, target, project) {
   if (isUnknownType(source) || isUnknownType(target)) return false;
   if (isNullType(source)) return isNullableType2(target);
   if (isNullableType2(source) && !isNullableType2(target)) return false;
-  if (target.kind === "named" && target.narrowedInterfaces !== void 0) {
+  if ((target.kind === "named" || target.kind === "typeParameter") && target.narrowedInterfaces !== void 0) {
     for (const bound of Object.values(target.narrowedInterfaces)) {
       if (!isNeoScriptTypeAssignable(source, bound, project)) return false;
     }
   }
-  if (source.kind === "named" && source.narrowedInterfaces !== void 0) {
+  if ((source.kind === "named" || source.kind === "typeParameter") && source.narrowedInterfaces !== void 0) {
     const direct = target.kind === "named" ? source.narrowedInterfaces[target.typeId] : void 0;
     if (direct !== void 0 && isNeoScriptTypeAssignable(direct, target, project))
       return true;
@@ -32019,7 +32028,7 @@ function isNeoScriptTypeAssignable(source, target, project) {
         project
       );
     }
-    if (!target.typeArguments?.length || project.typeById.get(target.typeId)?.kind !== "interface") {
+    if (!target.typeArguments?.length) {
       return isTypeDerivedFrom(
         project.typeById.get(source.typeId),
         target.typeId,
@@ -32027,7 +32036,7 @@ function isNeoScriptTypeAssignable(source, target, project) {
         /* @__PURE__ */ new Set()
       );
     }
-    const construction = interfaceConstruction(source, target.typeId, project);
+    const construction = supertypeConstruction(source, target.typeId, project);
     return construction !== void 0 && invariantTypeArguments(construction, target.typeArguments, project);
   }
   if (source.kind === "typeParameter" && target.kind === "typeParameter") {
@@ -32085,7 +32094,7 @@ function isNeoScriptTypeAssignable(source, target, project) {
   return false;
 }
 function withoutNeoScriptInterfaceProofs(type) {
-  if (type.kind !== "named" || type.narrowedInterfaces === void 0)
+  if (type.kind !== "named" && type.kind !== "typeParameter" || type.narrowedInterfaces === void 0)
     return type;
   const { narrowedInterfaces: _proofs, ...declared } = type;
   return declared;
@@ -32093,7 +32102,7 @@ function withoutNeoScriptInterfaceProofs(type) {
 function commonNeoScriptAssignableType(left, right, project) {
   if (isNeoScriptTypeAssignable(left, right, project)) return right;
   if (isNeoScriptTypeAssignable(right, left, project)) return left;
-  if (left.kind === "named" && right.kind === "named" && (left.narrowedInterfaces !== void 0 || right.narrowedInterfaces !== void 0)) {
+  if ((left.kind === "named" || left.kind === "typeParameter") && (right.kind === "named" || right.kind === "typeParameter") && (left.narrowedInterfaces !== void 0 || right.narrowedInterfaces !== void 0)) {
     const declaredLeft = withoutNeoScriptInterfaceProofs(left);
     const declaredRight = withoutNeoScriptInterfaceProofs(right);
     const common = commonNeoScriptAssignableType(
@@ -32101,7 +32110,8 @@ function commonNeoScriptAssignableType(left, right, project) {
       declaredRight,
       project
     );
-    if (common?.kind !== "named") return null;
+    if (common?.kind !== "named" && common?.kind !== "typeParameter")
+      return null;
     const proofs = {};
     for (const [source, other] of [
       [left, right],
@@ -32154,41 +32164,53 @@ function interfaceInstantiationMessage(declared, expected, project) {
   }
   return message;
 }
-function interfaceConstruction(source, interfaceId, project, seen = /* @__PURE__ */ new Set()) {
-  if (source.typeId === interfaceId) return source.typeArguments ?? [];
-  const type = project.typeById.get(source.typeId);
-  if (type === void 0 || seen.has(type.id)) return void 0;
-  seen.add(type.id);
-  const bindings = /* @__PURE__ */ new Map();
-  type.typeParameters?.forEach((parameter4, index) => {
-    const argument2 = source.typeArguments?.[index];
-    if (argument2 !== void 0)
-      bindings.set(parameter4.id ?? parameter4.name, argument2);
-  });
-  for (const id2 of [
-    ...type.baseTypeIds ?? [],
-    ...type.interfaceTypeIds ?? []
-  ]) {
-    const supertype = {
-      kind: "named",
-      typeId: id2,
-      typeArguments: (type.supertypeArguments?.[id2] ?? []).map(
-        (argument2) => substituteNeoScriptTypeParameters(
-          argument2,
-          (parameter4) => bindings.get(parameter4.id),
-          project
-        )
-      )
-    };
-    const found = interfaceConstruction(supertype, interfaceId, project, seen);
-    if (found !== void 0) return found;
+function supertypeConstruction(source, supertypeId, project) {
+  for (const type of constructedSupertypes(source, project)) {
+    if (type.typeId === supertypeId) return type.typeArguments ?? [];
   }
   return void 0;
 }
+function* constructedSupertypes(source, project) {
+  const pending = [source];
+  const seen = /* @__PURE__ */ new Set();
+  while (true) {
+    const current = pending.pop();
+    if (current === void 0) return;
+    if (seen.has(current.typeId)) continue;
+    seen.add(current.typeId);
+    yield current;
+    const type = project.typeById.get(current.typeId);
+    if (type === void 0) continue;
+    const bindings = /* @__PURE__ */ new Map();
+    type.typeParameters?.forEach((parameter4, index) => {
+      const argument2 = current.typeArguments?.[index];
+      if (argument2 !== void 0)
+        bindings.set(parameter4.id ?? parameter4.name, argument2);
+    });
+    const parents = [
+      ...type.baseTypeIds ?? [],
+      ...type.interfaceTypeIds ?? []
+    ];
+    for (const id2 of parents.reverse()) {
+      if (seen.has(id2)) continue;
+      pending.push({
+        kind: "named",
+        typeId: id2,
+        typeArguments: (type.supertypeArguments?.[id2] ?? []).map(
+          (argument2) => substituteNeoScriptTypeParameters(
+            argument2,
+            (parameter4) => bindings.get(parameter4.id),
+            project
+          )
+        )
+      });
+    }
+  }
+}
 function interfaceUndeterminedReason(classType, interfaceType2, project) {
   const params = classType.typeParameters ?? [];
   if (params.length === 0) return null;
-  const construction = interfaceConstruction(
+  const construction = supertypeConstruction(
     {
       kind: "named",
       typeId: classType.id,
@@ -33971,7 +33993,7 @@ function implementerConstruction(implementer, slotInterface, slot, project) {
     );
     if (reason !== null) return void 0;
   }
-  const implemented = interfaceConstruction(
+  const implemented = supertypeConstruction(
     {
       kind: "named",
       typeId: implementer.id,
@@ -34422,9 +34444,7 @@ function typeRefsEqual(left, right) {
   if (left.kind === "primitive" && right.kind === "primitive") {
     return left.name === right.name;
   }
-  if (left.kind === "named" && right.kind === "named") {
-    const leftArgs = left.typeArguments ?? [];
-    const rightArgs = right.typeArguments ?? [];
+  if ((left.kind === "named" || left.kind === "typeParameter") && (right.kind === "named" || right.kind === "typeParameter")) {
     if (left.narrowedInterfaces !== right.narrowedInterfaces) {
       const leftBounds = Object.entries(left.narrowedInterfaces ?? {});
       const rightBounds = right.narrowedInterfaces ?? {};
@@ -34435,6 +34455,10 @@ function typeRefsEqual(left, right) {
           return false;
       }
     }
+  }
+  if (left.kind === "named" && right.kind === "named") {
+    const leftArgs = left.typeArguments ?? [];
+    const rightArgs = right.typeArguments ?? [];
     return left.typeId === right.typeId && leftArgs.length === rightArgs.length && leftArgs.every((item, index) => {
       const other = rightArgs[index];
       return other !== void 0 && typeRefsEqual(item, other);
@@ -35416,6 +35440,20 @@ function typesOverlap(left, right, project) {
   if (isNull(right)) return isNullable(left);
   left = neoScriptMemberLookupType(left);
   right = neoScriptMemberLookupType(right);
+  const declaredLeft = withoutNeoScriptInterfaceProofs(left);
+  const declaredRight = withoutNeoScriptInterfaceProofs(right);
+  if (left.kind === "named" || left.kind === "typeParameter") {
+    for (const proof of Object.values(left.narrowedInterfaces ?? {})) {
+      if (!typesOverlap(proof, declaredRight, project)) return false;
+    }
+  }
+  if (right.kind === "named" || right.kind === "typeParameter") {
+    for (const proof of Object.values(right.narrowedInterfaces ?? {})) {
+      if (!typesOverlap(declaredLeft, proof, project)) return false;
+    }
+  }
+  left = declaredLeft;
+  right = declaredRight;
   if (left.kind === "typeParameter" || right.kind === "typeParameter")
     return true;
   if (isNeoScriptTypeAssignable(left, right, project) || isNeoScriptTypeAssignable(right, left, project))
@@ -35429,11 +35467,29 @@ function typesOverlap(left, right, project) {
     const classDeclaration = leftDeclaration?.kind === "class" ? leftDeclaration : rightDeclaration?.kind === "class" ? rightDeclaration : null;
     const interfaceDeclaration = leftDeclaration?.kind === "interface" ? leftDeclaration : rightDeclaration?.kind === "interface" ? rightDeclaration : null;
     if (classDeclaration !== null && interfaceDeclaration !== null) {
+      if (conflictingInterfaceConstructions(left, right, project)) return false;
       return classDeclaration.sealed !== true;
     }
   }
   return isNumeric(left) && isNumeric(right);
 }
+function conflictingInterfaceConstructions(left, right, project) {
+  const constructions = /* @__PURE__ */ new Map();
+  for (const type of constructedSupertypes(left, project)) {
+    if (project.typeById.get(type.typeId)?.kind === "interface" && type.typeArguments?.length)
+      constructions.set(type.typeId, type.typeArguments);
+  }
+  for (const type of constructedSupertypes(right, project)) {
+    const argumentsList2 = constructions.get(type.typeId);
+    if (!argumentsList2) continue;
+    if (argumentsList2.some((argument2, index) => {
+      const other = type.typeArguments?.[index];
+      return other !== void 0 && !containsTypeParameter(argument2) && !containsTypeParameter(other) && !(isNeoScriptTypeAssignable(argument2, other, project) && isNeoScriptTypeAssignable(other, argument2, project));
+    }))
+      return true;
+  }
+  return false;
+}
 function isUnknown(type) {
   return type.kind === "primitive" && type.name === "unknown";
 }
@@ -36144,10 +36200,12 @@ var init_strict_resolver = __esm({
       constructor(parent, probe = parent?.probe ?? false) {
         this.parent = parent;
         this.probe = probe;
+        this.externalRoots = parent?.externalRoots ?? /* @__PURE__ */ new Map();
         this.patternBindings = parent?.patternBindings ?? null;
       }
       parent;
       probe;
+      externalRoots;
       entries = /* @__PURE__ */ new Map();
       invalidatedRoots = /* @__PURE__ */ new Set();
       hiddenNarrowingRoots = /* @__PURE__ */ new Set();
@@ -36170,7 +36228,15 @@ var init_strict_resolver = __esm({
       lookup(name) {
         return this.entries.get(name) ?? this.parent?.lookup(name) ?? null;
       }
+      registerExternalRoot(name, type) {
+        if (!this.externalRoots.has(name))
+          this.externalRoots.set(name, { name, type, variableId: name });
+      }
+      lookupFlowRoot(name) {
+        return this.lookup(name) ?? this.externalRoots.get(name) ?? null;
+      }
       containsEntry(entry) {
+        if (this.externalRoots.get(entry.name) === entry) return true;
         for (const candidate of this.entries.values()) {
           if (candidate === entry) return true;
         }
@@ -36228,6 +36294,7 @@ var init_strict_resolver = __esm({
         if (path === rootEntry.name) this.updatePatternType(rootEntry, type);
       }
       updatePatternType(entry, type) {
+        if (this.externalRoots.get(entry.name) === entry) return;
         if (this.probe || entry.patternBinding)
           this.patternBindings = {
             name: entry.name,
@@ -36871,7 +36938,7 @@ var init_strict_resolver = __esm({
                 branchExitNarrowings,
                 this.project
               )) {
-                const rootEntry = scope.lookup(pathRoot(path));
+                const rootEntry = scope.lookupFlowRoot(pathRoot(path));
                 if (rootEntry === narrowed.rootEntry) {
                   scope.narrow(path, rootEntry, narrowed.type);
                 }
@@ -37804,7 +37871,7 @@ var init_strict_resolver = __esm({
         }
         for (const [path, narrowed] of merged) {
           if (!parent.containsEntry(narrowed.rootEntry)) continue;
-          const rootEntry = parent.lookup(pathRoot(path));
+          const rootEntry = parent.lookupFlowRoot(pathRoot(path));
           if (rootEntry === narrowed.rootEntry) {
             parent.narrow(path, rootEntry, narrowed.type);
           }
@@ -38031,7 +38098,7 @@ var init_strict_resolver = __esm({
           scope
         );
         if (assignedPath) {
-          const rootEntry = scope.lookup(pathRoot(assignedPath));
+          const rootEntry = scope.lookupFlowRoot(pathRoot(assignedPath));
           if (rootEntry) {
             const retainedFacts = unaffectedNarrowings(
               assignedPath,
@@ -38078,11 +38145,7 @@ var init_strict_resolver = __esm({
       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 assigned = source === void 0 ? void 0 : this.resolveReferenceAssignmentValue(source, scope, 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);
@@ -38126,6 +38189,30 @@ var init_strict_resolver = __esm({
         }
         return { target: layer, value: valueAt(layer.type), through };
       }
+      resolveReferenceAssignmentValue(expression, scope, storageType) {
+        if (expression.kind === "conditional") {
+          return this.resolveConditionalExpression(
+            expression,
+            scope,
+            neoScriptReadType(storageType),
+            storageType
+          );
+        }
+        if (expression.kind === "coalesce") {
+          return this.resolveCoalesceExpression(
+            expression,
+            scope,
+            void 0,
+            storageType
+          );
+        }
+        const expected = neoScriptReadType(storageType);
+        return this.resolveReferenceExpression(
+          expression,
+          scope,
+          expression.kind === "litNull" ? void 0 : expected
+        );
+      }
       /** `Reference<target>` as an expression type (P112 §3.1). */
       referenceType(target, nullable2) {
         return neoScriptReferenceType(
@@ -38286,7 +38373,7 @@ var init_strict_resolver = __esm({
               false
             ).type;
           }
-          return resolvedTarget.type;
+          return this.resolveIdentifierNatural(targetAst.name, scope, targetAst.pos).type;
         }
         if (targetAst.kind !== "member") return resolvedTarget.type;
         return this.resolveMemberNatural(
@@ -38529,7 +38616,7 @@ var init_strict_resolver = __esm({
           scope
         );
         if (assignedPath) {
-          const rootEntry = scope.lookup(pathRoot(assignedPath));
+          const rootEntry = scope.lookupFlowRoot(pathRoot(assignedPath));
           if (rootEntry) {
             const retainedFacts = unaffectedNarrowings(
               assignedPath,
@@ -39265,34 +39352,8 @@ var init_strict_resolver = __esm({
               ...operand.writeRoot ? { writeRoot: operand.writeRoot } : {}
             };
           }
-          case "coalesce": {
-            const left = this.resolveExpression(expression.left, scope);
-            const leftOptional = { ...left.type, nullable: true };
-            const nullLeft = isNull(left.type);
-            const right = this.resolveExpression(
-              expression.right,
-              scope,
-              nullLeft ? expected : leftOptional
-            );
-            if (!nullLeft && !isNeoScriptTypeAssignable(right.type, leftOptional, this.project)) {
-              throw new CompileError(
-                `\`??\` right operand ${this.describe(right.type)} is not assignable to ${this.describe(leftOptional)}`,
-                expression.pos
-              );
-            }
-            const resultType = nullLeft ? right.type : {
-              ...left.type,
-              nullable: isNullable(left.type) && isNullable(right.type)
-            };
-            return {
-              pointer: {
-                type: "coalesce" /* Coalesce */,
-                left: left.pointer,
-                right: right.pointer
-              },
-              type: resultType
-            };
-          }
+          case "coalesce":
+            return this.resolveCoalesceExpression(expression, scope, expected);
           case "conditional":
             return this.resolveConditionalExpression(expression, scope, expected);
           case "is": {
@@ -39869,6 +39930,21 @@ var init_strict_resolver = __esm({
         };
       }
       resolveIdentifier(name, scope, pos, usage2 = "value") {
+        const natural = this.resolveIdentifierNatural(name, scope, pos, usage2);
+        if (scope.lookup(name)) return natural;
+        const path = this.narrowingPath(name, scope);
+        const root = path === null ? null : scope.lookupFlowRoot(pathRoot(path));
+        const narrowed = root && path ? scope.lookupNarrowedType(path, root) : null;
+        const resolved = narrowed ? { ...natural, type: narrowed } : natural;
+        this.options.onFlowScope?.({
+          name,
+          position: pos,
+          type: resolved.type,
+          bindings: scope.patternBindings
+        });
+        return resolved;
+      }
+      resolveIdentifierNatural(name, scope, pos, usage2 = "value") {
         if (name === "this" && this.context.kind === "initializer" && this.delegateCaptureContexts.length === 0 && usage2 === "value") {
           throw new CompileError(
             "'this' is unavailable while an initializer runs. Defer instance access with a lambda or method group.",
@@ -39901,7 +39977,7 @@ var init_strict_resolver = __esm({
           };
         }
         const global = this.context.project.globals.find(
-          (candidate) => candidate.name === name
+          (symbol) => symbol.name === name
         );
         if (global) return this.symbolValue(global);
         const implicit = this.implicitMember(name);
@@ -40043,11 +40119,29 @@ var init_strict_resolver = __esm({
         if (path === null) return null;
         const root = pathRoot(path);
         if (scope.lookup(root)) return path;
-        if (this.context.project.globals.some((symbol) => symbol.name === root)) {
-          return path;
+        const global = this.context.project.globals.find(
+          (symbol) => symbol.name === root
+        );
+        if (global) {
+          const key = `global:${root}`;
+          scope.registerExternalRoot(key, global.type);
+          return key + path.slice(root.length);
         }
         const implicit = this.implicitMember(root);
-        return implicit && implicit.symbol.static !== true ? `this.${path}` : path;
+        if (implicit && implicit.symbol.static !== true) return `this.${path}`;
+        const owner = implicit?.owner ?? this.project.typeByName.get(root);
+        if (owner) {
+          const memberName = implicit?.symbol.name ?? path.slice(root.length + 1).split(".")[0];
+          const member = implicit?.symbol ?? owner.members.find((candidate) => candidate.name === memberName);
+          const declaring = member?.inheritedFrom;
+          const key = `static:${declaring?.typeName ?? owner.name}`;
+          scope.registerExternalRoot(key, {
+            kind: "named",
+            typeId: declaring?.typeId ?? owner.id
+          });
+          return implicit ? `${key}.${path}` : key + path.slice(root.length);
+        }
+        return path;
       }
       conditionFacts(expression, scope, whenTrue) {
         const pathOf = (value) => this.narrowingPath(canonicalPath(value), scope);
@@ -40065,7 +40159,7 @@ var init_strict_resolver = __esm({
           locals
         )) {
           const path = this.narrowingPath(assignedPath, outerScope);
-          const outerEntry = path === null ? null : outerScope.lookup(pathRoot(path));
+          const outerEntry = path === null ? null : outerScope.lookupFlowRoot(pathRoot(path));
           if (outerEntry && path !== null) {
             const retained = unaffectedNarrowings(path, outerEntry, loopEntryScope);
             loopEntryScope.hideInheritedNarrowing(outerEntry);
@@ -40083,7 +40177,7 @@ var init_strict_resolver = __esm({
             targetScope
           );
           const natural = this.readReferences(place, void 0);
-          const rootEntry = fact.path === null ? null : targetScope.lookup(pathRoot(fact.path));
+          const rootEntry = fact.path === null ? null : targetScope.lookupFlowRoot(pathRoot(fact.path));
           if (fact.nullValue) {
             if (fact.path === null || rootEntry === null) continue;
             if (place.type.kind === "reference" && !isNullable(place.type)) {
@@ -40104,7 +40198,7 @@ var init_strict_resolver = __esm({
             const targetDefinition = target.kind === "named" ? this.project.typeById.get(target.typeId) : void 0;
             const naturalDefinition = natural.type.kind === "named" ? this.project.typeById.get(natural.type.typeId) : void 0;
             let narrowed = { ...target, nullable: false };
-            if (!fact.bindingName && natural.type.kind === "named" && (naturalDefinition?.kind === "class" || naturalDefinition?.kind === "interface") && target.kind === "named" && targetDefinition?.kind === "interface") {
+            if ((natural.type.kind === "typeParameter" || natural.type.kind === "named" && (naturalDefinition?.kind === "class" || naturalDefinition?.kind === "interface")) && target.kind === "named" && targetDefinition?.kind === "interface") {
               narrowed = { ...natural.type, nullable: false };
               if (!isNeoScriptTypeAssignable(narrowed, target, this.project)) {
                 narrowed = {
@@ -40116,6 +40210,22 @@ var init_strict_resolver = __esm({
                 };
               }
             }
+            if (target.kind === "named" && targetDefinition?.kind === "class") {
+              const lookup = neoScriptMemberLookupType(natural.type);
+              if (lookup.kind === "named" || lookup.kind === "typeParameter") {
+                const { narrowedInterfaces, ...declared } = lookup;
+                const proofs = declared.kind === "named" && this.project.typeById.get(declared.typeId)?.kind === "interface" ? {
+                  ...narrowedInterfaces,
+                  [declared.typeId]: declared
+                } : narrowedInterfaces;
+                if (proofs !== void 0)
+                  narrowed = {
+                    ...target,
+                    nullable: false,
+                    narrowedInterfaces: proofs
+                  };
+              }
+            }
             if (mode === "all" && fact.path !== null && rootEntry !== null && place.type.kind !== "reference") {
               targetScope.narrow(fact.path, rootEntry, narrowed);
             }
@@ -40125,7 +40235,7 @@ var init_strict_resolver = __esm({
               }
               targetScope.definePattern({
                 name: fact.bindingName,
-                type: narrowed,
+                type: { ...target, nullable: false },
                 variableId: fact.bindingTest ? this.patternBindingId(fact.bindingTest) : fact.bindingName,
                 writeRoot: this.expressionWriteRoot(natural, targetScope),
                 pointer: fact.bindingTest ? {
@@ -40405,7 +40515,7 @@ var init_strict_resolver = __esm({
         return wire;
       }
       resolveMember(receiverAst, name, scope, pos, optional2, receiverValue) {
-        const resolved = this.resolveMemberNatural(
+        let resolved = this.resolveMemberNatural(
           receiverAst,
           name,
           scope,
@@ -40414,21 +40524,25 @@ var init_strict_resolver = __esm({
           receiverValue
         );
         if (!optional2) {
-          const receiverPath = this.narrowingPath(
-            canonicalPath(receiverAst),
+          const receiverPath = canonicalPath(receiverAst);
+          const path = this.narrowingPath(
+            receiverPath === null ? null : `${receiverPath}.${name}`,
             scope
           );
-          if (receiverPath) {
-            const rootEntry = scope.lookup(pathRoot(receiverPath));
+          if (path) {
+            const rootEntry = scope.lookupFlowRoot(pathRoot(path));
             if (rootEntry) {
-              const narrowed = scope.lookupNarrowedType(
-                `${receiverPath}.${name}`,
-                rootEntry
-              );
-              if (narrowed) return { ...resolved, type: narrowed };
+              const narrowed = scope.lookupNarrowedType(path, rootEntry);
+              if (narrowed) resolved = { ...resolved, type: narrowed };
             }
           }
         }
+        this.options.onFlowScope?.({
+          name,
+          position: pos,
+          type: resolved.type,
+          bindings: scope.patternBindings
+        });
         return resolved;
       }
       resolveStaticMemberValue(staticType, member, pos) {
@@ -42195,7 +42309,7 @@ var init_strict_resolver = __esm({
             scope
           )
         );
-        const schemaClassInfo = toWireType(targetType, this.project);
+        const schemaClassInfo = this.constructorWireType(targetType, expression);
         if (schemaClassInfo.type !== 7 /* Class */) {
           throw new Error(
             `NeoScript constructor ${className} has non-Class return type ${this.describe(signature.returnType)}.`
@@ -42213,6 +42327,16 @@ var init_strict_resolver = __esm({
           writability: "session" /* Session */
         };
       }
+      /** Constructor storage arguments stay distinct from their expression read types. */
+      constructorWireType(target, expression) {
+        const typeArguments = expression.typeArguments?.map(
+          (argument2) => resolveStoredReferenceTarget(argument2, this.context, this.project)
+        );
+        return toWireType(
+          typeArguments === void 0 ? target : { ...target, typeArguments },
+          this.project
+        );
+      }
       constructorTargetType(schemaClass2, expression, expected) {
         const typeArguments = expression.typeArguments?.map(
           (argument2) => this.resolveType(argument2)
@@ -42343,7 +42467,7 @@ var init_strict_resolver = __esm({
           scope
         );
         const classType = targetType;
-        const schemaClassInfo = toWireType(classType, this.project);
+        const schemaClassInfo = this.constructorWireType(classType, expression);
         if (schemaClassInfo.type !== 7 /* Class */) {
           throw new Error(
             `NeoScript declared constructor ${className} projected a non-Class wire type.`
@@ -43206,6 +43330,8 @@ var init_strict_resolver = __esm({
             {
               collectionPointer: receiver.pointer,
               valuePointer: value.pointer,
+              ...isPrimitive(expectedValueType, "float") ? { float: true } : {},
+              ...isPrimitive(expectedValueType, "decimal") ? { decimal: true } : {},
               ...hasReferenceEquality(collection.valueType, this.project) ? { reference: true } : {}
             },
             { kind: "primitive", name: "int" }
@@ -43235,6 +43361,8 @@ var init_strict_resolver = __esm({
             {
               collectionPointer: receiver.pointer,
               valuePointer: value.pointer,
+              ...isPrimitive(expectedValueType, "float") ? { float: true } : {},
+              ...isPrimitive(expectedValueType, "decimal") ? { decimal: true } : {},
               ...hasReferenceEquality(collection.valueType, this.project) ? { reference: true } : {}
             },
             { kind: "primitive", name: "bool" }
@@ -43467,6 +43595,7 @@ var init_strict_resolver = __esm({
             info = {
               ...base,
               op: name,
+              ...isPrimitive(collection.valueType, "decimal") ? { decimalEntries: true } : {},
               ...hasReferenceEquality(collection.valueType, this.project) ? { reference: true } : {}
             };
             resultType = {
@@ -44406,7 +44535,7 @@ var init_strict_resolver = __esm({
           scope
         );
         if (path) {
-          const rootEntry = scope.lookup(pathRoot(path));
+          const rootEntry = scope.lookupFlowRoot(pathRoot(path));
           if (rootEntry) scope.invalidate(rootEntry);
         }
         const actionTypeInfo = receiver.wireType ?? toWireType(receiver.type, this.project);
@@ -44458,7 +44587,74 @@ var init_strict_resolver = __esm({
           pos
         );
       }
-      resolveConditionalExpression(expression, scope, expected) {
+      referenceAssignmentBranches(left, right, storageType, operator) {
+        let layer = storageType;
+        while (true) {
+          const expected = operator === "coalesce" ? { ...layer, nullable: true } : layer;
+          const resolvedLeft = this.readReferences(left, expected);
+          const resolvedRight = this.readReferences(right, expected);
+          if (isNeoScriptTypeAssignable(resolvedLeft.type, expected, this.project) && isNeoScriptTypeAssignable(resolvedRight.type, expected, this.project)) {
+            return { left: resolvedLeft, right: resolvedRight, type: expected };
+          }
+          if (layer.kind !== "reference") break;
+          layer = layer.target;
+        }
+        return { left, right, type: neoScriptReadType(storageType) };
+      }
+      resolveCoalesceExpression(expression, scope, expected, assignmentType) {
+        let left;
+        let right;
+        if (assignmentType) {
+          const branches = this.referenceAssignmentBranches(
+            this.resolveReferenceAssignmentValue(
+              expression.left,
+              scope,
+              assignmentType
+            ),
+            this.resolveReferenceAssignmentValue(
+              expression.right,
+              scope,
+              assignmentType
+            ),
+            assignmentType,
+            "coalesce"
+          );
+          left = branches.left;
+          right = branches.right;
+        } else {
+          left = this.resolveExpression(
+            expression.left,
+            scope,
+            expected?.kind === "reference" ? { ...expected, nullable: true } : void 0
+          );
+          right = this.resolveExpression(
+            expression.right,
+            scope,
+            isNull(left.type) ? expected : { ...left.type, nullable: true }
+          );
+        }
+        const leftOptional = { ...left.type, nullable: true };
+        const nullLeft = isNull(left.type);
+        if (!nullLeft && !isNeoScriptTypeAssignable(right.type, leftOptional, this.project)) {
+          throw new CompileError(
+            `\`??\` right operand ${this.describe(right.type)} is not assignable to ${this.describe(leftOptional)}`,
+            expression.pos
+          );
+        }
+        const resultType = nullLeft ? right.type : {
+          ...left.type,
+          nullable: isNullable(left.type) && isNullable(right.type)
+        };
+        return {
+          pointer: {
+            type: "coalesce" /* Coalesce */,
+            left: left.pointer,
+            right: right.pointer
+          },
+          type: resultType
+        };
+      }
+      resolveConditionalExpression(expression, scope, expected, assignmentType) {
         const condition = this.toBool(
           this.resolveExpression(expression.condition, scope),
           expression.condition.pos
@@ -44475,7 +44671,38 @@ var init_strict_resolver = __esm({
         );
         let whenTrue;
         let whenFalse;
-        if (expected) {
+        if (assignmentType) {
+          whenTrue = this.resolveReferenceAssignmentValue(
+            expression.whenTrue,
+            trueScope,
+            assignmentType
+          );
+          whenFalse = this.resolveReferenceAssignmentValue(
+            expression.whenFalse,
+            falseScope,
+            assignmentType
+          );
+          let common2 = commonNeoScriptAssignableType(
+            whenTrue.type,
+            whenFalse.type,
+            this.project
+          );
+          if (isNull(whenTrue.type)) common2 = { ...whenFalse.type, nullable: true };
+          if (isNull(whenFalse.type)) common2 = { ...whenTrue.type, nullable: true };
+          if (common2) {
+            expected = common2;
+          } else {
+            const branches = this.referenceAssignmentBranches(
+              whenTrue,
+              whenFalse,
+              assignmentType,
+              "conditional"
+            );
+            whenTrue = branches.left;
+            whenFalse = branches.right;
+            expected = branches.type;
+          }
+        } else if (expected) {
           whenTrue = this.resolveExpression(
             expression.whenTrue,
             trueScope,
@@ -44512,7 +44739,7 @@ var init_strict_resolver = __esm({
             expression.pos
           );
         }
-        if (expected) {
+        if (expected && !assignmentType) {
           this.requireAssignable(
             whenTrue.type,
             expected,
@@ -50824,6 +51051,27 @@ function validateStatements(statements, returnType, scope, environment, uri, ran
   }
 }
 function validateExpression(expression, expected, scope, environment, uri, range2, diagnostics, anchor) {
+  if (expression.kind === "new" && expression.typeArguments?.length) {
+    const { context } = initializerResolver(
+      environment,
+      scope.get("this")?.name ?? "",
+      environment.staticMember
+    );
+    for (const argument2 of expression.typeArguments) {
+      try {
+        resolveNeoScriptType(argument2, context, environment.projectIndex);
+      } catch (error) {
+        if (!(error instanceof CompileError)) throw error;
+        pushDiagnostic(
+          diagnostics,
+          uri,
+          anchor ? anchorSpan(anchor, error, 1) : range2,
+          "invalid-construction-type-argument",
+          error.message.replace(/^\d+:\d+: /, "")
+        );
+      }
+    }
+  }
   if (expected?.name === "NeoDelegate" && validateDelegateMethodGroup(
     expression,
     expected,
@@ -52181,7 +52429,9 @@ function subscriptKeyType(receiver) {
   return void 0;
 }
 function validateReferenceExpression(expression, declared, scope, environment, uri, range2, diagnostics) {
-  const expected = declared?.name === "NeoDialogueReference" ? { ...declared, name: "NeoDialogue" } : declared;
+  let expected = declared?.name === "Reference" ? declared.arguments?.[0] : declared;
+  if (expected?.name === "NeoDialogueReference")
+    expected = { ...expected, name: "NeoDialogue" };
   const typeArguments = expression.typeArguments ?? [];
   const names = expression.argumentNames ?? [];
   const idIndex = names.findIndex((name) => name === "id");
@@ -60950,7 +61200,7 @@ function parseSlotPathSpellingV4(expression, isStaticSymbol) {
     return steps[0]?.kind === "member" ? { spelling: "slotPath", head: "root", steps } : null;
   }
   const first = steps[0];
-  if (first?.kind !== "member" || steps.length < 2) return null;
+  if (first?.kind !== "member") return null;
   const head = `${current.name}.${first.name}`;
   return isStaticSymbol(head) ? { spelling: "slotPath", head, steps: steps.slice(1) } : null;
 }
@@ -77662,7 +77912,7 @@ function compileNSInitializer(code, ctx) {
       {
         ...compilerContext,
         thisClass: lexicalThisClass ?? null,
-        implicitMemberAccess: lexicalThisClass !== null,
+        implicitMemberAccess: lexicalThisClass != null || declaringClass2 != null,
         staticMember: false
       },
       {
@@ -78144,7 +78394,7 @@ function compileMemberInitializerBody(args) {
         returnTypeInfo,
         initializerName: args.member.name,
         lexicalThisClass: parseExpression(defaultValue.init.code).kind === "lambda" ? instanceClass : null,
-        declaringClass: instanceClass,
+        declaringClass: args.thisClass,
         argumentTypes: initializerArgumentTypes(
           instanceClass,
           args.constructors ?? []
@@ -78193,7 +78443,7 @@ function compileValueRowInitializerBody(args) {
         lexicalThisClass: args.lexicalThisClass ?? null,
         declaringClass: args.initializerOwnerClass,
         argumentTypes: initializerArgumentTypes(
-          args.initializerOwnerClass,
+          args.lexicalThisClass === null ? null : args.initializerOwnerClass,
           args.constructors ?? []
         ),
         ...args.storedConstructionReplay === true ? { storedConstructionReplay: true } : {}
@@ -79252,16 +79502,18 @@ var init_runtime_set = __esm({
   "../packages/neoscript-runtime/src/neoscript/runtime-set.ts"() {
     "use strict";
     RuntimeSet = class {
-      constructor(source, reference2, enumEntries, slotReferences = null) {
+      constructor(source, reference2, enumEntries, slotReferences = null, decimalEntries = false) {
         this.source = source;
         this.reference = reference2;
         this.enumEntries = enumEntries;
         this.slotReferences = slotReferences;
+        this.decimalEntries = decimalEntries;
       }
       source;
       reference;
       enumEntries;
       slotReferences;
+      decimalEntries;
       entries = /* @__PURE__ */ new Map();
       validations = /* @__PURE__ */ new Map();
       snapshot;
@@ -79271,6 +79523,9 @@ var init_runtime_set = __esm({
       has(key) {
         return this.entries.has(key);
       }
+      *values() {
+        for (const entry of this.entries.values()) yield entry.raw;
+      }
       add(key, raw, reference2) {
         if (this.entries.has(key)) return;
         this.entries.set(key, { raw, reference: reference2 });
@@ -79857,12 +80112,15 @@ function initializerOwnerContext(document, valueId, rootOwners, valuesById, reco
     currentId = sourceValueId;
     lexicalRoot = rootOwners.get(sourceValueId) ?? lexicalRoot;
   }
-  if (lexicalRoot === void 0 || isStaticMember(lexicalRoot)) {
-    return { ownerClass: null, lexicalThisClass: null };
+  if (lexicalRoot === void 0) {
+    return { declaringClass: null, lexicalThisClass: null };
   }
   const lexicalRootId = getField(lexicalRoot, "id");
   const ownerClass = typeof lexicalRootId === "string" ? findSchemaPlacement(lexicalRootId, document.classes)?.ownerClass ?? null : null;
-  return { ownerClass, lexicalThisClass: ownerClass };
+  return {
+    declaringClass: ownerClass,
+    lexicalThisClass: isStaticMember(lexicalRoot) ? null : ownerClass
+  };
 }
 function isClassRecordValue(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
@@ -82925,7 +83183,14 @@ function evaluateNSGetterWithEffects(getter, ctx, argumentValues = [], options =
   for (let index = 0; index < argumentValues.length; index += 1) {
     const parameter4 = parameters[index];
     if (parameter4 === void 0) continue;
-    scope.setLocal(parameter4.id, argumentValues[index]);
+    scope.setLocal(
+      parameter4.id,
+      coerceAssignmentValue(
+        argumentValues[index],
+        parameter4.typeInfo,
+        "getter argument"
+      )
+    );
   }
   try {
     const result = evalBody(
@@ -82935,9 +83200,11 @@ function evaluateNSGetterWithEffects(getter, ctx, argumentValues = [], options =
       evaluationOptions(runtimeCtx, false)
     );
     if (result.kind === "return") {
-      if (getter.typeInfo.type === 20 /* Decimal */ && typeof result.value === "number") {
-        result.value = coerceDecimalOperand(result.value, "return");
-      }
+      result.value = coerceAssignmentValue(
+        result.value,
+        getter.typeInfo,
+        "return"
+      );
       if (ownsInvocationState) {
         flushRuntimeSets(runtimeCtx);
         result.value = exportRuntimeSetValue(result.value, runtimeCtx);
@@ -83772,7 +84039,11 @@ function executeCompiledFunction(action, ctx, args, allowFallthroughReturn, runt
     const parameter4 = action.parameters[index + 2];
     const runtimeTypeInfo = runtimeArgumentTypes[index];
     const value2 = asDeclaredRuntimeSet(
-      restoreExportedReferences(filledArgs[index], runtimeTypeInfo, ctx),
+      coerceAssignmentValue(
+        restoreExportedReferences(filledArgs[index], runtimeTypeInfo, ctx),
+        runtimeTypeInfo,
+        "function argument"
+      ),
       runtimeTypeInfo,
       ctx
     );
@@ -83806,9 +84077,7 @@ function executeCompiledFunction(action, ctx, args, allowFallthroughReturn, runt
     }
     return null;
   }
-  if (runtimeReturnType.type === 20 /* Decimal */ && typeof value === "number") {
-    value = coerceDecimalOperand(value, "function return");
-  }
+  value = coerceAssignmentValue(value, runtimeReturnType, "function return");
   if (!runtimeValueMatchesType(value, runtimeReturnType, ctx)) {
     throw new NSGetterRuntimeError(
       "NSFunction returned a value that does not match its compiled return type."
@@ -84147,9 +84416,11 @@ function evalInstructions(instructions, scope, ctx, options) {
         }
         case "variable" /* variable */: {
           let value = evalPointer(ins.variable.pointer, scope, ctx);
-          if (ins.variable.typeInfo.type === 20 /* Decimal */ && typeof value === "number") {
-            value = coerceDecimalOperand(value, "variable initialization");
-          }
+          value = coerceAssignmentValue(
+            value,
+            ins.variable.typeInfo,
+            "variable initialization"
+          );
           value = asDeclaredRuntimeSet(value, ins.variable.typeInfo, ctx);
           scope.setLocal(ins.variable.id, value);
           break;
@@ -84185,9 +84456,11 @@ function evalInstructions(instructions, scope, ctx, options) {
         }
         case "assign" /* assign */: {
           let value = evalPointer(ins.pointer, scope, ctx);
-          if (ins.target.typeInfo.type === 20 /* Decimal */ && typeof value === "number") {
-            value = coerceDecimalOperand(value, "assignment");
-          }
+          value = coerceAssignmentValue(
+            value,
+            ins.target.typeInfo,
+            "assignment"
+          );
           if (ins.target.pointer.type === "variable" /* variable */) {
             assertVariableBindingWritable(scope, ins.target.pointer.variableId);
             scope.setLocal(ins.target.pointer.variableId, value);
@@ -85961,6 +86234,21 @@ function evalCollectionMutationInstruction(ins, scope, ctx, options) {
     );
   }
   const args = ins.args.map((arg) => evalPointer(arg, scope, ctx));
+  const decimalEntries = "entryTypeInfo" in ins.target.typeInfo && ins.target.typeInfo.entryTypeInfo.type === 20 /* Decimal */;
+  let entryArgumentIndex = null;
+  const dictionary = ins.target.typeInfo.type === 5 /* Dictionary */;
+  if (ins.mutation === "Add" /* Add */)
+    entryArgumentIndex = dictionary ? 1 : 0;
+  if (ins.mutation === "Insert" /* Insert */) entryArgumentIndex = 1;
+  if (ins.mutation === "Remove" /* Remove */ && !dictionary)
+    entryArgumentIndex = 0;
+  if (entryArgumentIndex !== null && "entryTypeInfo" in ins.target.typeInfo) {
+    args[entryArgumentIndex] = coerceAssignmentValue(
+      args[entryArgumentIndex],
+      ins.target.typeInfo.entryTypeInfo,
+      "collection mutation entry"
+    );
+  }
   const setEntryMember = mutatesLocalVariable ? null : storedSetEntryMember(targetValue, ctx);
   const isLookupSet = setEntryMember === null && ins.target.typeInfo.type === 9 /* Lookup */;
   if (isLookupSet && Array.isArray(targetValue)) {
@@ -85968,7 +86256,8 @@ function evalCollectionMutationInstruction(ins, scope, ctx, options) {
       targetValue,
       ins.reference === true,
       ins.target.typeInfo.type === 9 /* Lookup */ && (ins.target.typeInfo.entryTypeInfo.type === 8 /* Enum */ || ins.target.typeInfo.entryTypeInfo.type === 18 /* DialogueLookup */),
-      ctx
+      ctx,
+      decimalEntries
     );
   }
   const setMatch = setEntryMember !== null && Array.isArray(targetValue) && (ins.mutation === "Add" /* Add */ || ins.mutation === "Remove" /* Remove */) ? findStoredSetEntry(targetValue, args[0], setEntryMember, ctx) : null;
@@ -85987,7 +86276,8 @@ function evalCollectionMutationInstruction(ins, scope, ctx, options) {
       ctx,
       isLookupSet,
       false,
-      ins.reference === true
+      ins.reference === true,
+      decimalEntries
     );
     updateCollectionReferenceProvenance(
       targetValue,
@@ -86065,7 +86355,8 @@ function evalCollectionMutationInstruction(ins, scope, ctx, options) {
     ctx,
     isLookupSet,
     ins.reference !== true && ins.mutation === "Remove" /* Remove */ && isArrayCollection(targetValue) && setEntryMember === null && !isLookupSet && findKnownRowIdByValueReference(args[0], ctx) === null,
-    ins.reference === true
+    ins.reference === true,
+    setEntryMember === null && decimalEntries
   );
   updateCollectionReferenceProvenance(
     targetValue,
@@ -86341,21 +86632,28 @@ function asDeclaredRuntimeSet(value, type, ctx) {
     value,
     entry === 7 /* Class */ || entry === 22 /* Interface */ || entry === 6 /* List */ || entry === 5 /* Dictionary */ || entry === 9 /* Lookup */,
     entry === 8 /* Enum */ || entry === 18 /* DialogueLookup */,
-    ctx
+    ctx,
+    entry === 20 /* Decimal */
   );
 }
 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);
+  return toSetEntryKey(value, null, set.reference, ctx, set.decimalEntries);
 }
-function runtimeSet(array3, reference2, enumEntries, ctx) {
+function runtimeSet(array3, reference2, enumEntries, ctx, decimalEntries = false) {
   const sets = ctx.__runtimeSets ??= /* @__PURE__ */ new WeakMap();
   ctx.__dirtyRuntimeSets ??= /* @__PURE__ */ new Set();
   const existing = sets.get(array3);
   if (existing !== void 0) return existing;
-  const set = new RuntimeSet(array3, reference2, enumEntries);
+  const set = new RuntimeSet(
+    array3,
+    reference2,
+    enumEntries,
+    null,
+    decimalEntries
+  );
   const references = collectionReferences(array3, ctx);
   for (let index = 0; index < array3.length; index++) {
     const raw = array3[index];
@@ -86474,7 +86772,7 @@ function removableEntryRowIds(targetValue, mutation, args, ctx) {
   }
   return rowIds;
 }
-function applyLocalCollectionMutation(targetValue, mutation, args, ctx, unique = false, resolveRemovalEntries = false, reference2 = false) {
+function applyLocalCollectionMutation(targetValue, mutation, args, ctx, unique = false, resolveRemovalEntries = false, reference2 = false, decimal2 = false) {
   if (targetValue instanceof RuntimeSet) {
     (ctx.__dirtyRuntimeSets ??= /* @__PURE__ */ new Set()).add(targetValue);
     switch (mutation) {
@@ -86526,6 +86824,7 @@ function applyLocalCollectionMutation(targetValue, mutation, args, ctx, unique =
     case "Remove" /* Remove */:
       if (Array.isArray(targetValue)) {
         const references = resolveRemovalEntries ? collectionReferences(targetValue, ctx) : recordedReferenceEntries(targetValue, ctx) ?? 1 /* Values */;
+        const targetKey = decimal2 ? decimalCollectionKey(args[0]) : args[0];
         let index = -1;
         for (let candidate = 0; candidate < targetValue.length; candidate += 1) {
           const entry = targetValue[candidate];
@@ -86536,10 +86835,8 @@ function applyLocalCollectionMutation(targetValue, mutation, args, ctx, unique =
             }
             continue;
           }
-          if (jsEqual(
-            typeof entry === "string" && isReferenceEntry(references, candidate) ? resolveValueIfId(entry, ctx) : entry,
-            args[0]
-          )) {
+          const value = typeof entry === "string" && isReferenceEntry(references, candidate) ? resolveValueIfId(entry, ctx) : entry;
+          if (jsEqual(decimal2 ? decimalCollectionKey(value) : value, targetKey)) {
             index = candidate;
             break;
           }
@@ -87026,12 +87323,22 @@ function evalPointerCore(pointer, scope, ctx, resultUsage = "value") {
     case "function" /* function */:
       return evalFunction(pointer.function, scope, ctx);
     case "listLiteral" /* listLiteral */:
-      return pointer.entries.map((e) => evalPointer(e, scope, ctx));
+      return pointer.entries.map(
+        (entry) => coerceAssignmentValue(
+          evalPointer(entry, scope, ctx),
+          pointer.typeInfo.entryTypeInfo,
+          "list entry"
+        )
+      );
     case "dictLiteral" /* dictLiteral */: {
       const out = {};
       for (const e of pointer.entries) {
         const k = evalPointer(e.key, scope, ctx);
-        out[String(k)] = evalPointer(e.value, scope, ctx);
+        out[String(k)] = coerceAssignmentValue(
+          evalPointer(e.value, scope, ctx),
+          pointer.typeInfo.entryTypeInfo,
+          "dictionary entry"
+        );
       }
       return out;
     }
@@ -88693,9 +89000,9 @@ function readRecordKey(receiver, k, memberId, ctx) {
     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 row = trackedRowForValueReference(receiver, ctx);
+    if (row !== null && classIdForValueRow(row, ctx) !== void 0)
+      return row.id;
   }
   const assetMember = resolveAssetRuntimeMember(receiver, k, ctx);
   if (assetMember.kind === "ok") return assetMember.value;
@@ -89993,7 +90300,11 @@ function evalDecimalMathOp(info, fn, scope, ctx) {
   }
 }
 function evalListRepeat(info, scope, ctx) {
-  const value = evalPointer(info.valuePointer, scope, ctx);
+  const value = coerceAssignmentValue(
+    evalPointer(info.valuePointer, scope, ctx),
+    info.entryTypeInfo,
+    "List.Repeat entry"
+  );
   const count = numberArg(
     evalPointer(info.countPointer, scope, ctx),
     "List.Repeat count"
@@ -90081,13 +90392,18 @@ function jsEqual(a, b) {
     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;
-    for (let i2 = 0; i2 < a.length; i2++) {
-      if (!jsEqual(a[i2], b[i2])) return false;
+  if (Array.isArray(a) || a instanceof RuntimeSet) {
+    if (!Array.isArray(b) && !(b instanceof RuntimeSet)) return false;
+    const aSize = a instanceof RuntimeSet ? a.size : a.length;
+    const bSize = b instanceof RuntimeSet ? b.size : b.length;
+    if (aSize !== bSize) return false;
+    const other = b.values();
+    for (const entry of a.values()) {
+      if (!jsEqual(entry, other.next().value)) return false;
     }
     return true;
   }
+  if (b instanceof RuntimeSet) return false;
   if (typeof a === "object" && typeof b === "object" && a !== null && b !== null && !Array.isArray(a) && !Array.isArray(b)) {
     const aKeys = Object.keys(a);
     const bKeys = Object.keys(b);
@@ -90523,7 +90839,8 @@ function evalCollectionQuery(info, scope, ctx) {
       output,
       info.reference === true,
       info.enumEntries === true,
-      ctx
+      ctx,
+      info.decimalEntries === true
     ) : output;
   };
   if (info.op === "OrderBy" || info.op === "OrderByDescending") {
@@ -90575,7 +90892,8 @@ function evalCollectionQuery(info, scope, ctx) {
           entry,
           valueId,
           info.reference === true,
-          ctx
+          ctx,
+          info.decimalEntries === true
         );
         if (seenSetKeys.has(setKey)) return 0 /* Continue */;
         seenSetKeys.add(setKey);
@@ -90630,10 +90948,15 @@ function evalCollectionQuery(info, scope, ctx) {
   }
   return finish();
 }
-function toSetEntryKey(entry, valueId, reference2, ctx) {
+function toSetEntryKey(entry, valueId, reference2, ctx, decimal2 = false) {
   if (reference2) return valueId ?? referenceIdOf(entry, ctx) ?? entry;
+  if (decimal2) return decimalCollectionKey(entry);
   return typeof entry === "object" && entry !== null ? canonicalJsonStringify(entry) : entry;
 }
+function decimalCollectionKey(value) {
+  if (value === null) return null;
+  return decimalKey(coerceDecimalOperand(value, "decimal collection entry"));
+}
 function compareCollectionKeys(left, right, keyType) {
   if (left === null) return right === null ? 0 : -1;
   if (right === null) return 1;
@@ -90751,7 +91074,11 @@ function evalFunction(fn, scope, ctx) {
     }
     case "contains" /* contains */: {
       let c = evalPointer(fn.info.collectionPointer, scope, ctx);
-      const target = evalPointer(fn.info.valuePointer, scope, ctx);
+      let target = evalPointer(fn.info.valuePointer, scope, ctx);
+      if (fn.info.float === true && typeof target === "number")
+        target = Math.fround(target);
+      if (fn.info.decimal === true && target !== null)
+        target = coerceDecimalOperand(target, "collection search");
       if (typeof c === "string") {
         if (typeof target !== "string") {
           throw new NSGetterRuntimeError(
@@ -90784,9 +91111,13 @@ function evalFunction(fn, scope, ctx) {
         return referenceIndexOf(c, target, ctx) !== null;
       }
       const targetReferenceId = typeof target === "string" ? null : findKnownRowIdByValueReference(target, ctx);
+      const targetKey = fn.info.decimal ? decimalCollectionKey(target) : target;
       let containsResolvedEntry = false;
       iterateCollection(c, ctx, (entry, _key, valueId) => {
-        if (valueId !== null && valueId === targetReferenceId || jsEqual(entry, target)) {
+        if (valueId !== null && valueId === targetReferenceId || jsEqual(
+          fn.info.decimal ? decimalCollectionKey(entry) : entry,
+          targetKey
+        )) {
           containsResolvedEntry = true;
           return 1 /* Break */;
         }
@@ -90799,15 +91130,21 @@ function evalFunction(fn, scope, ctx) {
         evalPointer(fn.info.collectionPointer, scope, ctx),
         "IndexOf receiver"
       );
-      const target = evalPointer(fn.info.valuePointer, scope, ctx);
+      let target = evalPointer(fn.info.valuePointer, scope, ctx);
+      if (fn.info.float === true && typeof target === "number")
+        target = Math.fround(target);
       if (fn.info.reference === true) {
         const index = referenceIndexOf(collection, target, ctx);
         return index === null ? -1 : numberArg(index, "IndexOf index");
       }
       const targetReferenceId = typeof target === "string" ? null : findKnownRowIdByValueReference(target, ctx);
+      const targetKey = fn.info.decimal ? decimalCollectionKey(target) : target;
       let found = -1;
       iterateCollection(collection, ctx, (entry, key, valueId) => {
-        if (valueId !== null && valueId === targetReferenceId || jsEqual(entry, target)) {
+        if (valueId !== null && valueId === targetReferenceId || jsEqual(
+          fn.info.decimal ? decimalCollectionKey(entry) : entry,
+          targetKey
+        )) {
           found = numberArg(key, "IndexOf index");
           return 1 /* Break */;
         }
@@ -91015,7 +91352,19 @@ function evalFunction(fn, scope, ctx) {
         );
         iterateCollection(c, ctx, callback);
       }
-      if (found !== sentinel) return found;
+      if (found !== sentinel) {
+        if (typeof found === "string") {
+          if (c instanceof RuntimeSet) {
+            if (c.enumEntries) return [found];
+          } else {
+            const row = trackedRowForValueReference(c, ctx);
+            const member = row === null ? null : memberForValueRow(row, ctx);
+            if (member?.kind === 8 /* Enum */ || member?.kind === 18 /* DialogueLookup */)
+              return [found];
+          }
+        }
+        return found;
+      }
       if (fn.type === "first" /* first */) {
         throw new NSGetterRuntimeError(
           innerFn ? "First() found no matching entry. Use FirstOrDefault() and handle null if no match is expected." : "First() called on an empty collection. Check that it has entries, or use FirstOrDefault() and handle null."
@@ -92228,10 +92577,19 @@ function constructionInitEvaluator(ctx, createdValues, argumentScopes, construct
     }
     return null;
   };
+  const defaultScopeMemberId = (memberId) => walkExtendsMemberChain(
+    memberId,
+    ctx.vm.members,
+    (declaration) => declaration.defaultValue === void 0 ? void 0 : declaration.id,
+    {
+      memberById: (id2) => indexes4.schemaIndex.member(id2) ?? null,
+      maxHops: ctx.vm.members.length
+    }
+  );
   return (member, init, sourceValueId, genericEnv = instanceEnv) => {
     const memberId = Reflect.get(member, "id");
     const effectiveMemberId = typeof memberId === "string" ? memberId : null;
-    const scopeMemberId = indexes4.initializerScopeMemberIds.get(init) ?? (typeof sourceValueId !== "string" ? void 0 : indexes4.initializerScopeMemberIdsByValueId.get(sourceValueId)) ?? effectiveMemberId;
+    const scopeMemberId = indexes4.initializerScopeMemberIds.get(init) ?? (typeof sourceValueId !== "string" ? void 0 : indexes4.initializerScopeMemberIdsByValueId.get(sourceValueId)) ?? (sourceValueId === void 0 && effectiveMemberId !== null ? defaultScopeMemberId(effectiveMemberId) : void 0) ?? effectiveMemberId;
     const compiled = ensureInitializerCompiled({
       init,
       member,
@@ -97315,7 +97673,7 @@ function materializeMemberDefaultValue(args) {
       rootOwners,
       valuesById,
       (id2) => args.readTracking?.valueIds.add(id2)
-    ).ownerClass : typeof Reflect.get(member, "id") === "string" && !isStaticMember(member) ? findSchemaPlacement(
+    ).lexicalThisClass : typeof Reflect.get(member, "id") === "string" && !isStaticMember(member) ? findSchemaPlacement(
       String(Reflect.get(member, "id")),
       args.document.classes
     )?.ownerClass ?? null : null;
@@ -108437,15 +108795,19 @@ function deferredReferenceDefault(context, expression) {
   if (elements.length === 0) return null;
   const placeholders = [];
   for (const element of elements) {
-    const spelling = parseIndexPathSpellingV4(element) ?? parseSlotPathSpellingV4(
-      element,
-      (symbol) => context.staticValueIdsBySymbol.has(symbol)
-    );
-    if (spelling === null) return null;
-    placeholders.push(encodeMemberDefaultKeyReferenceV4(spelling));
+    const placeholder = deferredReferenceValue(context, element);
+    if (placeholder === null) return null;
+    placeholders.push(placeholder);
   }
   return placeholders;
 }
+function deferredReferenceValue(context, expression) {
+  const spelling = parseIndexPathSpellingV4(expression) ?? parseSlotPathSpellingV4(
+    expression,
+    (symbol) => context.staticValueIdsBySymbol.has(symbol) || context.classIdsByName.has(symbol.slice(0, symbol.indexOf(".")))
+  );
+  return spelling === null ? null : encodeMemberDefaultKeyReferenceV4(spelling);
+}
 function slotReferenceType(readType) {
   if (readType.name === "Reference") return readType;
   const element = readType.name === "Set" ? readType.arguments[0] : void 0;
@@ -108692,6 +109054,10 @@ function lowerExpressionValue(context, expression, declaredExpected, ownerClass,
       sourceText
     );
   }
+  if (expected.name === "Reference") {
+    const deferred = deferredReferenceValue(context, expression);
+    if (deferred !== null) return deferred;
+  }
   if (expected.name === "NeoAction") {
     return lowerActionDefault(context, expression, ownerClass, path);
   }
@@ -117729,7 +118095,7 @@ function valueInitializerCompilationSites(document) {
     sites.set(row.id, {
       row,
       member,
-      ownerClass: ownerContext.ownerClass,
+      ownerClass: ownerContext.declaringClass,
       lexicalThisClass: ownerContext.lexicalThisClass
     });
   }
@@ -118854,21 +119220,25 @@ function projectValueHeadPlacementGraph(args) {
       );
     return { ...substituteMember(member, bindings, genericMembers, member) };
   };
-  const instanceBindings = (classId, member) => {
+  const instanceBindings = (classId, member, value) => {
     if (classId === null || !genericClassIds.has(classId)) return emptyBindings;
-    if (isInterfaceTypedMember(member)) {
-      return resolveInstanceEnv(
-        classId,
-        slotClassArguments(member, classId, implementerIndex()),
-        genericClasses
-      );
-    }
-    const arguments_ = member.classArguments;
+    const arguments_ = isInterfaceTypedMember(member) ? slotClassArguments(member, classId, implementerIndex()) : member.classArguments;
     if (arguments_ != null && !isGenericBindingsRecord(arguments_))
       throw new Error(
         `Class placement "${classId}" has malformed generic arguments.`
       );
-    return resolveInstanceEnv(classId, arguments_, genericClasses);
+    const env = resolveInstanceEnv(classId, arguments_, genericClasses);
+    const stamp = value?.genericBindings;
+    if (stamp !== void 0) {
+      if (!isStringRecord7(stamp))
+        throw new Error(
+          `Class value "${String(value?.id)}" has malformed genericBindings.`
+        );
+      for (const [paramId, entry] of envFromStamp(stamp))
+        env.set(paramId, entry);
+      closeForwardedGenericParams(env);
+    }
+    return env;
   };
   const unorderedByContainer = /* @__PURE__ */ new Map();
   for (const value of values.values()) {
@@ -119013,7 +119383,7 @@ function projectValueHeadPlacementGraph(args) {
     }
     result.set(item.valueId, projection);
     args.contextualMembers?.set(item.valueId, member);
-    const childBindings = classId === null ? item.bindings ?? emptyBindings : instanceBindings(classId, member);
+    const childBindings = classId === null ? item.bindings ?? emptyBindings : instanceBindings(classId, member, value);
     if ((member.kind === 5 /* Dictionary */ || member.kind === 6 /* List */ || member.kind === 28 /* Set */) && childBindings.size > 0) {
       if (!isMemberBase(member))
         throw new Error(
@@ -119213,6 +119583,9 @@ function joinPath(parent, child2) {
 function placementsEqual(left, right) {
   return JSON.stringify(left) === JSON.stringify(right);
 }
+function isStringRecord7(value) {
+  return isRecord6(value) && Object.values(value).every((entry) => typeof entry === "string");
+}
 function isRecord6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -124498,6 +124871,61 @@ var init_stored_closure_captures = __esm({
   }
 });
 
+// ../src/database/construction-replay-equality.ts
+function createConstructionReplayComparer(reader, ownedValueIds) {
+  let graph;
+  return (args) => {
+    if (!isLiteralValueContent(args.currentRoot)) return false;
+    if (!isLiteralValueContent(args.replayRoot)) return false;
+    if (args.currentRoot.instanceConstructorId !== args.replayRoot.instanceConstructorId)
+      return false;
+    const replayArgs = args.replayRoot.constructorArgs;
+    if (replayArgs === void 0 || replayArgs === null) return true;
+    if (args.currentArguments === void 0 || args.currentArguments === null)
+      return false;
+    graph ??= new MaterializedValueGraphContext(reader.documentView);
+    let owned;
+    for (const edge of graph.constructorEdges(
+      args.currentRoot,
+      args.rootMember
+    )) {
+      const replayed2 = replayArgs[edge.parameterId];
+      if (replayed2 === edge.targetValueId) continue;
+      if (typeof replayed2 === "string" && !args.replayRows.has(replayed2))
+        return false;
+      owned ??= new Set(ownedValueIds(args.currentRoot, args.rootMember));
+      if (!owned.has(edge.targetValueId)) return false;
+    }
+    const stored = { ...args.currentArguments };
+    const replayed = { ...replayArgs };
+    for (const [slot, value] of Object.entries(stored)) {
+      if (typeof value !== "string" || replayed[slot] !== value) continue;
+      delete stored[slot];
+      delete replayed[slot];
+    }
+    return effectiveValuesEqual(
+      reader.normalizeConstructorArguments(
+        stored,
+        args.currentRoot,
+        args.rootMember
+      ),
+      reader.withRowOverrides(args.replayRows).normalizeConstructorArguments(
+        replayed,
+        args.replayRoot,
+        args.rootMember
+      )
+    );
+  };
+}
+var init_construction_replay_equality = __esm({
+  "../src/database/construction-replay-equality.ts"() {
+    "use strict";
+    init_effective_value_comparison();
+    init_constructor_argument_ownership();
+    init_members();
+  }
+});
+
 // ../src/models/project/world-layer-compatibility-error.ts
 var WorldLayerCompatibilityError;
 var init_world_layer_compatibility_error = __esm({
@@ -126505,9 +126933,9 @@ function assertNumberRange(member, value, path) {
   }
 }
 function stringRecord3(value) {
-  return isStringRecord7(value) ? value : null;
+  return isStringRecord8(value) ? value : null;
 }
-function isStringRecord7(value) {
+function isStringRecord8(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
     return false;
   }
@@ -128143,8 +128571,7 @@ function materializePreparedInstanceInitializers(args) {
     compiledDocument,
     compiledDocument.variants ?? []
   );
-  let currentReader = null;
-  const requireCurrentReader = () => currentReader ??= new EffectiveValueReader(materializationScope.document);
+  let compareConstruction;
   let ownedValueCollector;
   let valueHashes;
   const liveValueHashes = () => valueHashes ??= indexLiveContentHashesByRecordId(
@@ -128210,16 +128637,28 @@ function materializePreparedInstanceInitializers(args) {
           `construction-arguments-conflict: Value "${valueId}" is already materialized as class "${String(existingConstructedRoot.classId)}", and this construction builds class "${String(materialized.root.classId)}". Delete and recreate the value to change its class.`
         );
       }
-      if (replayedCreationDataMatches({
-        // The synthetic variant binding members are part of the ownership
-        // scope that compiled and evaluated this initializer. Stored replay
-        // closes its generic slot from the same ephemeral member id, so its
-        // expansion must read that scoped document too.
-        currentReader: requireCurrentReader(),
+      compareConstruction ??= createConstructionReplayComparer(
+        new EffectiveValueReader(materializationScope.document),
+        (root, rootMember) => {
+          ownedValueCollector ??= createOwnedValueDeletionCollector(
+            args.document
+          );
+          return ownedValueCollector.collect({
+            rootIds: [root.id],
+            rootMembers: /* @__PURE__ */ new Map([[root.id, rootMember]])
+          });
+        }
+      );
+      const replayRows = new Map(
+        materialized.createdValues.map((row) => [row.id, row])
+      );
+      replayRows.set(materialized.root.id, materialized.root);
+      if (compareConstruction({
         currentRoot: existingConstructedRoot,
+        currentArguments: isLiteralValueContent(existingConstructedRoot) ? existingConstructedRoot.constructorArgs : void 0,
         rootMember: member,
         replayRoot: materialized.root,
-        replayCreated: materialized.createdValues
+        replayRows
       })) {
         replayOnlyIndexes.push(site.index);
         batch.upsert([existingConstructedRoot]);
@@ -128340,46 +128779,6 @@ function materializePreparedInstanceInitializers(args) {
     args.prepared.splice(index, 1);
   }
 }
-function replayedCreationDataMatches(args) {
-  if (!isLiteralValueContent(args.currentRoot) || !isLiteralValueContent(args.replayRoot)) {
-    return false;
-  }
-  const replayArgs = args.replayRoot.constructorArgs;
-  if (replayArgs !== void 0 && replayArgs !== null) {
-    const currentArgs = args.currentRoot.constructorArgs;
-    if (currentArgs === void 0 || currentArgs === null || !constructorArgumentsSemanticallyEqual({
-      currentReader: args.currentReader,
-      currentRoot: args.currentRoot,
-      rootMember: args.rootMember,
-      current: currentArgs,
-      replayRoot: args.replayRoot,
-      replayCreated: args.replayCreated,
-      replay: replayArgs
-    })) {
-      return false;
-    }
-  }
-  return true;
-}
-function constructorArgumentsSemanticallyEqual(args) {
-  const current = args.currentReader;
-  const replayRows = /* @__PURE__ */ new Map([
-    [args.replayRoot.id, args.replayRoot]
-  ]);
-  for (const row of args.replayCreated) replayRows.set(row.id, row);
-  const replay = current.withRowOverrides(replayRows);
-  const currentNormalized = current.normalizeConstructorArguments(
-    args.current,
-    args.currentRoot,
-    args.rootMember
-  );
-  const replayNormalized = replay.normalizeConstructorArguments(
-    args.replay,
-    args.replayRoot,
-    args.rootMember
-  );
-  return effectiveValuesEqual(currentNormalized, replayNormalized);
-}
 function completeLocalizedTextCreateEnvelopes(args) {
   const createsLocalizedText = args.changes.some(
     (change) => change.recordKind === "localized-text" && change.operation === "create"
@@ -130368,7 +130767,7 @@ function compileOwnedValueRowInitializer(args) {
     member,
     valueRow: row,
     valueId: row.id,
-    initializerOwnerClass: ownerContext.ownerClass,
+    initializerOwnerClass: ownerContext.declaringClass,
     lexicalThisClass: ownerContext.lexicalThisClass,
     // A value-row initializer is source for a persisted construction, never
     // an ad-hoc runtime `new`. The CLI replay compiler uses this same mode;
@@ -131423,7 +131822,7 @@ var init_project_version_schema_commit = __esm({
     init_declared_binding_targets();
     init_stored_closure_captures();
     init_document_initializer_compiler();
-    init_effective_value_comparison();
+    init_construction_replay_equality();
     init_classes();
     init_constructor_parameter_settlement();
     init_generics();
@@ -131679,7 +132078,11 @@ function resolveDeclarationListenerTemplate(args) {
           typeId: row.classId,
           nullable: type.nullable
         };
-        if (!isNeoScriptTypeAssignable(selectedType, type, projectIndex))
+        if (!isNeoScriptTypeAssignable(
+          selectedType,
+          { kind: "named", typeId: type.typeId, nullable: type.nullable },
+          projectIndex
+        ))
           throw new Error(
             `Listener template ${id2} selects a class that is not assignable to its declared type.`
           );
@@ -137913,7 +138316,7 @@ function toWorldReferenceClassRecord(value) {
   return {
     id: id2,
     extendsClassId: nullableStringField(value, "extendsClassId"),
-    schema: isStringRecord8(value.schema) ? value.schema : void 0,
+    schema: isStringRecord9(value.schema) ? value.schema : void 0,
     system: isPlainRecord8(value.system) ? value.system : null
   };
 }
@@ -137931,7 +138334,7 @@ function worldReferenceValueClassId(value) {
   if (value === void 0) return null;
   return typeof value.classId === "string" && value.classId.length > 0 ? value.classId : null;
 }
-function isStringRecord8(value) {
+function isStringRecord9(value) {
   if (!isPlainRecord8(value)) return false;
   return Object.values(value).every((entry) => typeof entry === "string");
 }
@@ -143807,6 +144210,33 @@ function lowerMemberDefaultSourcesV4(state, analysis, manifest, options = {}) {
     seeds
   };
 }
+function prepareValueReferencePathsV4(state, manifest, options) {
+  const paths = options.registry.referenceObligations.filter(
+    (obligation) => obligation.kind === "reference" && (obligation.target.spelling === "slotPath" || obligation.target.spelling === "indexPath")
+  );
+  if (paths.length === 0) return;
+  const context = buildValueLowerContext(state, manifest, {
+    analysis: options.analysis,
+    registry: options.registry,
+    valuePlacements: indexValuePlacements(state, {
+      pendingValues: options.registry.pendingValues
+    })
+  });
+  const deletedValueIds = /* @__PURE__ */ new Set();
+  for (const obligation of paths) {
+    const failure = settleReferenceObligation(
+      context,
+      obligation,
+      deletedValueIds,
+      options.resolveRootPath
+    );
+    if (failure !== null)
+      options.registry.loweringFailures.push({
+        message: failure,
+        site: obligation.site
+      });
+  }
+}
 function drainValueReferenceObligationsV4(state, manifest, options) {
   const deletedValueIds = options.deletedValueIds ?? /* @__PURE__ */ new Set();
   const survivingState = withoutDeletedValues(state, deletedValueIds);
@@ -144280,6 +144710,8 @@ function keyIndexSchemaKey(context, member, collection, spelling) {
 }
 function collectionEntryIds(context, collection, collectionValueId) {
   if (isUnorderedList(collection)) {
+    const authored = context.authoredListEntries.get(collectionValueId);
+    if (authored !== void 0) return authored;
     return [
       ...context.valuePlacements.valueIdsByContainerId.get(
         collectionValueId
@@ -145118,16 +145550,62 @@ function lowerRowBackedDefault(context, member, backed, baseData3, binding) {
   );
 }
 function foreignDelegateCopy(context, member, expression, binding) {
-  if (member.kind !== "delegate") return null;
-  const path = memberPath2(annotatedValue(expression).expression);
-  const parts = path?.split(".");
-  if (path === null || parts?.length !== 2) return null;
-  const owner = context.classesByName.get(parts[0]);
-  if (owner === void 0 || owner.id === binding.ownerClassId) return null;
-  const targetId = classSchemaMemberId(context, owner.id, parts[1]);
-  if (targetId === null) return null;
-  const target = context.members.get(targetId);
-  return target?.kind === "delegate" && target.modifier === "static" ? path : null;
+  let runtimeNames;
+  const declaringClass2 = binding.ownerClassId === void 0 ? void 0 : context.classes.get(binding.ownerClassId);
+  const visit = (source) => {
+    const value = annotatedValue(source).expression;
+    if (value.kind === "new") {
+      for (const argument2 of value.args) {
+        const copy = visit(argument2);
+        if (copy !== null) return copy;
+      }
+      for (const field of value.initializer ?? []) {
+        const copy = visit(field.value);
+        if (copy !== null) return copy;
+      }
+      return null;
+    }
+    if (value.kind === "litList") {
+      for (const entry of value.elements) {
+        const copy = visit(entry);
+        if (copy !== null) return copy;
+      }
+      return null;
+    }
+    if (value.kind === "litDict") {
+      for (const entry of value.entries) {
+        const copy = visit(entry.value);
+        if (copy !== null) return copy;
+      }
+      return null;
+    }
+    if (value.kind === "conditional")
+      return visit(value.whenTrue) ?? visit(value.whenFalse);
+    if (value.kind === "coalesce")
+      return visit(value.left) ?? visit(value.right);
+    if (value.kind === "force") return visit(value.operand);
+    const path = memberPath2(value);
+    if (path === null) return null;
+    const parts = path.split(".");
+    let ownerId;
+    let name;
+    if (parts.length === 1) {
+      if (member.modifier !== "static" && (runtimeNames ??= bindingRuntimeIdentifiers(context, binding)).has(path))
+        return null;
+      ownerId = binding.ownerClassId;
+      name = path;
+    } else if (parts.length === 2) {
+      ownerId = context.classesByName.get(parts[0])?.id;
+      name = parts[1];
+    } else return null;
+    if (ownerId === void 0) return null;
+    const targetId = classSchemaMemberId(context, ownerId, name);
+    if (targetId === null) return null;
+    if (declaringClass2?.schema[name] === targetId) return null;
+    const target = context.members.get(targetId);
+    return target?.kind === "delegate" && target.modifier === "static" ? { path, expression: value } : null;
+  };
+  return visit(expression);
 }
 function lowerStoredBinding(context, binding, memberValueIds, seeds) {
   const member = context.members.get(binding.memberId);
@@ -145155,8 +145633,8 @@ function lowerStoredBinding(context, binding, memberValueIds, seeds) {
   const foreign = foreignDelegateCopy(context, member, expression, binding);
   if (foreign !== null) {
     context.loweringFailures.push({
-      message: `Static delegate ${member.name} cannot copy ${foreign} from another Class; write () => ${foreign}() instead.`,
-      site: referenceSite(binding, expression)
+      message: `Initializer ${binding.label} cannot copy static delegate ${foreign.path} from another Class; write () => ${foreign.path}() instead.`,
+      site: referenceSite(binding, foreign.expression)
     });
     memberValueIds.set(
       binding.memberId,
@@ -147051,15 +147529,27 @@ function retainConstructionArguments(context, row, schemaClass2, expression, sou
   const constructorArgs2 = row.constructorArgs;
   if (!isObjectRecord(constructorArgs2)) return;
   if (row.instanceConstructorId === null) return;
-  const constructor2 = storedValueConstructor(
-    context,
-    schemaClass2,
-    recordedStoredConstructorId(row, schemaClass2)
+  const constructorId = recordedStoredConstructorId(row, schemaClass2);
+  const stored = context.state[`constructor:${constructorId}`]?.data;
+  if (!isObjectRecord(stored)) {
+    throw new Error(
+      `Stored construction for ${schemaClass2.name} names missing pulled constructor ${constructorId}.`
+    );
+  }
+  if (stored.classId !== schemaClass2.id) {
+    throw new Error(
+      `Stored constructor ${constructorId} does not belong to ${schemaClass2.name}.`
+    );
+  }
+  const argumentsValue = documentArgumentsToManifest(
+    stored.argumentTypes,
+    { recordKind: "constructor", recordId: constructorId, data: stored },
+    schemaClass2.source.span
   );
   const authoredArguments = constructorArgumentExpressions(expression);
   const argumentEnvironment = valueGenericEnvironment(row, environment);
-  for (let index = 0; index < constructor2.arguments.length; index += 1) {
-    const argument2 = constructor2.arguments[index];
+  for (let index = 0; index < argumentsValue.length; index += 1) {
+    const argument2 = argumentsValue[index];
     if (argument2 === void 0) continue;
     const valueId = constructorArgs2[`__arg_${index}__`];
     if (typeof valueId !== "string") continue;
@@ -147845,6 +148335,7 @@ function lowerRawMemberTypeName(context, memberId) {
   if (member.kind === 8 /* Enum */ && typeof member.enumId === "string") {
     return context.enumNames.get(member.enumId) ?? null;
   }
+  if (member.kind === 9 /* Lookup */) return "Reference";
   if (member.kind === 6 /* List */) return "List";
   if (member.kind === 28 /* Set */) return "Set";
   if (member.kind === 5 /* Dictionary */) return "Dictionary";
@@ -147859,6 +148350,8 @@ function lowerSchemaMemberTypeName(context, member) {
       return context.referenceTypes().interfaceImplementers().interface(member.interfaceId)?.name ?? null;
     case "enum":
       return context.enumNames.get(member.enumId) ?? null;
+    case "lookup":
+      return "Reference";
     case "list":
       return "List";
     case "set":
@@ -150859,10 +151352,15 @@ function storedConstructorArgumentSource(context, type, value, environment, visi
       throw new Error(
         `Stored constructor argument cannot be typed by interface type parameter ${type.genericParamId} of ${type.ownerInterfaceId}.`
       );
-    case "generic":
+    case "generic": {
+      const binding = storedGenericArgumentType(context, type, environment);
+      const argumentType = binding.kind === "reference" ? withSchemaTypeNullability(
+        referenceReadType2(context, binding.target),
+        binding.nullable
+      ) : binding;
       return storedConstructorArgumentSource(
         context,
-        storedGenericArgumentType(context, type, environment),
+        argumentType,
         value,
         environment,
         visited,
@@ -150870,6 +151368,7 @@ function storedConstructorArgumentSource(context, type, value, environment, visi
         partial,
         constructorOwnsGraph
       );
+    }
     case "interface":
     case "list":
     case "set":
@@ -151066,8 +151565,14 @@ function schemaTypeForBindingMember(context, memberId, environment, visited = /*
       };
     case "lookup": {
       if (member.declaredType !== null) {
-        const target = referenceReadType2(context, member.declaredType);
-        return member.collectionMemberId === null && member.multiselect ? { kind: "lookup", nullable: nullable2, entryType: target } : withSchemaTypeNullability(target, nullable2);
+        if (member.collectionMemberId === null && member.multiselect) {
+          return {
+            kind: "lookup",
+            nullable: nullable2,
+            entryType: referenceReadType2(context, member.declaredType)
+          };
+        }
+        return { kind: "reference", nullable: nullable2, target: member.declaredType };
       }
       if (member.collectionMemberId === null) {
         throw new Error(
@@ -151636,7 +152141,8 @@ function resolveGenericValueMember(context, member, environment) {
   }
   return {
     ...bindingMember,
-    id: member.id,
+    // Lookup emission reads the binding's declared target and collection.
+    id: bindingMember.kind === 9 /* Lookup */ ? bindingMemberId : member.id,
     name: member.name,
     defaultValue: member.defaultValue,
     ...member.payload === 1 /* Partial */ ? { payload: 1 /* Partial */ } : {}
@@ -151714,7 +152220,8 @@ function resolveGenericSchemaMember(context, member, environment) {
   }
   const resolved = {
     ...bindingMember,
-    id: member.id,
+    // Deferred reference checks resolve this concrete lookup declaration.
+    id: bindingMember.kind === "lookup" ? bindingMemberId : member.id,
     name: member.name,
     defaultValue: member.defaultValue
   };
@@ -153373,8 +153880,15 @@ function reconcileMaterializedInitializersV4(args) {
     );
   }
   let currentRows;
-  let currentReader;
+  let compareConstruction;
   let ownedValues;
+  const storedOwnedValues = () => {
+    if (ownedValues !== void 0) return ownedValues;
+    const storedDocument = currentState().document;
+    compilePulledUncompiledConstructorsV4(storedDocument);
+    assertPulledConstructorsCompiled(storedDocument);
+    return ownedValues = createOwnedValueDeletionCollector(storedDocument);
+  };
   const rebuilds = [];
   for (const reconciliation of constructions.values()) {
     if (!replayableValueIds.has(reconciliation.valueId)) continue;
@@ -153426,8 +153940,14 @@ function reconcileMaterializedInitializersV4(args) {
       currentState().document,
       replayDocument
     );
-    currentReader ??= new EffectiveValueReader(
-      storedRowsDocument(replayDocument, currentRows)
+    compareConstruction ??= createConstructionReplayComparer(
+      new EffectiveValueReader(storedRowsDocument(replayDocument, currentRows)),
+      (root, member) => {
+        return storedOwnedValues().collect({
+          rootIds: [root.id],
+          rootMembers: /* @__PURE__ */ new Map([[root.id, member]])
+        });
+      }
     );
     const replay = replayRows.get(reconciliation.valueId);
     if (replay === void 0) {
@@ -153457,13 +153977,12 @@ function reconcileMaterializedInitializersV4(args) {
       );
       continue;
     }
-    if (reconciliation.kind === "storedArguments" && storedArgumentsMatch({
-      reader: currentReader,
-      stored: reconciliation.storedConstructorArgs,
+    if (reconciliation.kind === "storedArguments" && compareConstruction({
       currentRoot,
-      replay,
+      currentArguments: reconciliation.storedConstructorArgs,
+      replayRoot: replay,
       replayRows,
-      owner
+      rootMember: owner
     })) {
       continue;
     }
@@ -153475,11 +153994,10 @@ function reconcileMaterializedInitializersV4(args) {
         `Cannot rebuild construction for value "${reconciliation.valueId}": its pulled row is missing.`
       );
     }
-    ownedValues ??= createOwnedValueDeletionCollector(replayDocument);
     rebuilds.push({
       valueId: reconciliation.valueId,
       row: rebuiltConstructionRow(stored, reconciliation.code),
-      ownedValueIds: ownedValues.collect({
+      ownedValueIds: storedOwnedValues().collect({
         rootIds: [reconciliation.valueId],
         rootMembers: /* @__PURE__ */ new Map([[reconciliation.valueId, owner]])
       })
@@ -153522,22 +154040,6 @@ function sameCompiledProgram(left, right) {
     return literal3 && key === "value" ? isDeepStrictEqual(left[key], right[key]) : sameCompiledProgram(left[key], right[key]);
   });
 }
-function storedArgumentsMatch(args) {
-  const replayArgs = isLiteralValueContent(args.replay) ? args.replay.constructorArgs : void 0;
-  if (!isObjectRecord(replayArgs)) return false;
-  const [storedArgs, replayedArgs] = withoutSharedArguments(
-    args.stored,
-    replayArgs
-  );
-  return effectiveValuesEqual(
-    args.reader.normalizeConstructorArguments(
-      storedArgs,
-      args.currentRoot,
-      args.owner
-    ),
-    args.reader.withRowOverrides(args.replayRows).normalizeConstructorArguments(replayedArgs, args.replay, args.owner)
-  );
-}
 function rebuiltConstructionRow(data, code) {
   return { ...withoutMaterializedInstanceFields(data), init: { code } };
 }
@@ -153565,7 +154067,7 @@ function retainedLiteralCompiles(document, retained, owners, rootOwners, stored)
     );
     const key = JSON.stringify([
       getField(member, "id") ?? member,
-      ownerContext.ownerClass?.id ?? null,
+      ownerContext.declaringClass?.id ?? null,
       ownerContext.lexicalThisClass?.id ?? null,
       code
     ]);
@@ -153592,7 +154094,7 @@ function retainedLiteralFailure(args, records3, document, replayContext, compile
       valueId: compile.valueId,
       code: compile.code,
       member: compile.member,
-      initializerOwnerClass: compile.ownerContext.ownerClass,
+      initializerOwnerClass: compile.ownerContext.declaringClass,
       lexicalThisClass: compile.ownerContext.lexicalThisClass,
       evaluate: false,
       compilationProject
@@ -153652,16 +154154,6 @@ function storedRowsWithRenamedKeys(before, after) {
   }
   return rows;
 }
-function withoutSharedArguments(stored, replayed) {
-  const storedRest = { ...stored };
-  const replayedRest = { ...replayed };
-  for (const [slot, value] of Object.entries(stored)) {
-    if (typeof value !== "string" || replayed[slot] !== value) continue;
-    delete storedRest[slot];
-    delete replayedRest[slot];
-  }
-  return [storedRest, replayedRest];
-}
 function pulledStateDocumentV4(workspace) {
   const state = workspace.state.records;
   const remembered = pulledStateDocuments.get(state);
@@ -153817,6 +154309,12 @@ function materializeInitializersLocallyV4(args) {
     valuesById: batch.valuesById
   });
   for (const id2 of pendingRoots) {
+    const ownerContext = initializerOwnerContext(
+      authoredDocument,
+      id2,
+      walkedRootOwners,
+      batch.valuesById
+    );
     replayStoredConstructionV4({
       records: records3,
       document: authoredDocument,
@@ -153825,6 +154323,8 @@ function materializeInitializersLocallyV4(args) {
       compilationProject,
       replayContext: templateContext,
       member: rootOwners.get(id2),
+      initializerOwnerClass: ownerContext.declaringClass,
+      lexicalThisClass: ownerContext.lexicalThisClass,
       evaluate: false,
       onCompiledInitializer: (init) => compiledInitializers.set(id2, init)
     });
@@ -154128,7 +154628,7 @@ var init_local_initializer_materialization = __esm({
     init_stored_closure_captures();
     init_initializer_dependencies();
     init_initializer_replay();
-    init_effective_value_comparison();
+    init_construction_replay_equality();
     init_constructor_argument_ownership();
     init_neo_script_recompile_scope();
     init_compiler_adapter();
@@ -161004,6 +161504,11 @@ function computeStatus(workspace, options, conflictedFiles, parseErrors, parseWa
     unavailableSlots: rootValues.unavailableSlots,
     registry: valueLowerRegistry
   });
+  prepareValueReferencePathsV4(rootPathResolutionState, manifest, {
+    registry: valueLowerRegistry,
+    analysis: projectAnalysisV4,
+    resolveRootPath
+  });
   if (collectionBindings !== void 0 && !(collectionBindings instanceof SchemaSourceError)) {
     const bindings = collectionBindings;
     const templateInitializer = (id2) => {
@@ -161016,10 +161521,19 @@ function computeStatus(workspace, options, conflictedFiles, parseErrors, parseWa
     const rootRecordsById = new Map(
       rootRecords.filter((record7) => record7.recordKind === "value").map((record7) => [record7.recordId, record7])
     );
-    const rootMembers = /* @__PURE__ */ new Map();
+    const rootBindings = /* @__PURE__ */ new Map();
     for (const record7 of Object.values(rootPathResolutionState)) {
       if (record7.recordKind === "member" && isObjectRecord(record7.data) && typeof record7.data.valueId === "string")
-        rootMembers.set(record7.data.valueId, record7.recordId);
+        rootBindings.set(record7.data.valueId, {
+          memberId: record7.recordId,
+          rootId: record7.data.valueId
+        });
+    }
+    for (const [memberId, seed] of authoredValueSeeds) {
+      if (seed.valueId === void 0) continue;
+      const binding = { memberId, rootId: seed.valueId };
+      rootBindings.set(seed.valueId, binding);
+      for (const row of seed.values ?? []) rootBindings.set(row.id, binding);
     }
     for (const row of collectionBindings.rows.values()) {
       if (rootPathResolutionState[`value:${row.id}`] === void 0) continue;
@@ -161035,11 +161549,21 @@ function computeStatus(workspace, options, conflictedFiles, parseErrors, parseWa
           fileFields: { ...row }
         });
     }
-    for (const [rootId, rowIds] of collectionBindings.pathRowsByRootId) {
-      const memberId = rootMembers.get(rootId);
+    const pathsByBinding = /* @__PURE__ */ new Map();
+    for (const [pathRootId, rowIds] of collectionBindings.pathRowsByRootId) {
+      const binding = rootBindings.get(pathRootId);
+      const rootId = binding?.rootId ?? pathRootId;
+      let paths = pathsByBinding.get(rootId);
+      if (paths === void 0) {
+        paths = { memberId: binding?.memberId, rowIds: /* @__PURE__ */ new Set() };
+        pathsByBinding.set(rootId, paths);
+      }
+      for (const id2 of rowIds) paths.rowIds.add(id2);
+    }
+    for (const [rootId, { memberId, rowIds }] of pathsByBinding) {
       const root = collectionBindings.rowForValue(rootId);
-      if (memberId === void 0 || root === void 0) continue;
-      const seed = authoredValueSeeds.get(memberId);
+      if (root === void 0) continue;
+      const seed = memberId === void 0 ? void 0 : bindingSeeds.get(memberId);
       const rows = new Map((seed?.values ?? []).map((row) => [row.id, row]));
       const copiedById = /* @__PURE__ */ new Map();
       const insideInitializerCopy = (id2) => {
@@ -161065,7 +161589,8 @@ function computeStatus(workspace, options, conflictedFiles, parseErrors, parseWa
       for (const id2 of rowIds) {
         if (id2 === rootId) continue;
         const location3 = collectionBindings.locationForValue(id2);
-        if (location3 === void 0) continue;
+        const rowMemberId = location3?.memberId ?? rows.get(id2)?.memberId;
+        if (rowMemberId === void 0) continue;
         if (insideInitializerCopy(id2)) continue;
         const row = collectionBindings.rowForValue(id2);
         if (row === void 0)
@@ -161082,13 +161607,13 @@ function computeStatus(workspace, options, conflictedFiles, parseErrors, parseWa
               containerId: row.containerId,
               genericBindings: row.genericBindings
             },
-            location3.memberId
+            rowMemberId
           );
           rows.set(id2, authored2);
           if (isNew) valueLowerRegistry.pendingValues.set(id2, authored2);
           continue;
         }
-        const classId = row.classId ?? (isClassTypedMember(location3.member) ? location3.member.classId : null);
+        const classId = row.classId ?? (location3 !== void 0 && isClassTypedMember(location3.member) ? location3.member.classId : null);
         const authored = staticValueSeedRow(
           {
             ...row,
@@ -161098,11 +161623,25 @@ function computeStatus(workspace, options, conflictedFiles, parseErrors, parseWa
               instanceConstructorId: row.instanceConstructorId ?? null
             } : {}
           },
-          location3.memberId
+          rowMemberId
         );
         rows.set(id2, authored);
         if (isNew) valueLowerRegistry.pendingValues.set(id2, authored);
       }
+      if (memberId === void 0) {
+        for (const row of rows.values()) {
+          if (rootPathResolutionState[`value:${row.id}`] !== void 0)
+            continue;
+          rootRecords.push({
+            recordKind: "value",
+            recordId: row.id,
+            file: "Root.neo",
+            line: 1,
+            fileFields: { id: row.id, ...encodeStoredValueRowFields(row) }
+          });
+        }
+        continue;
+      }
       bindingSeeds.set(memberId, {
         ...seed,
         nodeType: "literal",
@@ -161830,8 +162369,9 @@ function replayAnimationDeclarationInitializersV4(records3, document, fallbackVa
       rootOwners,
       valuesById
     );
-    const initializerOwnerClass = ownerContext.ownerClass;
-    const requiredConstructor = initializerOwnerClass?.requiredConstructorId === void 0 || initializerOwnerClass.requiredConstructorId === null ? void 0 : constructorsById.get(initializerOwnerClass.requiredConstructorId);
+    const initializerOwnerClass = ownerContext.declaringClass;
+    const requiredConstructorId2 = ownerContext.lexicalThisClass?.requiredConstructorId;
+    const requiredConstructor = requiredConstructorId2 == null ? void 0 : constructorsById.get(requiredConstructorId2);
     const requiredArgumentNames = new Set(
       requiredConstructor?.argumentTypes.map((argument2) => argument2.name) ?? []
     );
@@ -167945,11 +168485,11 @@ function membersForType(snapshot, type) {
       (member) => member.id === cloneId ? cloneSymbol(named, type) : member
     );
   }
-  if (type.kind === "named") {
-    const named = snapshot.project.typeById.get(type.typeId);
-    if (!named) return [];
-    let members = named.members.filter((member) => member.static !== true);
-    if (type.typeArguments?.length)
+  if (type.kind === "named" || type.kind === "typeParameter") {
+    const named = type.kind === "named" ? snapshot.project.typeById.get(type.typeId) : void 0;
+    if (type.kind === "named" && !named) return [];
+    let members = named?.members.filter((member) => member.static !== true) ?? [];
+    if (type.kind === "named" && type.typeArguments?.length && named)
       members = members.map((member) => {
         return {
           ...member,
@@ -167996,7 +168536,7 @@ function membersForType(snapshot, type) {
         }
       }
     }
-    if (named.kind === "class") {
+    if (named?.kind === "class") {
       members = members.filter(
         (member) => member.name !== NEOSCRIPT_CLASS_ID_MEMBER
       );
@@ -168060,8 +168600,16 @@ function resolveMemberOf(snapshot, reference2, receiver) {
     const symbol = enumMemberNamed(receiver.type, reference2.name);
     return symbol ? { type: symbol.type, symbol } : null;
   }
-  const member = resolveMember3(snapshot, receiver.resolution, reference2.name);
-  const call = scriptFeatureIndex(snapshot).calls.get(reference2.start);
+  const index = scriptFeatureIndex(snapshot);
+  const tokenIndex = index.tokenIndexes.get(reference2.start);
+  const dotOffset = tokenIndex === void 0 ? void 0 : index.tokens[tokenIndex - 1]?.start;
+  const member = resolveMember3(
+    snapshot,
+    receiver.resolution,
+    reference2.name,
+    dotOffset
+  );
+  const call = index.calls.get(reference2.start);
   return specializeGenericCall(snapshot, member, call?.typeArgumentTokens);
 }
 function isKnownMemberReceiver(snapshot, receiver) {
@@ -168275,7 +168823,12 @@ function resolveChain(snapshot, tokens, offset, expectedType) {
     if (token.kind === "punctuation" && token.text === "." || token.kind === "operator" && token.text === "?.") {
       const member = tokens[cursor + 1];
       if (!member || member.kind !== "identifier") break;
-      const resolved = resolveMember3(snapshot, current, member.text);
+      const resolved = resolveMember3(
+        snapshot,
+        current,
+        member.text,
+        token.start
+      );
       if (!resolved) {
         const nextRoot = member.range.start.line > token.range.end.line ? resolveRoot(snapshot, member.text, member.start) : null;
         if (!nextRoot) return null;
@@ -168517,7 +169070,7 @@ function contextualTypeParameters(snapshot) {
   if (thisClass?.kind !== "named") return [];
   return snapshot.project.typeById.get(thisClass.typeId)?.typeParameters ?? [];
 }
-function resolveMember3(snapshot, receiver, name) {
+function resolveMember3(snapshot, receiver, name, flowOffset) {
   if (receiver.indexSurface) {
     const index = indexesFor(snapshot, receiver.indexSurface.memberId).find(
       (candidate) => candidate.name === name
@@ -168538,10 +169091,9 @@ function resolveMember3(snapshot, receiver, name) {
   ) : membersForType(snapshot, receiver.type)).find((candidate) => candidate.name === name);
   if (!member || receiver.symbol?.name === "base" && !isConcreteBaseMember(member))
     return null;
-  return {
-    type: member.returnType ?? member.type,
-    symbol: member
-  };
+  const flow = flowOffset === void 0 ? void 0 : flowProbe(snapshot).locals.get(flowOffset);
+  const type = flow?.name === name ? flow.type : member.returnType ?? member.type;
+  return { type, symbol: { ...member, type } };
 }
 function scopeAt(snapshot, offset, name) {
   const result = [];
@@ -182029,7 +182581,7 @@ function collectUnityReferencedProjectFileIds(args) {
     )) {
       instanceEnv.set(paramId, { kind: "member", memberId: boundMemberId });
     }
-    const childValueIds = isStringRecord9(storedValue) ? storedValue : {};
+    const childValueIds = isStringRecord10(storedValue) ? storedValue : {};
     for (const entry of schema) {
       if (entry.memberId === null) continue;
       const childMember = substituteWalkMember(
@@ -182092,7 +182644,7 @@ function collectUnityReferencedProjectFileIds(args) {
     return;
   }
   if (isMemberDictionaryBase(member)) {
-    const childValueIds = isStringRecord9(storedValue) ? storedValue : {};
+    const childValueIds = isStringRecord10(storedValue) ? storedValue : {};
     const substitutedEntryMember = substituteWalkMember(
       member.entryMemberId,
       args.genericEnv,
@@ -182126,7 +182678,7 @@ function readGenericBindingsFromValue(value) {
   if (value == null) return {};
   if (!isLiteralValueContent(value)) return {};
   const bindings = Reflect.get(value, "genericBindings");
-  return isStringRecord9(bindings) ? bindings : {};
+  return isStringRecord10(bindings) ? bindings : {};
 }
 function readClassIdFromMemberValueBase(value) {
   if (value === null) return null;
@@ -182146,7 +182698,7 @@ function readFileIdFromMemberValue(value) {
   if (fileId.trim().length === 0) return null;
   return fileId;
 }
-function isStringRecord9(value) {
+function isStringRecord10(value) {
   if (value === null) return false;
   if (typeof value !== "object") return false;
   return Object.values(value).every((entry) => typeof entry === "string");
@@ -185868,7 +186420,7 @@ function spellClassInterfaceConstructions(ctx, classId, env) {
       path
     );
     if (saved === null) continue;
-    const list = [interfaceConstruction2(ctx, interfaceId, name, saved, false)];
+    const list = [interfaceConstruction(ctx, interfaceId, name, saved, false)];
     const inherited = parentClassId === void 0 ? void 0 : index.construction(parentClassId, interfaceId);
     const readOnly = inherited === void 0 ? null : interfaceConstructionArguments(
       ctx,
@@ -185880,13 +186432,13 @@ function spellClassInterfaceConstructions(ctx, classId, env) {
       false
     );
     if (readOnly !== null && readOnly.join() !== saved.join()) {
-      list.push(interfaceConstruction2(ctx, interfaceId, name, readOnly, true));
+      list.push(interfaceConstruction(ctx, interfaceId, name, readOnly, true));
     }
     result.set(interfaceId, list);
   }
   return result;
 }
-function interfaceConstruction2(ctx, interfaceId, name, args, readOnlyView) {
+function interfaceConstruction(ctx, interfaceId, name, args, readOnlyView) {
   const params = ctx.exportData.interfaces[interfaceId]?.genericParams ?? [];
   const suffix = args.length === 0 ? "" : `<${args.join(", ")}>`;
   return {
@@ -186683,18 +187235,36 @@ function generateInheritedPropertyInterfaceAdapters(ctx, classDef, genericEnv) {
         continue;
       }
       const source = `((${receiverType})this).${memberName}`;
-      const getter = isMemberWithEntries(member) ? collectionReadExpression(
+      const memberSaved = memberSavedForStorage(
         ctx,
-        member,
-        `node.Get<${neoMemberNodeType(member)}>("${escapeCSharpString(schemaKey)}")`,
-        schemaKey,
-        resolveMemberById(ctx, member.entryMemberId, "entryMemberId"),
-        memberSavedForStorage(ctx, memberId, false, declarationClass.id),
-        null,
-        genericEnv,
-        interfaceValueType,
-        false
-      ) : [`return (${interfaceValueType})(object)${source}!;`];
+        memberId,
+        false,
+        declarationClass.id
+      );
+      const getter = isMemberWithEntries(member) ? [
+        ...detachedReadExpression(
+          ctx,
+          member,
+          schemaKey,
+          memberSaved,
+          null,
+          genericEnv,
+          declarationClass.id,
+          false
+        ),
+        ...collectionReadExpression(
+          ctx,
+          member,
+          `node.Get<${neoMemberNodeType(member)}>("${escapeCSharpString(schemaKey)}")`,
+          schemaKey,
+          resolveMemberById(ctx, member.entryMemberId, "entryMemberId"),
+          memberSaved,
+          null,
+          genericEnv,
+          interfaceValueType,
+          false
+        )
+      ] : [`return (${interfaceValueType})(object)${source}!;`];
       const hasSetter = isMemberNSPropertyBase(member) && typeof member.setterCode === "string";
       const adapter = [
         `${interfaceValueType} ${interfaceType2}.${memberName}`,
@@ -190637,7 +191207,7 @@ function readExpression(ctx, member, schemaKey, nodeType, saved, ownerClassName,
     )
   ];
 }
-function detachedReadExpression(ctx, member, schemaKey, saved, writeGuardMemberName, genericEnv, ownerClassId) {
+function detachedReadExpression(ctx, member, schemaKey, saved, writeGuardMemberName, genericEnv, ownerClassId, genericBindingSaved = saved) {
   if (ownerClassId === void 0 || !classSupportsDetachedViews(ctx, ownerClassId)) {
     return [];
   }
@@ -190667,7 +191237,13 @@ function detachedReadExpression(ctx, member, schemaKey, saved, writeGuardMemberN
       saved,
       genericEnv
     );
-    const entryType = csharpValueType(ctx, entryMember, saved, genericEnv);
+    const entryType = csharpValueType(
+      ctx,
+      entryMember,
+      saved,
+      genericEnv,
+      genericBindingSaved
+    );
     if (readEntry2 === null || entryType === null) return [];
     const guardArguments = collectionGuardArguments(
       member,
@@ -190675,10 +191251,10 @@ function detachedReadExpression(ctx, member, schemaKey, saved, writeGuardMemberN
     );
     const [viewType, view] = saved ? [
       `NeoList<${entryType}>`,
-      `DetachedList<${entryType}>("${key}", entry => ${readEntry2}, (client, child) => ${childConverter(ctx, entryMember, true, writeGuardMemberName != null, genericEnv)}, item => ${entrySerializeExpression(ctx, entryMember, `writableNode.Get<NeoMemberListWritable>("${key}")`, member.name, genericEnv)}${guardArguments})`
+      `DetachedList<${entryType}>("${key}", entry => ${readEntry2}, (client, child) => ${childConverter(ctx, entryMember, true, writeGuardMemberName != null, genericEnv, genericBindingSaved)}, item => ${entrySerializeExpression(ctx, entryMember, `writableNode.Get<NeoMemberListWritable>("${key}")`, member.name, genericEnv, genericBindingSaved)}${guardArguments})`
     ] : [
       `NeoReadOnlyList<${entryType}>`,
-      `DetachedReadOnlyList<${entryType}>("${key}", entry => ${readEntry2}, (client, child) => ${childConverter(ctx, entryMember, false, false, genericEnv)})`
+      `DetachedReadOnlyList<${entryType}>("${key}", entry => ${readEntry2}, (client, child) => ${childConverter(ctx, entryMember, false, false, genericEnv, genericBindingSaved)})`
     ];
     return [
       `if (TryReadDetached("${key}", out _))`,
@@ -191556,7 +192132,13 @@ function childConverter(ctx, member, saved = false, branchOnReadOnly = false, ge
   }
   if (isClassTypedMember(member)) {
     const typeName = ctx.typeNames.get(member.classId) ?? "NeoNode";
-    const constructedSuffix = constructedTypeArgumentsSuffix(ctx, member, true, genericEnv) ?? "";
+    const constructedSuffix = constructedTypeArgumentsSuffix(
+      ctx,
+      member,
+      true,
+      genericEnv,
+      genericBindingSaved
+    ) ?? "";
     const savedTypeRef = `${qualifyGeneratedType(ctx, savedTypeName(typeName))}${constructedSuffix}`;
     const hasWritableFamily = schemaClassHasWritableFamily(ctx, member.classId);
     if (saved && branchOnReadOnly && hasWritableFamily) {
@@ -195138,7 +195720,7 @@ var UNITY_CODEGEN_REVISION;
 var init_unity_codegen_revision = __esm({
   "../src/models/exports/unity-codegen-revision.ts"() {
     "use strict";
-    UNITY_CODEGEN_REVISION = "e875228ee779f868c2c818eb9e245604cd074598712ffd3f8394f460317b1a28";
+    UNITY_CODEGEN_REVISION = "f748ddae5544d547b4d1139dcdbc86b86b01ab0aae4a9a24656ad8858258b460";
   }
 });
 
@@ -216276,7 +216858,7 @@ var releaseWorkspaceLock = () => void 0;
 async function main() {
   const args = parseArgs(process.argv.slice(2));
   if (args.command === "--version") {
-    console.log("0.84.3");
+    console.log("0.84.5");
     return;
   }
   if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {