@neocompose/cli 0.81.1 → 0.81.3

package/dist/neo.mjs

@@ -1291,6 +1291,15 @@ function neoScriptRegistryEntryType(typeName) {
   }
   return REGISTRY_ENTRY_TYPES[typeName] ?? null;
 }
+function typeArgumentArityMessage(typeName, expected, provided) {
+  return `Type '${typeName}' expects ${expected} type argument${expected === 1 ? "" : "s"}, but ${provided} ${provided === 1 ? "was" : "were"} provided.`;
+}
+function genericParameterArgumentsMessage(name) {
+  return `Generic parameter '${name}' cannot receive type arguments.`;
+}
+function delegateArityMessage(provided) {
+  return `Type 'NeoDelegate' expects a return type followed by up to ${NEOSCRIPT_DELEGATE_MAX_PARAMETERS} parameter types, but ${provided} type arguments were provided.`;
+}
 function neoScriptRegistryReferenceType(entryTypeName) {
   for (const definition2 of Object.values(REGISTRY_ENTRY_TYPES)) {
     if (definition2.entryType === entryTypeName) return definition2.refType;
@@ -1376,7 +1385,7 @@ function vectorTypes() {
     members: structuredLeafFieldProperties(name)
   }));
 }
-var NEO_PROJECT_IGNORED_DIRECTORY_NAMES, NEOSCRIPT_KEYWORDS, NEOSCRIPT_INFERRED_LOCAL_KEYWORD, NEOSCRIPT_CONSTRUCTOR_KEYWORD, NEOSCRIPT_PRIMITIVE_TYPES, NEOSCRIPT_BUILTIN_ANNOTATION_TYPES, NEOSCRIPT_BUILTIN_NAMESPACES, NEOSCRIPT_BUILTIN_TYPES, NEO_VARIANT_TYPE_NAME, NEO_VARIANT_FOLDER_TYPE_NAME, NEO_LOOKUP_VARIANT_TYPE_NAME, NEO_LOOKUP_VARIANT_FOLDER_TYPE_NAME, NEO_VARIANT_SCOPE_NAME, NEO_VARIANT_RESERVED_NAME, NEO_VARIANT_FOLDER_PATH_SEPARATOR, NEOSCRIPT_OPERATORS, STRING_TYPE2, INT_TYPE2, FLOAT_TYPE, DECIMAL_TYPE, BOOL_TYPE2, IMAGE_REF_TYPE, SPRITE_INFO_TYPE, VECTOR2_TYPE, FLOAT_OPTIONAL_TYPE, NEOSCRIPT_STRUCTURED_LEAF_FIELDS, NEOSCRIPT_IMAGE_REGISTRY_TYPE, NEOSCRIPT_AUDIO_CLIP_REGISTRY_TYPE, NEOSCRIPT_PENDING_SYMBOL_ID_PREFIX, REGISTRY_ENTRY_TYPES, NEOSCRIPT_GLOBALS, NEOSCRIPT_SCALAR_METHODS, NEOSCRIPT_CLASS_ID_MEMBER, NEOSCRIPT_ON_CHANGED_MEMBER, NEOSCRIPT_CLASS_ID_SYMBOL, NEOSCRIPT_PRIMITIVE_DERIVED_MEMBERS, NEOSCRIPT_SPRITE_INFO_EMPTY_MEMBER_ID, NEOSCRIPT_SPRITE_INFO_EMPTY_VALUE, NEOSCRIPT_MATH_TYPE_ID, MATH_INFERENCE_RULE, MATH_INTEGRAL_RULE, NEOSCRIPT_LIST_TYPE_NAME, NEOSCRIPT_LIST_TYPE_ID, NEOSCRIPT_LIST_REPEAT_NAME, LIST_ENTRY_TYPE, NEOSCRIPT_BUILTIN_TYPE_SYMBOLS;
+var NEO_PROJECT_IGNORED_DIRECTORY_NAMES, NEOSCRIPT_KEYWORDS, NEOSCRIPT_INFERRED_LOCAL_KEYWORD, NEOSCRIPT_CONSTRUCTOR_KEYWORD, NEOSCRIPT_PRIMITIVE_TYPES, NEOSCRIPT_BUILTIN_ANNOTATION_TYPES, NEOSCRIPT_BUILTIN_NAMESPACES, NEOSCRIPT_BUILTIN_TYPES, NEO_VARIANT_TYPE_NAME, NEO_VARIANT_FOLDER_TYPE_NAME, NEO_LOOKUP_VARIANT_TYPE_NAME, NEO_LOOKUP_VARIANT_FOLDER_TYPE_NAME, NEO_VARIANT_SCOPE_NAME, NEO_VARIANT_RESERVED_NAME, NEO_VARIANT_FOLDER_PATH_SEPARATOR, NEOSCRIPT_OPERATORS, STRING_TYPE2, INT_TYPE2, FLOAT_TYPE, DECIMAL_TYPE, BOOL_TYPE2, IMAGE_REF_TYPE, SPRITE_INFO_TYPE, VECTOR2_TYPE, FLOAT_OPTIONAL_TYPE, NEOSCRIPT_STRUCTURED_LEAF_FIELDS, NEOSCRIPT_IMAGE_REGISTRY_TYPE, NEOSCRIPT_AUDIO_CLIP_REGISTRY_TYPE, NEOSCRIPT_PENDING_SYMBOL_ID_PREFIX, REGISTRY_ENTRY_TYPES, NEOSCRIPT_DELEGATE_MAX_PARAMETERS, NEOSCRIPT_GLOBALS, NEOSCRIPT_SCALAR_METHODS, NEOSCRIPT_CLASS_ID_MEMBER, NEOSCRIPT_ON_CHANGED_MEMBER, NEOSCRIPT_CLASS_ID_SYMBOL, NEOSCRIPT_PRIMITIVE_DERIVED_MEMBERS, NEOSCRIPT_SPRITE_INFO_EMPTY_MEMBER_ID, NEOSCRIPT_SPRITE_INFO_EMPTY_VALUE, NEOSCRIPT_MATH_TYPE_ID, MATH_INFERENCE_RULE, MATH_INTEGRAL_RULE, NEOSCRIPT_LIST_TYPE_NAME, NEOSCRIPT_LIST_TYPE_ID, NEOSCRIPT_LIST_REPEAT_NAME, LIST_ENTRY_TYPE, NEOSCRIPT_BUILTIN_TYPE_SYMBOLS;
 var init_language_spec = __esm({
   "../packages/neoscript-language/src/language-spec.ts"() {
     "use strict";
@@ -1652,6 +1661,7 @@ var init_language_spec = __esm({
         refType: { kind: "primitive", name: "AudioClipRef" }
       }
     };
+    NEOSCRIPT_DELEGATE_MAX_PARAMETERS = 16;
     NEOSCRIPT_GLOBALS = [
       builtinFunction(
         "VisitCount",
@@ -30982,21 +30992,34 @@ function resolveNeoScriptType(type, context, project) {
       const declaringType = declaringTypeRef?.kind === "named" ? project.typeById.get(declaringTypeRef.typeId) : void 0;
       const byName = (candidate) => candidate.name === type.name;
       const typeParameter2 = context.typeParameters?.find(byName) ?? declaringType?.typeParameters?.find(byName);
+      const written = type.typeArguments?.length ?? 0;
       if (typeParameter2?.type.kind === "typeParameter") {
+        if (written > 0)
+          throw new CompileError(
+            genericParameterArgumentsMessage(type.name),
+            type.pos
+          );
         resolved = typeParameter2.type;
         break;
       }
       const builtin = namedPrimitive(type.name);
+      const registryReference = builtin ? null : neoScriptRegistryReferenceType(type.name);
+      if ((builtin || registryReference) && written > 0)
+        throw new CompileError(
+          typeArgumentArityMessage(type.name, 0, written),
+          type.pos
+        );
       if (builtin) {
         resolved = { kind: "primitive", name: builtin };
         break;
       }
-      const registryReference = neoScriptRegistryReferenceType(type.name);
       if (registryReference) {
         resolved = registryReference;
         break;
       }
       if (type.name === "NeoDelegate") {
+        if (written > NEOSCRIPT_DELEGATE_MAX_PARAMETERS + 1)
+          throw new CompileError(delegateArityMessage(written), type.pos);
         const [returnType, ...parameterTypes] = (type.typeArguments ?? []).map(
           (argument2) => resolveNeoScriptType(argument2, context, project)
         );
@@ -31014,6 +31037,7 @@ function resolveNeoScriptType(type, context, project) {
           renamedDialogueTypeMessage(type.name, "value") ?? `Unknown type '${type.name}'`,
           type.pos
         );
+      if (written > 0) assertTypeArgumentCount(named, written, type.pos);
       resolved = {
         kind: "named",
         typeId: named.id,
@@ -31082,6 +31106,14 @@ function assertDirectTypeParameterArguments(target, pos, project) {
   const message = wrappedTypeParameterMessage(target, project);
   if (message !== null) throw new CompileError(message, pos);
 }
+function assertTypeArgumentCount(declaring, count, pos) {
+  const expected = declaring.typeParameters?.length ?? 0;
+  if (count === expected) return;
+  throw new CompileError(
+    typeArgumentArityMessage(declaring.name, expected, count),
+    pos
+  );
+}
 function assertTypeArgumentConstraints(declaring, type, pos, project) {
   declaring.typeParameters?.forEach((parameter4, index) => {
     const argument2 = type.typeArguments?.[index];
@@ -36849,13 +36881,12 @@ var init_strict_resolver = __esm({
         const typeArguments = expression.typeArguments?.map(
           (argument2) => this.resolveType(argument2)
         );
-        if (typeArguments !== void 0 && typeArguments.length !== (schemaClass2.typeParameters?.length ?? 0)) {
-          throw new CompileError(
-            `Class '${schemaClass2.name}' expects ${schemaClass2.typeParameters?.length ?? 0} type argument${schemaClass2.typeParameters?.length === 1 ? "" : "s"} but got ${typeArguments.length}.`,
+        if (typeArguments !== void 0) {
+          assertTypeArgumentCount(
+            schemaClass2,
+            typeArguments.length,
             expression.pos
           );
-        }
-        if (typeArguments !== void 0) {
           const target = {
             kind: "named",
             typeId: schemaClass2.id,
@@ -50946,20 +50977,20 @@ function validateTypeApplication(uri, type, genericParameters, environment, diag
         uri,
         type.range,
         "generic-parameter-arguments",
-        `Generic parameter '${type.name}' cannot receive type arguments.`
+        genericParameterArgumentsMessage(type.name)
       );
     }
     return;
   }
   const target = environment.declarations.get(type.name);
   if (type.name === "NeoDelegate") {
-    if (type.typeArguments.length < 1 || type.typeArguments.length > 17) {
+    if (type.typeArguments.length < 1 || type.typeArguments.length > NEOSCRIPT_DELEGATE_MAX_PARAMETERS + 1) {
       diagnose(
         diagnostics,
         uri,
         type.range,
         "generic-argument-arity",
-        `Type 'NeoDelegate' expects a return type followed by up to 16 parameter types, but ${type.typeArguments.length} type arguments were provided.`
+        delegateArityMessage(type.typeArguments.length)
       );
     }
     return;
@@ -50974,13 +51005,13 @@ function validateTypeApplication(uri, type, genericParameters, environment, diag
         "Type 'NeoAction' cannot use 'void' as a parameter type; spell a zero-argument action as bare 'NeoAction'."
       );
     }
-    if (type.typeArguments.length > 16) {
+    if (type.typeArguments.length > NEOSCRIPT_DELEGATE_MAX_PARAMETERS) {
       diagnose(
         diagnostics,
         uri,
         type.range,
         "generic-argument-arity",
-        `Type 'NeoAction' expects up to 16 parameter types, but ${type.typeArguments.length} type arguments were provided.`
+        `Type 'NeoAction' expects up to ${NEOSCRIPT_DELEGATE_MAX_PARAMETERS} parameter types, but ${type.typeArguments.length} type arguments were provided.`
       );
     }
     if (type.nullable) {
@@ -51002,7 +51033,7 @@ function validateTypeApplication(uri, type, genericParameters, environment, diag
       uri,
       type.range,
       "generic-argument-arity",
-      `Type '${type.name}' expects ${expected} type argument${expected === 1 ? "" : "s"}, but ${type.typeArguments.length} ${type.typeArguments.length === 1 ? "was" : "were"} provided.`,
+      typeArgumentArityMessage(type.name, expected, type.typeArguments.length),
       target ? related(target.location, "The type declaration is here.") : void 0
     );
     return;
@@ -54533,7 +54564,7 @@ var init_registry = __esm({
   "../packages/manifest/schema-contract/registry.mjs"() {
     "use strict";
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
-      cliVersion: "0.81.1",
+      cliVersion: "0.81.3",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -77377,7 +77408,7 @@ function readNeoScriptRuntimeRow(ctx, valueId) {
 }
 function inspectNeoScriptValueReference(ctx, value, collection, index) {
   let id2 = findKnownRowIdByValueReference(value, ctx);
-  if (id2 === null && collection !== void 0 && index !== void 0 && typeof value === "string" && (findKnownRowIdByValueReference(collection, ctx) !== null || Array.isArray(collection) && typeof index === "number" && ctx.__unorderedListProjections?.referenceEntryIndexesByArray.get(collection)?.has(index) || typeof collection === "object" && collection !== null && typeof index === "string" && ctx.__unorderedListProjections?.referenceEntryKeysByRecord.get(collection)?.has(index))) {
+  if (id2 === null && collection !== void 0 && index !== void 0 && typeof value === "string" && isReferenceEntry(collectionReferences(collection, ctx), index)) {
     id2 = value;
   }
   if (id2 === null) return null;
@@ -79038,15 +79069,9 @@ function evalActionListenerInstruction(ins, scope, ctx, options) {
   }
   let destination;
   const target = ins.target.pointer;
-  const currentValue = target.type === "keyOf" /* keyOf */ ? evalKeyOf(
-    target.keyOf,
-    scope,
-    ctx,
-    target.optional === true,
-    (resolved) => {
-      destination = resolved;
-    }
-  ) : evalPointer(target, scope, ctx);
+  const currentValue = target.type === "keyOf" /* keyOf */ ? evalKeyOf(target, scope, ctx, (resolved) => {
+    destination = resolved;
+  }) : evalPointer(target, scope, ctx);
   const current = actionListenersOf(currentValue, () => `'${operator}' target`);
   const identity2 = nsActionListenerIdentity(listener);
   const present = current.some(
@@ -79117,38 +79142,26 @@ function applyOverlayAssignment(target, targetTypeInfo, value, scope, ctx, desti
         );
       }
       receiver[index] = referenceValueId;
-      setCollectionReferenceProvenance(receiver, index, true, ctx);
+      recordWrittenEntry(receiver, index, true, ctx);
       invalidateEvaluatorIndexes(ctx, receiver);
       return;
     }
-    if (ctx.__unorderedListProjections?.referenceEntryIndexesByArray.has(
-      receiver
-    ) === true) {
-      receiver[index] = value;
-      setCollectionReferenceProvenance(receiver, index, false, ctx);
-      invalidateEvaluatorIndexes(ctx, receiver);
+    if (collectionReferences(receiver, ctx) === 0 /* RowIds */ && replaceEntryRowValue(
+      receiver,
+      receiver[index],
+      value,
+      targetTypeInfo,
+      ctx
+    ))
       return;
-    }
-    const existing2 = receiver[index];
-    if (typeof existing2 === "string") {
-      const row = evalValueById(
-        ctx,
-        existing2,
-        ctx.__runtimeSessionValues,
-        ctx.__valueOverlay
-      );
-      if (row !== null) {
-        replaceRowValue(row, value, receiver, ctx);
-        updateUnorderedListProjectionAfterAssignment(row, value, ctx);
-        return;
-      }
-    }
     receiver[index] = value;
+    recordWrittenEntry(receiver, index, false, ctx);
     invalidateEvaluatorIndexes(ctx, receiver);
     return;
   }
   const object2 = objectArg(receiver, "Assignment target");
   const stringKey = String(key);
+  const field = target.memberId !== void 0;
   if (referenceValueId !== null) {
     const parentId = findKnownRowIdByValueReference(receiver, ctx);
     if (parentId !== null) {
@@ -79163,26 +79176,41 @@ function applyOverlayAssignment(target, targetTypeInfo, value, scope, ctx, desti
       );
     }
     object2[stringKey] = referenceValueId;
+    if (!field) recordWrittenEntry(object2, stringKey, true, ctx);
     invalidateEvaluatorIndexes(ctx, receiver);
     return;
   }
-  const existing = object2[stringKey];
-  if (typeof existing === "string") {
-    const row = evalValueById(
-      ctx,
-      existing,
-      ctx.__runtimeSessionValues,
-      ctx.__valueOverlay
-    );
-    if (row !== null) {
-      replaceRowValue(row, value, receiver, ctx);
-      updateUnorderedListProjectionAfterAssignment(row, value, ctx);
-      return;
-    }
-  }
+  if (collectionReferences(object2, ctx) === 0 /* RowIds */ && replaceEntryRowValue(object2, object2[stringKey], value, targetTypeInfo, ctx))
+    return;
   object2[stringKey] = value;
+  if (!field) recordWrittenEntry(object2, stringKey, false, ctx);
   invalidateEvaluatorIndexes(ctx, receiver);
 }
+function replaceEntryRowValue(receiver, existing, value, targetTypeInfo, ctx) {
+  if (typeof existing !== "string") return false;
+  const row = evalValueById(
+    ctx,
+    existing,
+    ctx.__runtimeSessionValues,
+    ctx.__valueOverlay
+  );
+  if (row === null) return false;
+  keepAssignedCollectionValues(value, targetTypeInfo, ctx);
+  replaceRowValue(row, value, receiver, ctx);
+  updateUnorderedListProjectionAfterAssignment(row, value, ctx);
+  return true;
+}
+function keepAssignedCollectionValues(value, targetTypeInfo, ctx) {
+  const cache = unorderedListProjectionCache(ctx);
+  if (Array.isArray(value) && (targetTypeInfo.type === 6 /* List */ || targetTypeInfo.type === 28 /* Set */)) {
+    if (!cache.referenceEntryIndexesByArray.has(value))
+      cache.referenceEntryIndexesByArray.set(value, /* @__PURE__ */ new Set());
+    return;
+  }
+  if (targetTypeInfo.type === 5 /* Dictionary */ && typeof value === "object" && value !== null && !cache.referenceEntryKeysByRecord.has(value)) {
+    cache.referenceEntryKeysByRecord.set(value, /* @__PURE__ */ new Set());
+  }
+}
 function replaceRowValue(row, value, receiver, ctx) {
   const indexes3 = ctx.__indexes;
   if (indexes3 === void 0 || ctx.__runtimeSessionValues?.get(row.id) !== row || !indexes3.indexedRowIds.has(row.id)) {
@@ -79620,9 +79648,11 @@ function evalCollectionMutationInstruction(ins, scope, ctx, options) {
     );
   }
   const unorderedEntriesBeforeMutation = unorderedContainerValueId === null || !Array.isArray(targetValue) || ins.mutation === "Add" /* Add */ ? null : [...targetValue];
-  if ((ins.mutation === "Add" /* Add */ || ins.mutation === "Insert" /* Insert */) && !isLookupSet) {
+  const writesEntry = (ins.mutation === "Add" /* Add */ || ins.mutation === "Insert" /* Insert */) && !isLookupSet;
+  let attachedValueId = null;
+  if (writesEntry) {
     const attachedValue = isArrayCollection(targetValue) && ins.mutation !== "Insert" /* Insert */ ? args[0] : args[1];
-    const attachedValueId = findKnownRowIdByValueReference(attachedValue, ctx);
+    attachedValueId = findKnownRowIdByValueReference(attachedValue, ctx);
     const parentId = findKnownRowIdByValueReference(targetValue, ctx);
     if (attachedValueId !== null && parentId !== null) {
       ctx.assertCollectionEntryAttachable?.(
@@ -79659,6 +79689,23 @@ function evalCollectionMutationInstruction(ins, scope, ctx, options) {
     removedIndex,
     ctx
   );
+  if (writesEntry && !(targetValue instanceof RuntimeSet)) {
+    const writtenAsRowId = attachedValueId !== null || unorderedContainerValueId !== null;
+    if (Array.isArray(targetValue))
+      recordWrittenEntry(
+        targetValue,
+        removedIndex ?? targetValue.length - 1,
+        writtenAsRowId,
+        ctx
+      );
+    else
+      recordWrittenEntry(
+        objectArg(targetValue, "Dictionary Add target"),
+        String(args[0]),
+        writtenAsRowId,
+        ctx
+      );
+  }
   if (unorderedEntriesBeforeMutation !== null && Array.isArray(targetValue)) {
     detachRemovedUnorderedScalarEntries(
       unorderedEntriesBeforeMutation,
@@ -79860,9 +79907,10 @@ function runtimeSet(array3, reference2, enumEntries, ctx) {
   const existing = sets.get(array3);
   if (existing !== void 0) return existing;
   const set = new RuntimeSet(array3, reference2, enumEntries);
+  const references = collectionReferences(array3, ctx);
   for (let index = 0; index < array3.length; index++) {
     const raw = array3[index];
-    const resolves = collectionEntryUsesReferenceResolution(array3, index, ctx);
+    const resolves = isReferenceEntry(references, index);
     const value = resolves ? resolveValueIfId(raw, ctx) : raw;
     const key = runtimeSetKey(value, set, ctx);
     set.add(key, enumEntries ? key : raw, !enumEntries && resolves);
@@ -79871,9 +79919,9 @@ function runtimeSet(array3, reference2, enumEntries, ctx) {
   (ctx.__dirtyRuntimeSets ??= /* @__PURE__ */ new Set()).add(set);
   return set;
 }
-function storedSetEntryMatch(raw, entryMember, ctx) {
+function storedSetEntryMatch(raw, reference2, entryMember, ctx) {
   const byIdentity = entryMember.kind === 7 /* Class */;
-  const row = byIdentity || typeof raw !== "string" ? null : evalValueById(ctx, raw, ctx.__runtimeSessionValues, ctx.__valueOverlay);
+  const row = byIdentity || !reference2 || typeof raw !== "string" ? null : evalValueById(ctx, raw, ctx.__runtimeSessionValues, ctx.__valueOverlay);
   const valueId = byIdentity && typeof raw === "string" ? raw : row?.id ?? null;
   const entry = row === null ? { id: "", value: raw } : { id: row.id, value: row.value };
   const key = byIdentity ? valueId ?? referenceIdOf(raw, ctx) : setEntryKey(entryMember, entry);
@@ -79884,8 +79932,14 @@ function storedSetEntries(set, entryMember, ctx) {
   const existing = indexes3.get(set);
   if (existing !== void 0) return existing;
   const entries = /* @__PURE__ */ new Map();
-  for (const raw of set) {
-    const match = storedSetEntryMatch(raw, entryMember, ctx);
+  const references = collectionReferences(set, ctx);
+  for (let index = 0; index < set.length; index++) {
+    const match = storedSetEntryMatch(
+      set[index],
+      isReferenceEntry(references, index),
+      entryMember,
+      ctx
+    );
     if (match !== null && !entries.has(match.key)) {
       entries.set(match.key, match);
     }
@@ -79897,7 +79951,13 @@ function syncStoredSetEntries(set, mutation, removed, entryMember, ctx) {
   const entries = ctx.__setEntryIndexes?.get(set);
   if (entries === void 0) return;
   if (entryMember !== null && mutation === "Add" /* Add */) {
-    const added = storedSetEntryMatch(set[set.length - 1], entryMember, ctx);
+    const index = set.length - 1;
+    const added = storedSetEntryMatch(
+      set[index],
+      isReferenceEntry(collectionReferences(set, ctx), index),
+      entryMember,
+      ctx
+    );
     if (added !== null) entries.set(added.key, added);
     return;
   }
@@ -79963,6 +80023,7 @@ function applyLocalCollectionMutation(targetValue, mutation, args, ctx, unique =
       return null;
     case "Remove" /* Remove */:
       if (Array.isArray(targetValue)) {
+        const references = resolveRemovalEntries ? collectionReferences(targetValue, ctx) : recordedReferenceEntries(targetValue, ctx) ?? 1 /* Values */;
         let index = -1;
         for (let candidate = 0; candidate < targetValue.length; candidate += 1) {
           const entry = targetValue[candidate];
@@ -79973,9 +80034,8 @@ function applyLocalCollectionMutation(targetValue, mutation, args, ctx, unique =
             }
             continue;
           }
-          const referenceEntry = ctx.__unorderedListProjections?.referenceEntryIndexesByArray.get(targetValue)?.has(candidate) === true;
           if (jsEqual(
-            resolveRemovalEntries || referenceEntry ? resolveCollectionEntry(targetValue, entry, candidate, ctx) : entry,
+            typeof entry === "string" && isReferenceEntry(references, candidate) ? resolveValueIfId(entry, ctx) : entry,
             args[0]
           )) {
             index = candidate;
@@ -80008,13 +80068,6 @@ function applyLocalCollectionMutation(targetValue, mutation, args, ctx, unique =
       return null;
   }
 }
-function setCollectionReferenceProvenance(targetValue, index, reference2, ctx) {
-  const cache = ctx.__unorderedListProjections;
-  const indexes3 = cache?.referenceEntryIndexesByArray.get(targetValue);
-  if (cache === void 0 || indexes3 === void 0) return;
-  if (reference2) indexes3.add(index);
-  else indexes3.delete(index);
-}
 function updateCollectionReferenceProvenance(targetValue, mutation, removedIndex, ctx) {
   if (!Array.isArray(targetValue)) return;
   const cache = ctx.__unorderedListProjections;
@@ -80288,7 +80341,7 @@ function evalPointerCore(pointer, scope, ctx, resultUsage = "value") {
     case "staticMember" /* staticMember */:
       return evalStaticMember(pointer.memberId, ctx);
     case "keyOf" /* keyOf */:
-      return evalKeyOf(pointer.keyOf, scope, ctx, pointer.optional === true);
+      return evalKeyOf(pointer, scope, ctx);
     case "operation" /* operation */:
       return evalOperation(pointer.operation, scope, ctx);
     case "function" /* function */:
@@ -80938,15 +80991,9 @@ function readActionWithOwner(pointer, scope, ctx) {
     return { action: evalPointer(pointer, scope, ctx), owner: null };
   }
   let owner = null;
-  const action = evalKeyOf(
-    pointer.keyOf,
-    scope,
-    ctx,
-    pointer.optional === true,
-    (destination) => {
-      owner = destination.receiver;
-    }
-  );
+  const action = evalKeyOf(pointer, scope, ctx, (destination) => {
+    owner = destination.receiver;
+  });
   return { action, owner };
 }
 function actionPointerLabel(pointer, ctx) {
@@ -81863,7 +81910,9 @@ function isRuntimeSpriteValue(value) {
   const sliceIndex = value.sliceIndex;
   return typeof sliceIndex === "number" && Number.isInteger(sliceIndex) && sliceIndex >= 0;
 }
-function evalKeyOf(keyOf, scope, ctx, optional2 = false, onDestination) {
+function evalKeyOf(pointer, scope, ctx, onDestination) {
+  const { keyOf } = pointer;
+  const optional2 = pointer.optional === true;
   const receiver = evalPointer(keyOf.pointer, scope, ctx);
   if (optional2 && (receiver === null || receiver === void 0)) {
     return null;
@@ -81924,7 +81973,7 @@ function evalKeyOf(keyOf, scope, ctx, optional2 = false, onDestination) {
     if (dispatched.kind === "ok") return dispatched.value;
     if (Object.prototype.hasOwnProperty.call(receiver, k)) {
       const at3 = receiver[k];
-      return resolveValueIfId(at3, ctx);
+      return typeof at3 === "string" && (pointer.memberId !== void 0 || isReferenceEntry(collectionReferences(receiver, ctx), k)) ? resolveValueIfId(at3, ctx) : at3;
     }
     const expanded = virtualExpandedRecordForReceiver(receiver, ctx);
     if (expanded !== null && Object.prototype.hasOwnProperty.call(expanded, k)) {
@@ -82656,7 +82705,7 @@ function evaluateSystemNative(memberId, receiver, args, ctx, typeArguments) {
           shift,
           accepts
         );
-        return { handled: true, value };
+        return { handled: true, value: referenceEntryList(value, ctx) };
       }
       if (memberId === NEO_OBJECT_GRID_MEMBER_IDS.GetTiles) {
         const value = index.tiles(
@@ -82666,7 +82715,7 @@ function evaluateSystemNative(memberId, receiver, args, ctx, typeArguments) {
           shift,
           accepts
         );
-        return { handled: true, value };
+        return { handled: true, value: referenceEntryList(value, ctx) };
       }
       const tile = index.tile(
         placement,
@@ -83275,7 +83324,17 @@ function evalDeclaredListIndex(info, scope, ctx) {
     collectionIndexes.set(cacheKey, index);
   }
   if (info.keyPointer === void 0) {
-    return Object.fromEntries(index);
+    const view = Object.fromEntries(index);
+    if (info.unique) {
+      unorderedListProjectionCache(ctx).referenceEntryKeysByRecord.set(
+        view,
+        new Set(index.keys())
+      );
+    } else {
+      for (const bucket of index.values())
+        if (Array.isArray(bucket)) referenceEntryList(bucket, ctx);
+    }
+    return view;
   }
   const key = evalPointer(info.keyPointer, scope, ctx);
   if (typeof key !== "string") {
@@ -83287,7 +83346,12 @@ function evalDeclaredListIndex(info, scope, ctx) {
   if (info.unique) {
     return typeof hit === "string" ? resolveValueIfId(hit, ctx) : null;
   }
-  return Array.isArray(hit) ? [...hit] : [];
+  return referenceEntryList(Array.isArray(hit) ? [...hit] : [], ctx);
+}
+function referenceEntryList(list, ctx) {
+  const indexes3 = unorderedListProjectionCache(ctx).referenceEntryIndexesByArray;
+  if (!indexes3.has(list)) indexes3.set(list, new Set(list.keys()));
+  return list;
 }
 function prepareCollectionCallback(callback, parentScope, ctx, isList, returnContract, onPredicateMatch) {
   const metrics = ctx.__collectionCallbackPreparationMetrics;
@@ -83851,7 +83915,7 @@ function evalFunction(fn, scope, ctx) {
       if (fn.info.reference === true) {
         return referenceIndexOf(c, target, ctx) !== null;
       }
-      const targetReferenceId = typeof target === "string" ? target : findKnownRowIdByValueReference(target, ctx);
+      const targetReferenceId = typeof target === "string" ? null : findKnownRowIdByValueReference(target, ctx);
       let containsResolvedEntry = false;
       iterateCollection(c, ctx, (entry, _key, valueId) => {
         if (valueId !== null && valueId === targetReferenceId || jsEqual(entry, target)) {
@@ -83872,7 +83936,7 @@ function evalFunction(fn, scope, ctx) {
         const index = referenceIndexOf(collection, target, ctx);
         return index === null ? -1 : numberArg(index, "IndexOf index");
       }
-      const targetReferenceId = typeof target === "string" ? target : findKnownRowIdByValueReference(target, ctx);
+      const targetReferenceId = typeof target === "string" ? null : findKnownRowIdByValueReference(target, ctx);
       let found = -1;
       iterateCollection(collection, ctx, (entry, key, valueId) => {
         if (valueId !== null && valueId === targetReferenceId || jsEqual(entry, target)) {
@@ -84136,9 +84200,27 @@ function validateClassConstructorDescriptor(info, ctx, requireEveryRequiredField
       `Cannot construct abstract Class '${schemaClass2.name}'.`
     );
   }
-  const genericSlot = ctx.__constructionGenericSlots?.toReversed().find((slot) => slot.classId === classId) ?? ctx.__storedConstructionReplaySlot;
-  const slotArguments = genericSlot?.classId === classId ? genericSlot.classArguments : void 0;
-  const typeArguments = slotArguments === void 0 ? receiverClosedTypeArguments(info.schemaClassInfo.typeArguments, ctx) : void 0;
+  const typeArguments = receiverClosedTypeArguments(
+    info.schemaClassInfo.typeArguments,
+    ctx
+  );
+  const matchesSlot = (slot) => {
+    if (slot.classId !== classId) return false;
+    if (typeArguments === void 0) return true;
+    const env = cachedInstanceEnv(classId, slot.classArguments, ctx);
+    return Object.entries(typeArguments).every(([parameterId, typeInfo]) => {
+      const binding = env.get(parameterId);
+      if (binding?.kind !== "member") return false;
+      const member = evalMemberById(ctx.vm, binding.memberId);
+      return member !== null && typeInfosInvariantlyEqual(
+        runtimeTypeInfoForMember(member, env, ctx, /* @__PURE__ */ new Set()),
+        typeInfo
+      );
+    });
+  };
+  const genericSlot = ctx.__constructionGenericSlots?.findLast(matchesSlot);
+  const replaySlot = ctx.__storedConstructionReplaySlot;
+  const slotArguments = genericSlot?.classArguments ?? (replaySlot !== void 0 && matchesSlot(replaySlot) ? replaySlot.classArguments : void 0);
   const descriptorCache = evaluatorValueGeneration(ctx).constructorDescriptors;
   const descriptorCacheKey = `${requireEveryRequiredField}:${ctx.storedConstructionReplay === true}:${JSON.stringify(slotArguments ?? typeArguments ?? null)}`;
   const cachedDescriptor = descriptorCache.get(info)?.get(descriptorCacheKey);
@@ -85014,6 +85096,8 @@ function evaluateDeclaredConstructorArguments(info, record7, scope, ctx) {
       );
     }
     const value = byName.get(parameter4.name);
+    if (parameter4.type === 9 /* Lookup */ && Array.isArray(value))
+      return referenceEntryList(value, ctx);
     if (typeof value !== "number") return value;
     if (parameter4.type === 4 /* Float */) return Math.fround(value);
     if (parameter4.type !== 20 /* Decimal */) return value;
@@ -87967,14 +88051,10 @@ function collectionLength(c) {
 }
 function snapshotCollectionMembership(collection, ctx) {
   const membership = [];
-  const valid = forEachRawCollectionEntry(collection, (entry) => {
+  const valid = forEachRawCollectionEntry(collection, ctx, (entry) => {
     membership.push({
       raw: entry.raw,
-      resolveAsReference: collectionEntryUsesReferenceResolution(
-        collection,
-        entry.key,
-        ctx
-      )
+      resolveAsReference: entry.valueId !== null
     });
     return 0 /* Continue */;
   });
@@ -87983,7 +88063,7 @@ function snapshotCollectionMembership(collection, ctx) {
     "NeoScript foreach requires a present collection."
   );
 }
-function forEachRawCollectionEntry(c, callback) {
+function forEachRawCollectionEntry(c, ctx, callback) {
   if (c instanceof RuntimeSet) {
     for (const [key, entry] of c.membership().entries()) {
       if (callback({
@@ -87995,35 +88075,34 @@ function forEachRawCollectionEntry(c, callback) {
     }
     return true;
   }
+  if (typeof c !== "object" || c === null) return false;
+  const references = collectionReferences(c, ctx);
   if (Array.isArray(c)) {
     for (let key = 0; key < c.length; key += 1) {
       const raw = c[key];
       const control = callback({
         raw,
         key,
-        valueId: typeof raw === "string" ? raw : null
+        valueId: typeof raw === "string" && isReferenceEntry(references, key) ? raw : null
       });
       if (control === 1 /* Break */) break;
     }
     return true;
   }
-  if (typeof c === "object" && c !== null) {
-    for (const [key, raw] of Object.entries(c)) {
-      const control = callback({
-        raw,
-        key,
-        valueId: typeof raw === "string" ? raw : null
-      });
-      if (control === 1 /* Break */) break;
-    }
-    return true;
+  for (const [key, raw] of Object.entries(c)) {
+    const control = callback({
+      raw,
+      key,
+      valueId: typeof raw === "string" && isReferenceEntry(references, key) ? raw : null
+    });
+    if (control === 1 /* Break */) break;
   }
-  return false;
+  return true;
 }
 function collectionEntries(c, ctx) {
   const entries = [];
-  forEachRawCollectionEntry(c, ({ raw, key }) => {
-    entries.push(resolveCollectionEntry(c, raw, key, ctx));
+  forEachRawCollectionEntry(c, ctx, ({ raw, valueId }) => {
+    entries.push(valueId === null ? raw : resolveValueIfId(valueId, ctx));
     return 0 /* Continue */;
   });
   return entries;
@@ -88031,7 +88110,7 @@ function collectionEntries(c, ctx) {
 function referenceIndexOf(c, target, ctx) {
   const targetId = target === null || target === void 0 ? null : referenceIdOf(target, ctx);
   let found = null;
-  forEachRawCollectionEntry(c, ({ raw, key }) => {
+  forEachRawCollectionEntry(c, ctx, ({ raw, key }) => {
     if (raw === target || targetId !== null && raw !== null && raw !== void 0 && referenceIdOf(raw, ctx) === targetId) {
       found = key;
       return 1 /* Break */;
@@ -88041,26 +88120,61 @@ function referenceIndexOf(c, target, ctx) {
   return found;
 }
 function iterateCollection(c, ctx, callback) {
-  forEachRawCollectionEntry(c, ({ raw, key, valueId }) => {
-    const effectiveValueId = collectionEntryUsesReferenceResolution(c, key, ctx) ? valueId : null;
-    return callback(
-      resolveCollectionEntry(c, raw, key, ctx),
+  forEachRawCollectionEntry(
+    c,
+    ctx,
+    ({ raw, key, valueId }) => callback(
+      valueId === null ? raw : resolveValueIfId(valueId, ctx),
       key,
-      effectiveValueId
-    );
-  });
+      valueId
+    )
+  );
 }
 function resolveCollectionEntry(collection, raw, key, ctx) {
-  return collectionEntryUsesReferenceResolution(collection, key, ctx) ? resolveValueIfId(raw, ctx) : raw;
+  return typeof raw === "string" && isReferenceEntry(collectionReferences(collection, ctx), key) ? resolveValueIfId(raw, ctx) : raw;
 }
-function collectionEntryUsesReferenceResolution(collection, key, ctx) {
-  if (collection instanceof RuntimeSet && typeof key === "number")
-    return collection.membership()[key]?.reference === true;
-  if (!Array.isArray(collection) || typeof key !== "number") return true;
-  const referenceIndexes = ctx.__unorderedListProjections?.referenceEntryIndexesByArray.get(
-    collection
-  );
-  return referenceIndexes === void 0 || referenceIndexes.has(key);
+function recordedReferenceEntries(collection, ctx) {
+  const cache = ctx.__unorderedListProjections;
+  if (Array.isArray(collection))
+    return cache?.referenceEntryIndexesByArray.get(collection);
+  if (typeof collection === "object" && collection !== null)
+    return cache?.referenceEntryKeysByRecord.get(collection);
+  return void 0;
+}
+function collectionReferences(collection, ctx) {
+  return recordedReferenceEntries(collection, ctx) ?? (findKnownRowIdByValueReference(collection, ctx) === null ? 1 /* Values */ : 0 /* RowIds */);
+}
+function isReferenceEntry(references, key) {
+  if (references === 0 /* RowIds */) return true;
+  if (references === 1 /* Values */) return false;
+  return references.has(key);
+}
+function recordWrittenEntry(collection, key, reference2, ctx) {
+  const references = collectionReferences(collection, ctx);
+  if (typeof references !== "object") {
+    if (reference2 === (references === 0 /* RowIds */)) return;
+    const written = Array.isArray(collection) ? collection[Number(key)] : collection[String(key)];
+    if (!reference2 && typeof written !== "string") return;
+  }
+  const rowIds = references === 0 /* RowIds */;
+  const cache = unorderedListProjectionCache(ctx);
+  if (Array.isArray(collection)) {
+    let indexes3 = cache.referenceEntryIndexesByArray.get(collection);
+    if (indexes3 === void 0) {
+      indexes3 = new Set(rowIds ? collection.keys() : []);
+      cache.referenceEntryIndexesByArray.set(collection, indexes3);
+    }
+    if (reference2) indexes3.add(Number(key));
+    else indexes3.delete(Number(key));
+    return;
+  }
+  let keys = cache.referenceEntryKeysByRecord.get(collection);
+  if (keys === void 0) {
+    keys = new Set(rowIds ? Object.keys(collection) : []);
+    cache.referenceEntryKeysByRecord.set(collection, keys);
+  }
+  if (reference2) keys.add(String(key));
+  else keys.delete(String(key));
 }
 var DELEGATE_LEXICAL_THIS, DELEGATE_LEXICAL_ROOT, DELEGATE_LEXICAL_TYPE_ARGUMENTS, NonCatchableNSGetterRuntimeError, NativeFunctionDelegateUnavailableError, CorruptNeoScriptIRError, NeoScriptWallClockTimeoutError, liveListIndexesByProject, evaluatorOwnershipCachesByBase, MAX_CONSTRUCTION_DEPTH, resolutionCacheByMembers, NO_SCHEMA_REVISION, LazyValueOverlay, READONLY_FOREACH_BINDING_ERROR, READONLY_CATCH_BINDING_ERROR, DIALOGUE_CONTEXT_PARAMETER_ID, FORWARDING_TYPE_ARGUMENTS, constantDeclarationRoots, NS_MATH_OP_NAMES, DOUBLE_INTEGRAL_MAGNITUDE, EMPTY_SUPPLIED_CONSTRUCTOR_FIELDS, variantResolutionCopiesByOverlay;
 var init_evaluateNSGetter = __esm({
@@ -89290,20 +89404,6 @@ var init_variant_value_graph = __esm({
   }
 });
 
-// ../packages/neoscript-runtime/src/declaration-default-source.ts
-function declarationDefaultSource(id2, stored, resolveGraph) {
-  if (stored !== null && !isCollapseStampedInstanceRoot(stored)) return stored;
-  const graph = resolveGraph(id2);
-  return defaultSourceWithListeners(graph?.rowsById.get(id2) ?? stored, graph);
-}
-var init_declaration_default_source = __esm({
-  "../packages/neoscript-runtime/src/declaration-default-source.ts"() {
-    "use strict";
-    init_instance_provenance();
-    init_member_change_listeners();
-  }
-});
-
 // ../packages/models/src/members/stored-value-placement-index.ts
 function buildStoredValuePlacementIndex(args) {
   return createStoredValuePlacementTraversal(args)();
@@ -89683,6 +89783,20 @@ var init_stored_value_placement_index = __esm({
   }
 });
 
+// ../packages/neoscript-runtime/src/declaration-default-source.ts
+function declarationDefaultSource(id2, stored, resolveGraph) {
+  if (stored !== null && !isCollapseStampedInstanceRoot(stored)) return stored;
+  const graph = resolveGraph(id2);
+  return defaultSourceWithListeners(graph?.rowsById.get(id2) ?? stored, graph);
+}
+var init_declaration_default_source = __esm({
+  "../packages/neoscript-runtime/src/declaration-default-source.ts"() {
+    "use strict";
+    init_instance_provenance();
+    init_member_change_listeners();
+  }
+});
+
 // ../packages/neoscript-runtime/src/listener-endpoint-projection.ts
 function projectListenerEndpoint(args) {
   const { descriptor } = args;
@@ -89763,6 +89877,14 @@ var init_overlay_readonly_map = __esm({
 });
 
 // ../packages/neoscript-runtime/src/virtual-instance-graph.ts
+function isMaterializedSpine(location3) {
+  const stored = location3?.materializedRow;
+  if (stored == null || location3?.parentId == null) return false;
+  const virtual = location3.virtualRow;
+  if (!isLiteralValueContent(stored) || !isLiteralValueContent(virtual))
+    return false;
+  return stored.id === virtual.id && (stored.instanceVariantId ?? null) === (virtual.instanceVariantId ?? null) && (stored.instanceVariantRowValueId ?? null) === (virtual.instanceVariantRowValueId ?? null) && (stored.instanceAppliedVariantId ?? null) === (virtual.instanceAppliedVariantId ?? null) && (stored.instanceAppliedVariantRowValueId ?? null) === (virtual.instanceAppliedVariantRowValueId ?? null);
+}
 function buildVirtualInstanceMaterializedIndex(args) {
   const rowsById = new Map(
     (args.materializedRows ?? args.document.values).map((row) => [row.id, row])
@@ -91007,6 +91129,7 @@ function resolveStoredInstanceGraphs(args) {
     if (next === void 0 || resolvedRootIds.has(next.root.id)) continue;
     resolvedRootIds.add(next.root.id);
     enqueueStoredRoots(stored.includeRoot(next.root, next.member));
+    if (isMaterializedSpine(resolvedLocations.get(next.root.id))) continue;
     const graph = isMemberClassBase(next.member) ? args.resolveClassGraph?.(next.root, next.member) ?? resolveStoredClassValue({
       evaluateInitializer: args.evaluateInitializer,
       document,
@@ -93072,6 +93195,10 @@ function createHeadlessVirtualInstanceResolver(args) {
     graphByValueId.set(graph.instanceRootId, graph);
   };
   const expandRoot = (rootId, declaredMember) => {
+    const containing = graphByValueId.get(rootId);
+    if (containing !== void 0 && isMaterializedSpine(containing.locationsById.get(rootId))) {
+      return expandRoot(containing.instanceRootId, void 0);
+    }
     const cached = graphRowsByRootId.get(rootId);
     if (cached !== void 0) {
       const reads2 = readsByRootId.get(rootId);
@@ -93161,17 +93288,21 @@ function createHeadlessVirtualInstanceResolver(args) {
     recorder.recordValuePlacementRead();
     recorder.recordValueRead(receiverValueId);
     let placement = placements().get(receiverValueId) ?? null;
+    const roots = [];
     while (placement !== null) {
       recorder.recordValueRead(placement.valueId);
       const raw = rawById.get(placement.valueId);
       if (raw !== void 0 && isLiteralValueContent(raw) && isStoredClassResolutionRoot(raw)) {
-        return expandRoot(
-          placement.valueId,
-          membersById.get(placement.memberId)
-        );
+        roots.push(placement);
       }
       placement = placement.parentValueId === null ? null : placements().get(placement.parentValueId) ?? null;
     }
+    let resolved = emptyRows;
+    for (let index = roots.length - 1; index >= 0; index -= 1) {
+      const root2 = roots[index];
+      resolved = expandRoot(root2.valueId, membersById.get(root2.memberId));
+    }
+    if (roots.length > 0) return resolved;
     const root = rawById.get(receiverValueId);
     if (root !== void 0 && typeof root.classId === "string" && isStoredClassResolutionRoot(root)) {
       return expandRoot(receiverValueId, {
@@ -93206,7 +93337,7 @@ function createHeadlessVirtualInstanceResolver(args) {
       const known = graphByValueId.get(valueId);
       if (known?.instanceRootId === valueId) return known;
       const stored = rawById.get(valueId);
-      if (known !== void 0 && (stored === void 0 || !isStoredClassResolutionRoot(stored)))
+      if (known !== void 0 && (stored === void 0 || !isStoredClassResolutionRoot(stored) || isMaterializedSpine(known.locationsById.get(valueId))))
         return known;
       virtualInstanceRowsForValue(valueId);
       return graphByValueId.get(valueId) ?? null;
@@ -94307,6 +94438,28 @@ function createTypedValueNormalizer(reader, document, childrenByContainerId, par
     }
     return normalizeLiteral(value);
   };
+  const bindingTypes = /* @__PURE__ */ new Map();
+  const bindingType = (memberId) => {
+    const member = memberById2(memberId);
+    if (member === void 0) return memberId;
+    try {
+      return genericBindingTypeInfo(member, /* @__PURE__ */ new Map(), document.members);
+    } catch {
+      return memberId;
+    }
+  };
+  const normalizeGenericBindings = (bindings) => {
+    const result = /* @__PURE__ */ Object.create(null);
+    for (const [paramId, memberId] of Object.entries(bindings)) {
+      let type = bindingTypes.get(memberId);
+      if (type === void 0) {
+        type = bindingType(memberId);
+        bindingTypes.set(memberId, type);
+      }
+      result[paramId] = type;
+    }
+    return result;
+  };
   const normalizeTypedRow = (valueId, typeInfo, placement, parentEnv = /* @__PURE__ */ new Map()) => {
     const row = reader.row(valueId, typeInfo, placement);
     if (row === void 0) return valueId;
@@ -94388,7 +94541,7 @@ function createTypedValueNormalizer(reader, document, childrenByContainerId, par
       const normalized = {
         ...rowIdentities?.has(valueId) ? { id: valueId } : {},
         ...typeof row.classId === "string" ? { classId: row.classId } : {},
-        ...row.genericBindings === void 0 ? {} : { genericBindings: row.genericBindings },
+        ...row.genericBindings === void 0 ? {} : { genericBindings: normalizeGenericBindings(row.genericBindings) },
         value,
         ...carriesSemanticConstructorArguments(row) ? {
           constructorArgs: normalizeConstructorArgs(
@@ -94425,7 +94578,7 @@ function createTypedValueNormalizer(reader, document, childrenByContainerId, par
       const normalized = {
         ...rowIdentities?.has(valueId) ? { id: valueId } : {},
         ...typeof row.classId === "string" ? { classId: row.classId } : {},
-        ...row.genericBindings === void 0 ? {} : { genericBindings: row.genericBindings },
+        ...row.genericBindings === void 0 ? {} : { genericBindings: normalizeGenericBindings(row.genericBindings) },
         // The containing Class schema proves this is an owned row edge, but an
         // unresolved generic member does not prove anything about strings in
         // the row's payload. Keep those strings literal instead of guessing
@@ -94539,6 +94692,7 @@ var init_effective_value_reader = __esm({
     init_core();
     init_members();
     init_packed_value_encoding();
+    init_stored_value_placement_index();
     init_read_class_member();
     init_initializer_materialization();
     init_evaluateInitializer();
@@ -94603,6 +94757,7 @@ var init_effective_value_reader = __esm({
       resolvedDocument;
       indexedDocument;
       materializedIndex;
+      storedPlacements;
       graphCache;
       createNormalizer(rowIdentities) {
         return createTypedValueNormalizer(
@@ -94777,10 +94932,15 @@ var init_effective_value_reader = __esm({
           return row;
         if (this.resolvedRoots.has(valueId)) return row;
         if (this.mode(valueId) === "partial") return row;
+        if (this.context.overrideRows === "constructed" && this.overrides.has(valueId) && !this.graph.valuesById.has(valueId))
+          return row;
         const schema = this.schema(classId);
-        if (schema.every(
-          (entry) => Object.prototype.hasOwnProperty.call(row.value, entry.schemaKey)
-        ))
+        const record7 = row.value;
+        if (schema.every((entry) => {
+          if (Object.hasOwn(record7, entry.schemaKey)) return true;
+          const member2 = this.memberForId(entry.memberId);
+          return member2 !== null && !memberKindOwnsStoredValue(member2.kind);
+        }))
           return row;
         this.resolvedRoots.add(valueId);
         const member = this.placementFor(valueId) ?? this.graph.ownerForValue(valueId) ?? {
@@ -94871,6 +95031,30 @@ var init_effective_value_reader = __esm({
             unorderedListEntryIds: unorderedListEntryIds2
           });
         }
+        const materializedIndex = this.materializedIndex;
+        this.storedPlacements ??= buildStoredValuePlacementIndex({
+          ...this.readDocument,
+          constructors: this.readDocument.constructors ?? [],
+          indexedRows: {
+            valuesById: this.materializedIndex.rowsById,
+            unorderedListEntryIds: (id2) => materializedIndex.unorderedEntryIdsByContainerId.get(id2) ?? []
+          },
+          resolveStaticValueId: (memberId) => this.memberForId(memberId)?.valueId ?? null
+        });
+        const positions = this.storedPlacements.placementByValueId;
+        let parentId = positions.get(valueId)?.parentValueId;
+        while (parentId != null) {
+          const position = positions.get(parentId);
+          if (position === void 0) break;
+          const parentMember = this.memberForId(position.memberId);
+          if (parentMember !== null && isMemberClassBase(parentMember)) {
+            const containingRows = this.resolveGraph(parentId, parentMember);
+            if (isMaterializedSpine(this.locations.get(valueId)))
+              return containingRows;
+            break;
+          }
+          parentId = position.parentValueId;
+        }
         const rows = resolveStoredInstanceGraphs({
           ...this.context,
           readRecorder: this.context.readTracking === void 0 ? void 0 : virtualReadRecorder(this.context.readTracking),
@@ -94977,6 +95161,8 @@ var init_effective_value_reader = __esm({
           {
             ...this.context,
             containerMembership: options.containerMembership ?? this.context.containerMembership,
+            // Describes this reader's overrides, not a fork's.
+            overrideRows: void 0,
             ...options.readTracking === void 0 ? {} : { readTracking: options.readTracking }
           },
           this,
@@ -117746,6 +117932,7 @@ function* prepareServerOwnedSchemaCommitPasses(args) {
   });
   materializePreparedInstanceInitializers({
     document: args.document,
+    physicalValues: args.document.physicalValues,
     prepared,
     contentHashHeads: args.contentHashHeads
   });
@@ -118065,6 +118252,7 @@ function materializePreparedInstanceInitializers(args) {
     args.contentHashHeads,
     "value"
   );
+  let writeBaseHashFor;
   const owners = resolveSemanticOwnerMembersForValues(
     materializationScope.document,
     new Set(sites.keys()),
@@ -118205,7 +118393,14 @@ function materializePreparedInstanceInitializers(args) {
       const existing = existingValueById.get(created.id);
       if (existing !== void 0) {
         if (materializedValueRowsEqual(existing, created)) continue;
-        const contentHash = liveValueHashes().get(created.id);
+        writeBaseHashFor ??= createValueWriteBaseHashResolver({
+          document: args.document,
+          physicalValues: args.physicalValues,
+          prepared: args.prepared,
+          contentHashHeads: args.contentHashHeads,
+          source: "server-initializer-materialization"
+        });
+        const contentHash = writeBaseHashFor(created.id);
         if (contentHash === void 0) {
           throw new Error(
             `Cannot reconcile materialized initializer row "${created.id}": its live content hash is unavailable.`
@@ -118220,7 +118415,7 @@ function materializePreparedInstanceInitializers(args) {
             source: "server-initializer-materialization",
             sourceValueId: valueId
           }),
-          expectedBaseContentHash: contentHash
+          ...contentHash === null ? {} : { expectedBaseContentHash: contentHash }
         });
         existingValueById.set(created.id, created);
         continue;
@@ -120153,7 +120348,7 @@ function valueIdsFromRows(explicitRows, sweepRows) {
   for (const row of sweepRows) ids.add(row.id);
   return ids;
 }
-function createValueRecompileBaseHashResolver(args) {
+function createValueWriteBaseHashResolver(args) {
   const hashById = indexLiveContentHashesByRecordId(
     args.contentHashHeads,
     "value"
@@ -120198,7 +120393,7 @@ function createValueRecompileBaseHashResolver(args) {
         nextData: root,
         expectedBaseContentHash: rootHash,
         intent: createProjectVersionIntent("value.update", {
-          source: "server-neoscript-recompile"
+          source: args.source
         })
       });
     }
@@ -120316,7 +120511,8 @@ function prepareServerOwnedValueInitializerBodies(args) {
   const currentById = new Map(
     args.document.values.map((value) => [value.id, value])
   );
-  const baseHashFor = createValueRecompileBaseHashResolver({
+  const baseHashFor = createValueWriteBaseHashResolver({
+    source: "server-neoscript-recompile",
     document: committedDocument,
     physicalValues: args.document.physicalValues,
     prepared: args.prepared,
@@ -120788,7 +120984,8 @@ function prepareServerOwnedDelegateValueBodies(args) {
   const currentById = new Map(
     args.document.values.map((value) => [value.id, value])
   );
-  const baseHashFor = createValueRecompileBaseHashResolver({
+  const baseHashFor = createValueWriteBaseHashResolver({
+    source: "server-neoscript-recompile",
     document: committedDocument,
     physicalValues: args.physicalValues,
     prepared: args.prepared,
@@ -138894,7 +139091,7 @@ function classValueBody(context, member, value, visited, targetTyped, outerEnvir
       context,
       value.id,
       replayConstruction,
-      concreteClassMemberForReplay(member, environment)
+      concreteClassMemberForReplay(context, member, environment)
     );
     const replayRoot = replayRows === null || typeof value.id !== "string" ? void 0 : replayRows.get(value.id);
     const graph = replayRows === null || typeof value.id !== "string" ? null : context.readEffectiveValues().withRowOverrides(
@@ -138941,7 +139138,11 @@ function classValueBody(context, member, value, visited, targetTyped, outerEnvir
     if (!context.values.has(childId)) {
       const reader = context.readEffectiveValues();
       if (reader.row(childId) === void 0) {
-        const placement = concreteClassMemberForReplay(member, environment);
+        const placement = concreteClassMemberForReplay(
+          context,
+          member,
+          environment
+        );
         if (!isAnyMemberBase(placement))
           throw new Error(
             `Stored class ${name} has no typed member placement.`
@@ -139217,22 +139418,23 @@ function storedConstructionReplayRows(context, valueId, code, member) {
   context.constructionReplays.set(valueId, replay);
   return replay;
 }
-function concreteClassMemberForReplay(member, environment) {
+function concreteClassMemberForReplay(context, member, environment) {
   if (numberField(member, "kind") !== 7 /* Class */) return member;
   const classArguments2 = isObjectRecord2(member.classArguments) ? member.classArguments : {};
+  const parameters = context.manifestClasses.get(stringField2(member, "classId"))?.genericParameters ?? [];
   let changed = false;
-  const concreteArguments = Object.fromEntries(
-    Object.entries(classArguments2).map(([genericParamId, binding]) => {
-      const forwardedParamId = isObjectRecord2(binding) && (binding.kind === void 0 || binding.kind === 0 /* Generic */) && typeof binding.genericParamId === "string" ? binding.genericParamId : null;
-      const bindingMemberId = environment.get(genericParamId) ?? (forwardedParamId === null ? void 0 : environment.get(forwardedParamId));
-      if (bindingMemberId === void 0) return [genericParamId, binding];
-      changed = true;
-      return [
-        genericParamId,
-        { kind: 1 /* Member */, memberId: bindingMemberId }
-      ];
-    })
-  );
+  const concreteArguments = { ...classArguments2 };
+  for (const { id: genericParamId } of parameters) {
+    const binding = classArguments2[genericParamId];
+    const forwardedParamId = isObjectRecord2(binding) && (binding.kind === void 0 || binding.kind === 0 /* Generic */) && typeof binding.genericParamId === "string" ? binding.genericParamId : null;
+    const bindingMemberId = environment.get(genericParamId) ?? (forwardedParamId === null ? void 0 : environment.get(forwardedParamId));
+    if (bindingMemberId === void 0) continue;
+    changed = true;
+    concreteArguments[genericParamId] = {
+      kind: 1 /* Member */,
+      memberId: bindingMemberId
+    };
+  }
   return changed ? { ...member, classArguments: concreteArguments } : member;
 }
 function storedLookupIdentityIds(values, reader) {
@@ -139959,6 +140161,19 @@ function storedTypedRowSource(context, type, valueId, environment, visited, writ
       `Stored ${type.kind} constructor argument references missing value row ${valueId}.`
     );
   }
+  if (type.kind === "generic" && typeof row.classId !== "string") {
+    return storedTypedRowSource(
+      context,
+      storedGenericArgumentType(context, type, environment),
+      valueId,
+      environment,
+      visited,
+      writeIdentity,
+      partial,
+      constructorOwnsGraph,
+      cloneAggregateArguments
+    );
+  }
   if (cloneAggregateArguments) {
     const settled = type.kind === "generic" ? storedGenericArgumentType(context, type, environment) : type;
     if (settled.kind === "class" || settled.kind === "interface") {
@@ -139983,8 +140198,8 @@ function storedTypedRowSource(context, type, valueId, environment, visited, writ
   visited.add(valueId);
   try {
     if (type.kind === "class" || type.kind === "interface" || type.kind === "generic") {
-      const classId = type.kind === "class" ? type.classId : typeof row.classId === "string" ? row.classId : null;
-      if (classId === null) {
+      const classId = type.kind === "class" ? type.classId : row.classId;
+      if (typeof classId !== "string") {
         throw new Error(
           `Stored ${type.kind} constructor argument ${valueId} has no concrete class.`
         );
@@ -201632,7 +201847,7 @@ There is no --keep-current: preserving current semantic state defines flatten.
 async function main() {
   const args = parseArgs(process.argv.slice(2));
   if (args.command === "--version") {
-    console.log("0.81.1");
+    console.log("0.81.3");
     return;
   }
   if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {