@neocompose/cli 0.81.0 → 0.81.2

package/dist/test-worker.mjs

@@ -2339,6 +2339,16 @@ 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.`;
+}
+var NEOSCRIPT_DELEGATE_MAX_PARAMETERS = 16;
+function delegateArityMessage(provided) {
+  return `Type 'NeoDelegate' expects a return type followed by up to ${NEOSCRIPT_DELEGATE_MAX_PARAMETERS} parameter types, but ${provided} type arguments were provided.`;
+}
 function neoScriptRegistryReferenceType(entryTypeName) {
   for (const definition of Object.values(REGISTRY_ENTRY_TYPES)) {
     if (definition.entryType === entryTypeName) return definition.refType;
@@ -3600,6 +3610,8 @@ function isNSFunctionVariantApply(value) {
   if (!isNSPointer(info.variantPointer)) return false;
   if (info.rowPointer !== void 0 && !isNSPointer(info.rowPointer))
     return false;
+  if (info.declarativeReplay !== void 0 && info.declarativeReplay !== true)
+    return false;
   return isNSTypeInfoClass(info.schemaClassInfo) && info.schemaClassInfo.required;
 }
 function isNSFunctionClassConstructor(value) {
@@ -5284,7 +5296,9 @@ function isLiteralValueContent(value) {
   for (const field of [
     "instanceConstructorId",
     "instanceVariantId",
-    "instanceVariantRowValueId"
+    "instanceVariantRowValueId",
+    "instanceAppliedVariantId",
+    "instanceAppliedVariantRowValueId"
   ]) {
     const provenance = getField(value, field);
     if (provenance !== void 0 && provenance !== null && (typeof provenance !== "string" || provenance.length === 0)) {
@@ -5310,6 +5324,9 @@ function isInitValueContent(value) {
   if (getField(value, "instanceConstructorId") !== void 0) return false;
   if (getField(value, "instanceVariantId") !== void 0) return false;
   if (getField(value, "instanceVariantRowValueId") !== void 0) return false;
+  if (getField(value, "instanceAppliedVariantId") !== void 0) return false;
+  if (getField(value, "instanceAppliedVariantRowValueId") !== void 0)
+    return false;
   const classIdField = getField(value, "classId");
   return classIdField === void 0 || classIdField === null;
 }
@@ -6081,6 +6098,8 @@ var LITERAL_INSTANCE_IDENTITY_FIELDS = [
   "instanceConstructorId",
   "instanceVariantId",
   "instanceVariantRowValueId",
+  "instanceAppliedVariantId",
+  "instanceAppliedVariantRowValueId",
   "genericBindings"
 ];
 function replaceLiteralValueClass(value, classId) {
@@ -6103,7 +6122,11 @@ function pickInstanceProvenance(source) {
     ...source.constructorArgs === void 0 ? {} : { constructorArgs: source.constructorArgs },
     ...source.instanceConstructorId === void 0 ? {} : { instanceConstructorId: source.instanceConstructorId },
     ...source.instanceVariantId === void 0 ? {} : { instanceVariantId: source.instanceVariantId },
-    ...source.instanceVariantRowValueId === void 0 ? {} : { instanceVariantRowValueId: source.instanceVariantRowValueId }
+    ...source.instanceVariantRowValueId === void 0 ? {} : { instanceVariantRowValueId: source.instanceVariantRowValueId },
+    ...source.instanceAppliedVariantId === void 0 ? {} : { instanceAppliedVariantId: source.instanceAppliedVariantId },
+    ...source.instanceAppliedVariantRowValueId === void 0 ? {} : {
+      instanceAppliedVariantRowValueId: source.instanceAppliedVariantRowValueId
+    }
   };
 }
 function isVirtualInstanceRootShape(value) {
@@ -6276,7 +6299,7 @@ function decodeContentField(container, field, scope, children) {
       )
     };
   }
-  const decoded = {};
+  const decoded = /* @__PURE__ */ Object.create(null);
   for (const [key, entry] of Object.entries(
     container
   )) {
@@ -11533,12 +11556,8 @@ function evaluateLiteralContainer(args) {
   const literal3 = {
     value: evaluated.value,
     classId: evaluated.classId,
-    ...evaluated.constructorArgs === void 0 ? {} : { constructorArgs: deepClonePlainData(evaluated.constructorArgs) },
-    ...evaluated.instanceConstructorId === void 0 ? {} : { instanceConstructorId: evaluated.instanceConstructorId },
-    ...evaluated.instanceVariantId === void 0 ? {} : { instanceVariantId: evaluated.instanceVariantId },
-    ...evaluated.instanceVariantRowValueId === void 0 ? {} : {
-      instanceVariantRowValueId: evaluated.instanceVariantRowValueId
-    }
+    ...pickInstanceProvenance(evaluated),
+    ...evaluated.constructorArgs === void 0 ? {} : { constructorArgs: deepClonePlainData(evaluated.constructorArgs) }
   };
   if (isMemberLookupBase(args.member)) {
     if (evaluated.existingValueRow !== void 0) {
@@ -11871,15 +11890,9 @@ function buildNewValue(projectId, body, timestamp2 = Date.now()) {
   if (body.constructorArgs !== void 0 && body.constructorArgs !== null) {
     props.constructorArgs = deepClonePlainData(body.constructorArgs);
   }
-  if (body.instanceConstructorId !== void 0) {
-    props.instanceConstructorId = body.instanceConstructorId;
-  }
-  if (body.instanceVariantId !== void 0) {
-    props.instanceVariantId = body.instanceVariantId;
-  }
-  if (body.instanceVariantRowValueId !== void 0) {
-    props.instanceVariantRowValueId = body.instanceVariantRowValueId;
-  }
+  const { constructorArgs: _constructorArgs, ...provenance } = pickInstanceProvenance(body);
+  void _constructorArgs;
+  Object.assign(props, provenance);
   return props;
 }
 function retargetInitializerRootValueIds(rows, fromValueId, toValueId) {
@@ -12071,7 +12084,7 @@ function cloneDefaultDictionaryRecord(args) {
     args.document,
     args.member.entryMemberId
   );
-  const value = {};
+  const value = /* @__PURE__ */ Object.create(null);
   for (const [key, sourceValueId] of Object.entries(sourceValue)) {
     value[key] = cloneDefaultValueForMember({
       document: args.document,
@@ -12348,9 +12361,7 @@ function cloneMemberValueBase(body) {
   return {
     value: deepClonePlainData(body.value),
     classId: body.classId,
-    ...body.instanceConstructorId === void 0 ? {} : { instanceConstructorId: body.instanceConstructorId },
-    ...body.instanceVariantId === void 0 ? {} : { instanceVariantId: body.instanceVariantId },
-    ...body.instanceVariantRowValueId === void 0 ? {} : { instanceVariantRowValueId: body.instanceVariantRowValueId },
+    ...pickInstanceProvenance({ ...body, constructorArgs: void 0 }),
     ...body.constructorArgs === void 0 || body.constructorArgs === null ? {} : {
       constructorArgs: deepClonePlainData(body.constructorArgs)
     }
@@ -13329,7 +13340,7 @@ function toCanonicalJsonValue(value) {
     });
   }
   const entries = Object.entries(value).sort(([a], [b]) => a.localeCompare(b));
-  const canonicalObject = {};
+  const canonicalObject = /* @__PURE__ */ Object.create(null);
   for (const [key, entryValue] of entries) {
     const canonicalValue = toCanonicalJsonValue(entryValue);
     if (canonicalValue === void 0) continue;
@@ -16971,6 +16982,7 @@ function makeUnindexedEvaluatorLookups(members, storedValues) {
     hasStoredValueId: (id) => valueById.has(id),
     unorderedListEntryIds: (containerValueId) => unorderedListMembership.get(containerValueId) ?? [],
     virtualInstanceRowsForValue: () => [],
+    virtualInstanceRootIdForValue: () => null,
     rowForValueReference: (value) => valueRefMap.get(value) ?? null
   };
 }
@@ -17154,6 +17166,7 @@ function createEvaluatorLookupsBuild(members, storedValues, options = {}) {
         hasStoredValueId: (id) => valueById.has(id),
         unorderedListEntryIds: (containerValueId) => unorderedListMembership.get(containerValueId) ?? [],
         virtualInstanceRowsForValue: () => [],
+        virtualInstanceRootIdForValue: () => null,
         rowForValueReference: (value) => rowByValueReference.get(value) ?? null,
         evaluatorIndexes: indexes3.result,
         ...options.constructorInitializerDocument === void 0 ? {} : {
@@ -17271,6 +17284,7 @@ function layerEvaluatorLookups(base, overlay) {
     hasStoredValueId: (id) => overlay.rows.has(id) || !overlay.hiddenIds.has(id) && (base.hasStoredValueId?.(id) ?? false),
     unorderedListEntryIds,
     virtualInstanceRowsForValue: () => [],
+    virtualInstanceRootIdForValue: () => null,
     rowForValueReference: (value) => evaluatorIndexes2.rowByValueReference.get(value) ?? null,
     evaluatorIndexes: evaluatorIndexes2,
     constructorInitializerIndexes: constructorInitializerIndexes2
@@ -17676,13 +17690,15 @@ function bindThisValue(ctx, thisValue) {
 function observeValueWrite(ctx, row) {
   ctx.beforeValueWrite?.(row);
   ctx.__getterSubscriptions?.noteValueWrite(row.id);
+  forgetVariantResolutionCopy(ctx, row.id);
 }
 function assertStoredReplayMutableValue(value, ctx, label, key) {
-  const observesWrites = ctx.beforeValueWrite !== void 0 || ctx.__getterSubscriptions?.empty === false;
+  const observesWrites = ctx.beforeValueWrite !== void 0 || ctx.__getterSubscriptions?.empty === false || hasVariantResolutionCopies(ctx);
   if (ctx.storedConstructionReplay !== true && !ctx.assertValueWritable && !observesWrites)
     return;
   let rowId = findKnownRowIdByValueReference(value, ctx);
   if (rowId === null) return;
+  forgetVariantResolutionCopy(ctx, rowId);
   const container = ctx.beforeValueWrite && evalValueById(ctx, rowId, ctx.__runtimeSessionValues, ctx.__valueOverlay);
   if (container) ctx.beforeValueWrite?.(container);
   if (key !== void 0 && value !== null && typeof value === "object") {
@@ -20004,15 +20020,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 identity = nsActionListenerIdentity(listener);
   const present = current.some(
@@ -20083,38 +20093,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 object = 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) {
@@ -20129,26 +20127,41 @@ function applyOverlayAssignment(target, targetTypeInfo, value, scope, ctx, desti
       );
     }
     object[stringKey] = referenceValueId;
+    if (!field) recordWrittenEntry(object, stringKey, true, ctx);
     invalidateEvaluatorIndexes(ctx, receiver);
     return;
   }
-  const existing = object[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(object, ctx) === 0 /* RowIds */ && replaceEntryRowValue(object, object[stringKey], value, targetTypeInfo, ctx))
+    return;
   object[stringKey] = value;
+  if (!field) recordWrittenEntry(object, 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)) {
@@ -20586,9 +20599,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?.(
@@ -20625,6 +20640,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,
@@ -20826,9 +20858,10 @@ function runtimeSet(array2, reference, enumEntries, ctx) {
   const existing = sets.get(array2);
   if (existing !== void 0) return existing;
   const set = new RuntimeSet(array2, reference, enumEntries);
+  const references = collectionReferences(array2, ctx);
   for (let index = 0; index < array2.length; index++) {
     const raw = array2[index];
-    const resolves = collectionEntryUsesReferenceResolution(array2, 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);
@@ -20837,9 +20870,9 @@ function runtimeSet(array2, reference, enumEntries, ctx) {
   (ctx.__dirtyRuntimeSets ??= /* @__PURE__ */ new Set()).add(set);
   return set;
 }
-function storedSetEntryMatch(raw, entryMember, ctx) {
+function storedSetEntryMatch(raw, reference, 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 || !reference || 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);
@@ -20850,8 +20883,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);
     }
@@ -20863,7 +20902,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;
   }
@@ -20929,6 +20974,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];
@@ -20939,9 +20985,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;
@@ -20974,13 +21019,6 @@ function applyLocalCollectionMutation(targetValue, mutation, args, ctx, unique =
       return null;
   }
 }
-function setCollectionReferenceProvenance(targetValue, index, reference, ctx) {
-  const cache = ctx.__unorderedListProjections;
-  const indexes3 = cache?.referenceEntryIndexesByArray.get(targetValue);
-  if (cache === void 0 || indexes3 === void 0) return;
-  if (reference) indexes3.add(index);
-  else indexes3.delete(index);
-}
 function updateCollectionReferenceProvenance(targetValue, mutation, removedIndex, ctx) {
   if (!Array.isArray(targetValue)) return;
   const cache = ctx.__unorderedListProjections;
@@ -21254,7 +21292,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 */:
@@ -21904,15 +21942,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) {
@@ -22830,7 +22862,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;
@@ -22891,7 +22925,7 @@ function evalKeyOf(keyOf, scope, ctx, optional2 = false, onDestination) {
     if (dispatched.kind === "ok") return dispatched.value;
     if (Object.prototype.hasOwnProperty.call(receiver, k)) {
       const at2 = receiver[k];
-      return resolveValueIfId(at2, ctx);
+      return typeof at2 === "string" && (pointer.memberId !== void 0 || isReferenceEntry(collectionReferences(receiver, ctx), k)) ? resolveValueIfId(at2, ctx) : at2;
     }
     const expanded = virtualExpandedRecordForReceiver(receiver, ctx);
     if (expanded !== null && Object.prototype.hasOwnProperty.call(expanded, k)) {
@@ -23624,7 +23658,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(
@@ -23634,7 +23668,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,
@@ -24256,7 +24290,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") {
@@ -24268,7 +24312,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;
@@ -24832,7 +24881,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)) {
@@ -24853,7 +24902,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)) {
@@ -25996,6 +26045,8 @@ function evaluateDeclaredConstructorArguments(info, record4, scope, ctx) {
       );
     }
     const value = byName.get(parameter3.name);
+    if (parameter3.type === 9 /* Lookup */ && Array.isArray(value))
+      return referenceEntryList(value, ctx);
     if (typeof value !== "number") return value;
     if (parameter3.type === 4 /* Float */) return Math.fround(value);
     if (parameter3.type !== 20 /* Decimal */) return value;
@@ -26490,12 +26541,7 @@ function evaluateInitializerInContext(init, member, ctx, createdValues, argument
   deleteRuntimeSessionValue(ctx, rootRow.id);
   ctx.__executionState?.constructorGroups.delete(rootRow.id);
   const constructorArgs = typeof result.value === "object" && result.value !== null ? ctx.__constructedArgumentsByValue.get(result.value) ?? rootRow.constructorArgs ?? void 0 : void 0;
-  const provenance = pickInstanceProvenance({
-    constructorArgs,
-    instanceConstructorId: rootRow.instanceConstructorId,
-    instanceVariantId: rootRow.instanceVariantId,
-    instanceVariantRowValueId: rootRow.instanceVariantRowValueId
-  });
+  const provenance = pickInstanceProvenance({ ...rootRow, constructorArgs });
   return {
     value: result.value,
     classId: rootRow.classId ?? null,
@@ -27360,7 +27406,7 @@ function evalVariantInitialize(info, scope, ctx) {
       scope,
       ctx
     );
-    stampInstanceVariantProvenance(instance, selection, ctx, true);
+    stampInstanceVariantProvenance(instance, selection, ctx);
     return instance;
   }
   const graph = resolveVariantGraph(selection, ctx);
@@ -27391,12 +27437,16 @@ function evalVariantInitialize(info, scope, ctx) {
       ctx,
       ctx.__variantDeclarativeAnsweredValueIds
     );
-    stampInstanceVariantProvenance(instance, selection, ctx, true);
+    stampInstanceVariantProvenance(instance, selection, ctx);
     return instance;
   } finally {
     closeFrame();
   }
 }
+function isInsideAnotherExpansion(valueId, ctx) {
+  const ownerRootId = ctx.vm.databaseVM?.virtualInstanceRootIdForValue(valueId) ?? null;
+  return ownerRootId !== null && ownerRootId !== valueId;
+}
 function evalVariantApply(info, scope, ctx) {
   const receiver = evalPointer(info.receiverPointer, scope, ctx);
   if (receiver === null || receiver === void 0) {
@@ -27408,12 +27458,12 @@ function evalVariantApply(info, scope, ctx) {
     evalPointer(info.variantPointer, scope, ctx),
     "ToVariant argument"
   );
-  if (selection.variantId === null) {
-    stampInstanceVariantProvenance(receiver, selection, ctx);
+  const graph = selection.variantId === null ? null : resolveVariantGraph(selection, ctx);
+  if (info.declarativeReplay === true) {
+    if (graph !== null) applyVariantDeclarativeHalves(receiver, graph, ctx);
     return receiver;
   }
-  const graph = resolveVariantGraph(selection, ctx);
-  const rowParameters = resolveVariantRowParameter({
+  const rowParameters = graph === null ? [] : resolveVariantRowParameter({
     graph,
     selection,
     explicitPointer: info.rowPointer,
@@ -27422,13 +27472,18 @@ function evalVariantApply(info, scope, ctx) {
   });
   const rootRow = trackedRowForValueReference(receiver, ctx);
   if (rootRow === null || !isLiteralValueContent(rootRow)) {
+    if (graph === null) return receiver;
     throw new NSGetterRuntimeError(
       "ToVariant receiver has no addressable instance root."
     );
   }
-  const priorInstanceRoot = ctx.__runtimeSessionValues?.has(rootRow.id) === true ? null : deepClonePlainData(rootRow);
-  const applyValue = graph.root.Apply;
-  if (applyValue !== void 0 && applyValue !== null) {
+  if (graph === null && typeof rootRow.instanceAppliedVariantId !== "string") {
+    return receiver;
+  }
+  const inPlace = ctx.__runtimeSessionValues?.has(rootRow.id) === true || isInsideAnotherExpansion(rootRow.id, ctx);
+  const priorInstanceRoot = inPlace ? null : deepClonePlainData(rootRow);
+  const applyValue = graph?.root.Apply;
+  if (graph !== null && applyValue !== void 0 && applyValue !== null) {
     invokeVariantClosure({
       closureValueId: applyValue,
       ctx,
@@ -27438,17 +27493,12 @@ function evalVariantApply(info, scope, ctx) {
     });
   }
   if (priorInstanceRoot === null) {
-    stampInstanceVariantProvenance(receiver, selection, ctx);
-    applyVariantDeclarativeHalves(receiver, graph, ctx);
+    if (graph !== null) applyVariantDeclarativeHalves(receiver, graph, ctx);
     return receiver;
   }
   priorInstanceRoot.value = deepClonePlainData(rootRow.value);
-  const answeredSlots = collectVariantDeclarativeAnsweredSlots(
-    receiver,
-    graph,
-    ctx
-  );
-  stampInstanceVariantProvenance(receiver, selection, ctx);
+  const answeredSlots = graph === null ? [] : collectVariantDeclarativeAnsweredSlots(receiver, graph, ctx);
+  stampAppliedVariantProvenance(rootRow, receiver, selection, ctx);
   const resolver = ctx.vm.databaseVM?.resolveVariantInstanceGraph;
   if (resolver === void 0) {
     if (answeredSlots.length > 0) {
@@ -27457,26 +27507,41 @@ function evalVariantApply(info, scope, ctx) {
       );
     }
   } else {
+    const overlay = ctx.__valueOverlay;
+    const copies = overlay === void 0 ? void 0 : variantResolutionCopies(overlay);
     const resolution = resolver.call(ctx.vm.databaseVM, {
       priorInstanceRoot,
       nextInstanceRoot: deepClonePlainData(rootRow),
       answeredValueIds: [...new Set(answeredSlots.map((slot) => slot.valueId))],
       localRows: [
         ...ctx.__runtimeSessionValues?.values() ?? [],
-        ...ctx.__valueOverlay?.values() ?? []
-      ]
+        ...overlay?.values() ?? []
+      ],
+      virtualCopyIds: unwrittenVariantResolutionCopyIds(
+        overlay,
+        copies?.byRootId.get(rootRow.id)
+      )
     });
     for (const valueId of resolution.clearedValueIds) {
       const previous = readNeoScriptRuntimeRow(ctx, valueId);
       if (previous) observeValueWrite(ctx, previous);
       deleteRuntimeSessionValue(ctx, valueId);
-      ctx.__valueOverlay?.delete(valueId);
+      overlay?.delete(valueId);
+    }
+    for (const valueId of copies?.byRootId.get(rootRow.id)?.keys() ?? []) {
+      forgetVariantResolutionCopy(ctx, valueId);
     }
+    const virtualValueIds = new Set(resolution.virtualValueIds);
     for (const row of resolution.rows) {
       if (row.id === rootRow.id) continue;
       const previous = readNeoScriptRuntimeRow(ctx, row.id);
       if (previous) observeValueWrite(ctx, previous);
-      ctx.__valueOverlay?.set(row.id, deepClonePlainData(row));
+      if (overlay === void 0 || copies === void 0) continue;
+      const copy = deepClonePlainData(row);
+      overlay.set(row.id, copy);
+      if (virtualValueIds.has(row.id)) {
+        trackVariantResolutionCopy(copies, rootRow.id, copy);
+      }
     }
     if (typeof receiver !== "object" || receiver === null || Array.isArray(receiver) || typeof resolution.root.value !== "object" || resolution.root.value === null || Array.isArray(resolution.root.value)) {
       throw new NSGetterRuntimeError(
@@ -27490,14 +27555,70 @@ function evalVariantApply(info, scope, ctx) {
   }
   return receiver;
 }
-function stampInstanceVariantProvenance(instance, selection, ctx, preserveLookupRow = false) {
+var variantResolutionCopiesByOverlay = /* @__PURE__ */ new WeakMap();
+function variantResolutionCopies(overlay) {
+  let copies = variantResolutionCopiesByOverlay.get(overlay);
+  if (copies === void 0) {
+    copies = { byRootId: /* @__PURE__ */ new Map(), rootIdByValueId: /* @__PURE__ */ new Map() };
+    variantResolutionCopiesByOverlay.set(overlay, copies);
+  }
+  return copies;
+}
+function hasVariantResolutionCopies(ctx) {
+  const overlay = ctx.__valueOverlay;
+  if (overlay === void 0) return false;
+  const copies = variantResolutionCopiesByOverlay.get(overlay);
+  return copies !== void 0 && copies.rootIdByValueId.size > 0;
+}
+function trackVariantResolutionCopy(copies, rootId, copy) {
+  let rootCopies = copies.byRootId.get(rootId);
+  if (rootCopies === void 0) {
+    rootCopies = /* @__PURE__ */ new Map();
+    copies.byRootId.set(rootId, rootCopies);
+  }
+  rootCopies.set(copy.id, copy);
+  copies.rootIdByValueId.set(copy.id, rootId);
+}
+function unwrittenVariantResolutionCopyIds(overlay, rootCopies) {
+  if (overlay === void 0 || rootCopies === void 0) return [];
+  const ids = [];
+  for (const [id, copy] of rootCopies) {
+    if (overlay.get(id) === copy) ids.push(id);
+  }
+  return ids;
+}
+function forgetVariantResolutionCopy(ctx, valueId) {
+  const overlay = ctx.__valueOverlay;
+  if (overlay === void 0) return;
+  const copies = variantResolutionCopiesByOverlay.get(overlay);
+  const rootId = copies?.rootIdByValueId.get(valueId);
+  if (copies === void 0 || rootId === void 0) return;
+  copies.rootIdByValueId.delete(valueId);
+  copies.byRootId.get(rootId)?.delete(valueId);
+}
+function stampInstanceVariantProvenance(instance, selection, ctx) {
   const row = trackedRowForValueReference(instance, ctx);
   if (row === null || !isLiteralValueContent(row)) return;
-  if (preserveLookupRow && row.id === selection.rowValueId) return;
+  if (row.id === selection.rowValueId) return;
   assertStoredReplayMutableValue(instance, ctx, "variant provenance");
   row.instanceVariantId = selection.variantId;
   row.instanceVariantRowValueId = selection.rowValueId;
 }
+function stampAppliedVariantProvenance(rootRow, instance, selection, ctx) {
+  const applied = typeof rootRow.instanceAppliedVariantId === "string";
+  const variantId = applied ? rootRow.instanceAppliedVariantId : rootRow.instanceVariantId ?? null;
+  const rowValueId = applied ? rootRow.instanceAppliedVariantRowValueId : rootRow.instanceVariantRowValueId;
+  if (variantId === selection.variantId && (rowValueId ?? null) === selection.rowValueId) {
+    return;
+  }
+  assertStoredReplayMutableValue(instance, ctx, "variant provenance");
+  if (!isVirtualInstanceRootShape(rootRow)) {
+    rootRow.instanceConstructorId = null;
+    rootRow.constructorArgs = {};
+  }
+  rootRow.instanceAppliedVariantId = selection.variantId;
+  rootRow.instanceAppliedVariantRowValueId = selection.rowValueId;
+}
 function constructDeclaredClassValue(info, scope, ctx) {
   const descriptor = validateClassConstructorDescriptor(info, ctx, false);
   const schemaClass2 = descriptor.schemaClass;
@@ -27580,6 +27701,7 @@ function constructDeclaredClassValueWithinFrame(descriptor, record4, info, scope
     );
   }
   const rootRecord = root.value;
+  recordConstructedFieldSchemaKeys(ctx, rootRecord, descriptor);
   if (record4 !== null) {
     const encoded = {};
     for (let index = 0; index < argumentValues.length; index += 1) {
@@ -27620,7 +27742,6 @@ function constructDeclaredClassValueWithinFrame(descriptor, record4, info, scope
     }
     const argumentsByValue = ctx.__constructedArgumentsByValue ?? (ctx.__constructedArgumentsByValue = /* @__PURE__ */ new WeakMap());
     argumentsByValue.set(rootRecord, encoded);
-    recordConstructedFieldSchemaKeys(ctx, rootRecord, descriptor);
     root.constructorArgs = deepClonePlainData(encoded);
     root.instanceConstructorId = record4.id;
   } else {
@@ -28013,7 +28134,7 @@ function cloneConstructorArgumentGraph(args) {
         member.classArguments,
         args.ctx.vm.classes
       );
-      const record4 = {};
+      const record4 = /* @__PURE__ */ Object.create(null);
       clone.value = record4;
       const sourceRecord = {
         ...virtualExpandedRecordForReceiver(source.value, args.ctx),
@@ -28057,7 +28178,7 @@ function cloneConstructorArgumentGraph(args) {
           `Constructor import references missing Dictionary entry member '${member.entryMemberId}'.`
         );
       }
-      const record4 = {};
+      const record4 = /* @__PURE__ */ Object.create(null);
       clone.value = record4;
       const entryEnv = envFromStamp(clone.genericBindings);
       for (const [key, childId] of Object.entries(source.value)) {
@@ -28300,7 +28421,7 @@ function materializeConstructorArgumentValue(args) {
       args.ctx.vm.members
     );
     const row = registerConstructorArgumentRow(args, {});
-    const record4 = {};
+    const record4 = /* @__PURE__ */ Object.create(null);
     for (const [key, rawEntry] of Object.entries(args.value)) {
       const entry = constructorCollectionEntryValue(
         rawEntry,
@@ -28880,14 +29001,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 */;
   });
@@ -28896,7 +29013,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({
@@ -28908,35 +29025,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;
@@ -28944,7 +29060,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 */;
@@ -28954,26 +29070,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, reference, ctx) {
+  const references = collectionReferences(collection, ctx);
+  if (typeof references !== "object") {
+    if (reference === (references === 0 /* RowIds */)) return;
+    const written = Array.isArray(collection) ? collection[Number(key)] : collection[String(key)];
+    if (!reference && 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 (reference) 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 (reference) keys.add(String(key));
+  else keys.delete(String(key));
 }
 
 // ../packages/neoscript-runtime/src/declaration-default-source.ts
@@ -32303,12 +32454,7 @@ function materializeInitializerValue(args) {
     value: evaluated.value,
     ...evaluated.classId === null ? {} : { classId: evaluated.classId },
     ...evaluated.genericBindings === void 0 ? {} : { genericBindings: { ...evaluated.genericBindings } },
-    ...evaluated.constructorArgs === void 0 ? {} : { constructorArgs: deepClonePlainData(evaluated.constructorArgs) },
-    ...evaluated.instanceConstructorId === void 0 ? {} : { instanceConstructorId: evaluated.instanceConstructorId },
-    ...evaluated.instanceVariantId === void 0 ? {} : { instanceVariantId: evaluated.instanceVariantId },
-    ...evaluated.instanceVariantRowValueId === void 0 ? {} : {
-      instanceVariantRowValueId: evaluated.instanceVariantRowValueId
-    }
+    ...deepClonePlainData(pickInstanceProvenance(evaluated))
   };
   const allCreated = [root, ...createdValues];
   if (evaluated.provisionalRootId !== void 0) {
@@ -32331,7 +32477,8 @@ function materializeInitializerValue(args) {
   return {
     root,
     createdValues,
-    pinnedRootSchemaKeys: evaluated.pinnedRootSchemaKeys ?? /* @__PURE__ */ new Set()
+    pinnedRootSchemaKeys: evaluated.pinnedRootSchemaKeys ?? /* @__PURE__ */ new Set(),
+    pinnedSchemaKeysByValueId: evaluated.pinnedSchemaKeysByValueId ?? /* @__PURE__ */ new Map()
   };
 }
 function materializeMemberDefaultValue(args) {
@@ -32448,7 +32595,12 @@ function materializeMemberDefaultValue(args) {
     storageKeyDeclarations,
     supersededRootId: built.id
   });
-  return { root, createdValues: interior, pinnedRootSchemaKeys: /* @__PURE__ */ new Set() };
+  return {
+    root,
+    createdValues: interior,
+    pinnedRootSchemaKeys: /* @__PURE__ */ new Set(),
+    pinnedSchemaKeysByValueId: /* @__PURE__ */ new Map()
+  };
 }
 
 // ../packages/neoscript-runtime/src/virtual-instance-graph.ts
@@ -32478,6 +32630,7 @@ function buildVirtualInstanceMaterializedIndex(args) {
     })
   };
 }
+var KEPT_ROW_SAMPLE_LIMIT = 12;
 function derivesContentFromMemberDefault(args) {
   const member = args.member;
   if (!isMemberClassBase(member)) return false;
@@ -32630,6 +32783,8 @@ function expandStoredInstance(args) {
     instanceConstructorId: _instanceConstructorId,
     instanceVariantId: _instanceVariantId,
     instanceVariantRowValueId: _instanceVariantRowValueId,
+    instanceAppliedVariantId: _instanceAppliedVariantId,
+    instanceAppliedVariantRowValueId: _instanceAppliedVariantRowValueId,
     ...envelope
   } = instanceRoot;
   void _value;
@@ -32638,6 +32793,8 @@ function expandStoredInstance(args) {
   void _instanceConstructorId;
   void _instanceVariantId;
   void _instanceVariantRowValueId;
+  void _instanceAppliedVariantId;
+  void _instanceAppliedVariantRowValueId;
   const closedRootMember = closeClassArgumentsFromRowStamp(
     rootMember,
     instanceRoot
@@ -32719,11 +32876,26 @@ function expandStoredInstance(args) {
       }
     };
   };
-  const materialized = derivesContentFromMemberDefault({
+  const constructed = derivesContentFromMemberDefault({
     member: replayMember,
     instanceRoot,
     effectiveClassId: classId
   }) ? replayDeclaredDefault() : replay([]);
+  const appliedVariantId = instanceRoot.instanceAppliedVariantId;
+  const materialized = typeof appliedVariantId !== "string" ? constructed : trackMaterialization(
+    () => replayAppliedVariant({
+      evaluateInitializer: args.evaluateInitializer,
+      document: args.document,
+      member: replayMember,
+      constructed,
+      classId,
+      variantId: appliedVariantId,
+      variantRowValueId: instanceRoot.instanceAppliedVariantRowValueId ?? null,
+      ...readTracking === void 0 ? {} : { readTracking },
+      saveStaticBindings: args.saveStaticBindings,
+      sessionStaticBindings: args.sessionStaticBindings
+    })
+  );
   const rows = [materialized.root, ...materialized.createdValues];
   assertVirtualExpansionIsLiteral(rows);
   return {
@@ -32732,6 +32904,80 @@ function expandStoredInstance(args) {
     pinnedRootSchemaKeys: /* @__PURE__ */ new Set()
   };
 }
+function replayAppliedVariant(args) {
+  const rootId = args.constructed.root.id;
+  const sessionValues = /* @__PURE__ */ new Map();
+  sessionValues.set(rootId, args.constructed.root);
+  for (const row of args.constructed.createdValues)
+    sessionValues.set(row.id, row);
+  const variant2 = args.document.databaseVM?.variantById?.(args.variantId) ?? args.document.variants?.find((entry) => entry.id === args.variantId);
+  const variantClassId = variant2?.classId ?? args.classId;
+  const schemaClassInfo = {
+    type: 7 /* Class */,
+    required: true,
+    classId: args.classId
+  };
+  args.evaluateInitializer({
+    init: {
+      code: `virtual-applied-variant:${rootId}`,
+      compiled: {
+        compilerRevision: NEOSCRIPT_COMPILER_REVISION,
+        parameters: evaluatorEnvelopeParameters(),
+        instructions: [
+          {
+            type: "return" /* return */,
+            pointer: {
+              type: "function" /* function */,
+              function: {
+                type: "variantApply" /* variantApply */,
+                info: {
+                  receiverPointer: {
+                    type: "reference" /* reference */,
+                    valueId: rootId
+                  },
+                  variantPointer: {
+                    type: "variant" /* variant */,
+                    classId: variantClassId,
+                    variantId: args.variantId,
+                    rowValueId: args.variantRowValueId
+                  },
+                  schemaClassInfo,
+                  declarativeReplay: true
+                }
+              }
+            }
+          }
+        ],
+        typeInfo: schemaClassInfo
+      }
+    },
+    member: args.member,
+    document: args.document,
+    createdValues: [],
+    sessionValues,
+    storedConstructionReplay: true,
+    sourceValueId: rootId,
+    ...args.readTracking === void 0 ? {} : { readTracking: args.readTracking },
+    saveStaticBindings: args.saveStaticBindings,
+    sessionStaticBindings: args.sessionStaticBindings
+  });
+  const root = sessionValues.get(rootId);
+  if (root === void 0) {
+    throw new Error(
+      `Applied variant "${args.variantId}" replay lost instance root "${rootId}".`
+    );
+  }
+  sessionValues.delete(rootId);
+  return {
+    ...args.constructed,
+    root: {
+      ...root,
+      instanceAppliedVariantId: args.variantId,
+      instanceAppliedVariantRowValueId: args.variantRowValueId
+    },
+    createdValues: [...sessionValues.values()]
+  };
+}
 function resolveVirtualInstanceGraph(args) {
   const expansion = args.expansionIndex ?? indexExpansion(args);
   const recorder = args.readRecorder ?? null;
@@ -33550,6 +33796,11 @@ function expandStoredClassValue(args) {
     pinnedRootSchemaKeys: /* @__PURE__ */ new Set()
   };
 }
+function owningInstanceRootId(graph) {
+  let owner = graph;
+  while (owner?.containingGraph !== void 0) owner = owner.containingGraph;
+  return owner?.instanceRootId ?? null;
+}
 function isStoredClassResolutionRoot(value) {
   if (!isLiteralValueContent(value)) return false;
   if (isVirtualInstanceRootShape(value)) return true;
@@ -33639,6 +33890,393 @@ function planVirtualOverrideResets(args) {
   });
   return { deletes, updates };
 }
+function planCollapseVirtualInstance(args) {
+  const protectedIds = args.protectedValueIds ?? /* @__PURE__ */ new Set();
+  const pinnedIds = args.pinnedValueIds ?? /* @__PURE__ */ new Set();
+  const deleteIds = /* @__PURE__ */ new Set();
+  const pairingMismatchIds = /* @__PURE__ */ new Set();
+  const updates = [];
+  const subtreeFacts = /* @__PURE__ */ new Map();
+  const stampsByPath = /* @__PURE__ */ new Map();
+  const reproducibleByPath = /* @__PURE__ */ new Map();
+  const isReproduciblePath = (location) => {
+    const cached = reproducibleByPath.get(location.pathKey);
+    if (cached !== void 0) return cached;
+    reproducibleByPath.set(location.pathKey, false);
+    const reproducible = computeReproduciblePath(location);
+    reproducibleByPath.set(location.pathKey, reproducible);
+    return reproducible;
+  };
+  const nestedRootIds = args.nestedRootValueIds ?? /* @__PURE__ */ new Set();
+  const isNestedRoot = (valueId) => valueId !== args.graph.root.id && nestedRootIds.has(valueId);
+  const ownsChildInterior = (child) => {
+    const stored = child.materializedRow;
+    if (stored === null) return true;
+    if (isNestedRoot(stored.id)) return false;
+    if (!isLiteralValueContent(stored)) return true;
+    const provenance = args.graph.compareCreationProvenance(child);
+    if (!provenance.sameType) return false;
+    if (provenance.sameRecipe) return true;
+    if (typeof stored.instanceConstructorId === "string") return false;
+    if (typeof stored.instanceVariantId === "string") return false;
+    if (typeof stored.instanceAppliedVariantId === "string") return false;
+    const storedArgs = stored.constructorArgs;
+    if (storedArgs != null && Object.keys(storedArgs).length > 0) return false;
+    return !isInitValueContent(child.member.defaultValue);
+  };
+  const valuesById = args.valuesById ?? /* @__PURE__ */ new Map();
+  const frameDerivedLineages = /* @__PURE__ */ new Set();
+  for (const location of args.graph.locationsByPath.values()) {
+    const derived = location.virtualRow.sourceValueId;
+    if (typeof derived === "string") frameDerivedLineages.add(derived);
+  }
+  const ownsLineageByPath = /* @__PURE__ */ new Map();
+  const frameOwnsLineage = (location) => {
+    const cached = ownsLineageByPath.get(location.pathKey);
+    if (cached !== void 0) return cached;
+    ownsLineageByPath.set(location.pathKey, true);
+    let owns = true;
+    let parentPath = parentPathKey(location.pathKey);
+    while (parentPath !== null) {
+      const ancestor = args.graph.locationsByPath.get(parentPath);
+      if (ancestor === void 0) break;
+      const ancestorId = ancestor.materializedRow?.id;
+      if (ancestorId !== void 0 && isNestedRoot(ancestorId)) {
+        owns = false;
+        break;
+      }
+      parentPath = parentPathKey(parentPath);
+    }
+    ownsLineageByPath.set(location.pathKey, owns);
+    return owns;
+  };
+  const isCrossFrameLineageRecord = (location, stored) => {
+    const storedSource = stored.sourceValueId ?? null;
+    if (storedSource === null) return false;
+    if (storedSource === stored.id) return false;
+    if (frameDerivedLineages.has(storedSource)) return false;
+    const named = valuesById.get(storedSource);
+    if (named === void 0) return false;
+    if (!isLiteralValueContent(stored)) return false;
+    if (!isLiteralValueContent(named)) {
+      return args.graph.compareLeafContent(location);
+    }
+    return semanticEqual(
+      normalizeLeafPayload(named, location.member),
+      normalizeLeafPayload(stored, location.member)
+    );
+  };
+  const computeReproduciblePath = (location) => {
+    const segment = location.parentSegment;
+    if (segment === null || location.pathKey === ROOT_PATH) return true;
+    const parentPath = parentPathKey(location.pathKey);
+    if (parentPath === null) return true;
+    const parent = args.graph.locationsByPath.get(parentPath);
+    if (parent === void 0) return false;
+    if (!isReproduciblePath(parent)) return false;
+    if (!isMemberEntryCollectionBase(parent.member)) return true;
+    if (listKindOf(parent.member) !== 1 /* Unordered */) return true;
+    return unorderedEntryMatchedByProvenance(location);
+  };
+  const normalizedStoredRow = (location, stored) => {
+    const cached = stampsByPath.get(location.pathKey);
+    if (cached !== void 0) return withLegacyLineage(stored, cached);
+    const stamp = settleLineage(stored, location.virtualRow, {
+      reproduciblePosition: isReproduciblePath(location),
+      frameOwnsLineage: frameOwnsLineage(location),
+      crossFrameRecord: isCrossFrameLineageRecord(location, stored)
+    });
+    stampsByPath.set(location.pathKey, stamp);
+    return withLegacyLineage(stored, stamp);
+  };
+  const compareSubtree = (location) => {
+    const cached = subtreeFacts.get(location.pathKey);
+    if (cached !== void 0) return cached;
+    const stored = location.materializedRow;
+    if (stored !== null && isInitValueContent(stored)) {
+      const result2 = {
+        defaultEqual: false,
+        contentEqual: false,
+        protected: true
+      };
+      subtreeFacts.set(location.pathKey, result2);
+      return result2;
+    }
+    const real = stored === null ? null : normalizedStoredRow(location, stored);
+    if (real === null) {
+      const result2 = {
+        defaultEqual: true,
+        contentEqual: true,
+        protected: false
+      };
+      subtreeFacts.set(location.pathKey, result2);
+      return result2;
+    }
+    let protectedSubtree = protectedIds.has(real.id) || pinnedIds.has(real.id) || args.removableValueIds !== void 0 && !args.removableValueIds.has(real.id) || location.parentId === args.graph.root.id && location.parentSegment?.kind === "class" && args.graph.pinnedRootSchemaKeys?.has(
+      location.parentSegment.schemaKey
+    ) === true;
+    const ownsLineage = frameOwnsLineage(location);
+    const pairingMismatch = provenancePairingDisagrees(
+      real,
+      location.virtualRow,
+      {
+        reproduciblePosition: isReproduciblePath(location),
+        frameOwnsLineage: true,
+        crossFrameRecord: isCrossFrameLineageRecord(location, real)
+      }
+    );
+    let defaultEqual = !pairingMismatch && args.graph.compareCreationProvenance(location).sameRecipe;
+    let contentEqual = true;
+    const storedIsNull = real.value === null;
+    const virtualIsNull = location.virtualRow.value === null;
+    if (storedIsNull || virtualIsNull) {
+      defaultEqual &&= storedIsNull && virtualIsNull;
+      contentEqual &&= storedIsNull && virtualIsNull;
+    } else if (isMemberClassBase(location.member)) {
+      for (const schemaKey of Object.keys(stringRecord(real.value))) {
+        const child = args.graph.locationsByPath.get(
+          appendVirtualValuePath(location.pathKey, {
+            kind: "class",
+            schemaKey
+          })
+        );
+        if (child === void 0) {
+          defaultEqual = false;
+          contentEqual = false;
+          continue;
+        }
+        const facts = compareSubtree(child);
+        defaultEqual &&= facts.defaultEqual;
+        contentEqual &&= facts.contentEqual;
+        protectedSubtree ||= facts.protected;
+      }
+    } else if (isMemberEntryCollectionBase(location.member)) {
+      if (listKindOf(location.member) === 1 /* Unordered */) {
+        protectedSubtree = true;
+        const storedEntries = args.graph.materializedUnorderedEntryIdsByContainerId.get(real.id) ?? [];
+        const virtualEntries = args.graph.expandedChildPathsByParentPath.get(location.pathKey) ?? [];
+        const resolvedEntries = args.graph.childPathsByParentPath.get(location.pathKey) ?? [];
+        const storedIsArray = Array.isArray(real.value);
+        const virtualIsArray = Array.isArray(location.virtualRow.value);
+        const entryCountsAgree = storedEntries.length === virtualEntries.length && resolvedEntries.length === storedEntries.length;
+        defaultEqual &&= storedIsArray;
+        defaultEqual &&= virtualIsArray;
+        defaultEqual &&= entryCountsAgree;
+        contentEqual &&= storedIsArray;
+        contentEqual &&= virtualIsArray;
+        contentEqual &&= entryCountsAgree;
+        const resolvedStoredIds = [];
+        for (const childPath of resolvedEntries) {
+          const child = args.graph.locationsByPath.get(childPath);
+          if (child?.materializedRow === null || child === void 0) {
+            defaultEqual = false;
+            contentEqual = false;
+            continue;
+          }
+          resolvedStoredIds.push(child.materializedRow.id);
+          const facts = compareSubtree(child);
+          defaultEqual &&= facts.defaultEqual;
+          contentEqual &&= facts.contentEqual;
+        }
+        const membershipEqual = semanticEqual(
+          resolvedStoredIds.sort(),
+          [...storedEntries].sort()
+        );
+        defaultEqual &&= membershipEqual;
+        contentEqual &&= membershipEqual;
+      } else {
+        const stored2 = Array.isArray(real.value) ? real.value : null;
+        const virtual = Array.isArray(location.virtualRow.value) ? location.virtualRow.value : null;
+        const bothArrays = stored2 !== null && virtual !== null;
+        const lengthsAgree = stored2?.length === virtual?.length;
+        defaultEqual &&= bothArrays;
+        defaultEqual &&= lengthsAgree;
+        contentEqual &&= bothArrays;
+        contentEqual &&= lengthsAgree;
+        for (let index = 0; index < (stored2?.length ?? 0); index += 1) {
+          if (stored2?.[index] === null && virtual?.[index] === null) continue;
+          const child = args.graph.locationsByPath.get(
+            appendVirtualValuePath(location.pathKey, { kind: "list", index })
+          );
+          if (child === void 0) {
+            defaultEqual = false;
+            contentEqual = false;
+            continue;
+          }
+          const facts = compareSubtree(child);
+          defaultEqual &&= facts.defaultEqual;
+          contentEqual &&= facts.contentEqual;
+          protectedSubtree ||= facts.protected;
+        }
+      }
+    } else if (isMemberDictionaryBase(location.member)) {
+      const stored2 = stringRecord(real.value);
+      const virtual = stringRecord(location.virtualRow.value);
+      const keysEqual = semanticEqual(
+        Object.keys(stored2).sort(),
+        Object.keys(virtual).sort()
+      );
+      defaultEqual &&= keysEqual;
+      contentEqual &&= keysEqual;
+      for (const key of Object.keys(stored2)) {
+        const child = args.graph.locationsByPath.get(
+          appendVirtualValuePath(location.pathKey, { kind: "dictionary", key })
+        );
+        if (child === void 0) {
+          defaultEqual = false;
+          contentEqual = false;
+          continue;
+        }
+        const facts = compareSubtree(child);
+        defaultEqual &&= facts.defaultEqual;
+        contentEqual &&= facts.contentEqual;
+        protectedSubtree ||= facts.protected;
+      }
+    } else {
+      const leafEqual = args.graph.compareLeafContent(location);
+      defaultEqual &&= leafEqual;
+      contentEqual &&= leafEqual;
+    }
+    const result = { defaultEqual, contentEqual, protected: protectedSubtree };
+    if (pairingMismatch && ownsLineage && contentEqual) {
+      pairingMismatchIds.add(real.id);
+    }
+    subtreeFacts.set(location.pathKey, result);
+    return result;
+  };
+  const deleteSubtree = (location) => {
+    const descendants = [];
+    const pending = [location.pathKey];
+    while (pending.length > 0) {
+      const path = pending.pop();
+      if (path === void 0) continue;
+      const candidate = args.graph.locationsByPath.get(path);
+      if (candidate !== void 0) descendants.push(candidate);
+      for (const childPath of args.graph.childPathsByParentPath.get(path) ?? []) {
+        pending.push(childPath);
+      }
+    }
+    descendants.sort(
+      (left, right) => pathDepth(right.pathKey) - pathDepth(left.pathKey)
+    );
+    for (const candidate of descendants) {
+      if (candidate.materializedRow !== null) {
+        deleteIds.add(candidate.materializedRow.id);
+      }
+    }
+  };
+  const sparsifyClass = (location) => {
+    const real = location.materializedRow;
+    if (real === null || isInitValueContent(real) || !isMemberClassBase(location.member))
+      return;
+    const stored = stringRecord(real.value);
+    const next = {};
+    for (const [schemaKey, childId] of Object.entries(stored)) {
+      const child = args.graph.locationsByPath.get(
+        appendVirtualValuePath(location.pathKey, { kind: "class", schemaKey })
+      );
+      if (child === void 0) {
+        next[schemaKey] = childId;
+        continue;
+      }
+      const facts = compareSubtree(child);
+      if (facts.defaultEqual && !facts.protected) {
+        deleteSubtree(child);
+        continue;
+      }
+      next[schemaKey] = child.materializedRow?.id ?? childId;
+      if (!isMemberClassBase(child.member)) continue;
+      if (!ownsChildInterior(child)) continue;
+      sparsifyClass(child);
+    }
+    if (!semanticEqual(stored, next)) {
+      updates.push({ valueId: real.id, value: next });
+    }
+  };
+  const stampSurvivingRow = (valueId, pathKey) => {
+    const stamp = stampsByPath.get(pathKey);
+    if (stamp === void 0) return;
+    if (stampIsEmpty(stamp)) return;
+    const sourceValueId = stamp.clearSourceValueId ? null : stamp.sourceValueId;
+    const existing = updates.find((update) => update.valueId === valueId);
+    if (existing !== void 0) {
+      if (sourceValueId !== null || stamp.clearSourceValueId) {
+        existing.sourceValueId = sourceValueId;
+      }
+      return;
+    }
+    const location = args.graph.locationsById.get(valueId);
+    const stored = location?.materializedRow;
+    if (stored === void 0 || stored === null) return;
+    updates.push({
+      valueId,
+      // Payload untouched: this update exists to carry lineage. The corpus
+      // planner drops a change whose row is byte-identical, so a re-run over an
+      // already-corrected row produces nothing.
+      value: stored.value,
+      ...sourceValueId === null && !stamp.clearSourceValueId ? {} : { sourceValueId }
+    });
+  };
+  sparsifyClass(args.graph.root);
+  const deletes = [...deleteIds].sort((left, right) => {
+    const leftLocation = args.graph.locationsById.get(left);
+    const rightLocation = args.graph.locationsById.get(right);
+    return pathDepth(rightLocation?.pathKey ?? ROOT_PATH) - pathDepth(leftLocation?.pathKey ?? ROOT_PATH);
+  });
+  const locatedRows = [];
+  for (const location of args.graph.locationsByPath.values()) {
+    if (location.pathKey === ROOT_PATH) continue;
+    const row = location.materializedRow;
+    if (row === null) continue;
+    locatedRows.push({ id: row.id, pathKey: location.pathKey });
+  }
+  locatedRows.sort((left, right) => left.pathKey.localeCompare(right.pathKey));
+  const materializedNonRoot = [];
+  const seenIds = /* @__PURE__ */ new Set();
+  for (const entry of locatedRows) {
+    if (seenIds.has(entry.id)) continue;
+    seenIds.add(entry.id);
+    materializedNonRoot.push(entry);
+  }
+  const keptRowReasons = /* @__PURE__ */ new Map();
+  const breakdown = { content: 0, provenanceOnly: 0, pinnedOrReference: 0 };
+  const provenanceOnlySampleIds = [];
+  const contentSampleIds = [];
+  let keptReferenceTargetRows = 0;
+  for (const entry of materializedNonRoot) {
+    if (protectedIds.has(entry.id)) keptReferenceTargetRows += 1;
+    if (deleteIds.has(entry.id)) continue;
+    if (args.removableValueIds === void 0)
+      stampSurvivingRow(entry.id, entry.pathKey);
+    const reason = keptRowReason(subtreeFacts.get(entry.pathKey));
+    keptRowReasons.set(entry.id, reason);
+    breakdown[reason] += 1;
+    if (reason === "provenanceOnly" && provenanceOnlySampleIds.length < KEPT_ROW_SAMPLE_LIMIT) {
+      provenanceOnlySampleIds.push(entry.id);
+    }
+    if (reason === "content" && contentSampleIds.length < KEPT_ROW_SAMPLE_LIMIT) {
+      contentSampleIds.push(entry.id);
+    }
+  }
+  return {
+    deletes,
+    updates,
+    deletedDefaultEqualRows: deletes.length,
+    keptOverrideRows: keptRowReasons.size,
+    keptReferenceTargetRows,
+    pairingMismatchValueIds: [...pairingMismatchIds].sort(),
+    keptRowBreakdown: breakdown,
+    provenanceOnlySampleIds,
+    contentSampleIds,
+    keptRowReasons
+  };
+}
+function keptRowReason(facts) {
+  if (facts === void 0) return "content";
+  if (!facts.contentEqual) return "content";
+  if (!facts.defaultEqual) return "provenanceOnly";
+  return "pinnedOrReference";
+}
 function closeClassArgumentsFromRowStamp(member, row) {
   if (!isMemberClassBase(member)) return member;
   const stamp = row.genericBindings;
@@ -33977,7 +34615,9 @@ function compareContextualCreationProvenance(left, right, context) {
       constructorArgs: literal3.constructorArgs ?? {},
       instanceConstructorId: literal3.instanceConstructorId ?? null,
       instanceVariantId: literal3.instanceVariantId ?? null,
-      instanceVariantRowValueId: literal3.instanceVariantRowValueId ?? null
+      instanceVariantRowValueId: literal3.instanceVariantRowValueId ?? null,
+      instanceAppliedVariantId: literal3.instanceAppliedVariantId ?? null,
+      instanceAppliedVariantRowValueId: literal3.instanceAppliedVariantRowValueId ?? null
     };
   };
   return {
@@ -33988,10 +34628,80 @@ function compareContextualCreationProvenance(left, right, context) {
     )
   };
 }
+var SYNTHETIC_LINEAGE_PREFIXES = ["missing-expansion:", "path:"];
+function unorderedEntryMatchedByProvenance(location) {
+  const storedSource = location.materializedRow?.sourceValueId ?? null;
+  if (storedSource === null) return false;
+  return storedSource === (location.virtualRow.sourceValueId ?? null);
+}
+function adoptableLineage(stored, expanded, reproduciblePosition) {
+  if (!reproduciblePosition) return null;
+  const expandedSource = expanded.sourceValueId ?? null;
+  if (expandedSource === null) return null;
+  if (expandedSource === stored.id) return null;
+  if (SYNTHETIC_LINEAGE_PREFIXES.some(
+    (prefix) => expandedSource.startsWith(prefix)
+  )) {
+    return null;
+  }
+  return expandedSource;
+}
+function storedLineageIsMeaningless(materialized, reproduciblePosition) {
+  const storedSource = materialized.sourceValueId ?? null;
+  if (storedSource === null) return false;
+  if (storedSource === materialized.id) return true;
+  return !reproduciblePosition;
+}
+function provenancePairingDisagrees(materialized, expanded, frame) {
+  const storedSource = materialized.sourceValueId ?? null;
+  if (storedSource === null) return false;
+  if (!frame.frameOwnsLineage) return false;
+  if (frame.crossFrameRecord) return false;
+  if (storedLineageIsMeaningless(materialized, frame.reproduciblePosition)) {
+    return false;
+  }
+  return storedSource !== (expanded.sourceValueId ?? null);
+}
+function settleLineage(stored, expanded, frame) {
+  const nothing = { sourceValueId: null, clearSourceValueId: false };
+  if (!frame.frameOwnsLineage) return nothing;
+  const storedSource = stored.sourceValueId ?? null;
+  const expandedSource = expanded.sourceValueId ?? null;
+  if (storedSource === null) {
+    return {
+      sourceValueId: adoptableLineage(
+        stored,
+        expanded,
+        frame.reproduciblePosition
+      ),
+      clearSourceValueId: false
+    };
+  }
+  if (storedSource === expandedSource) return nothing;
+  if (frame.crossFrameRecord && frame.reproduciblePosition) {
+    return expandedSource === null ? { sourceValueId: null, clearSourceValueId: true } : { sourceValueId: expandedSource, clearSourceValueId: false };
+  }
+  if (storedLineageIsMeaningless(stored, frame.reproduciblePosition)) {
+    return { sourceValueId: null, clearSourceValueId: true };
+  }
+  return nothing;
+}
 function readClassId(row) {
   const classId = Reflect.get(row, "classId");
   return typeof classId === "string" ? classId : null;
 }
+function stampIsEmpty(stamp) {
+  return stamp.sourceValueId === null && !stamp.clearSourceValueId;
+}
+function withLegacyLineage(stored, stamp) {
+  if (stampIsEmpty(stamp)) return stored;
+  const next = {
+    ...stored,
+    ...stamp.sourceValueId === null ? {} : { sourceValueId: stamp.sourceValueId }
+  };
+  if (stamp.clearSourceValueId) delete next.sourceValueId;
+  return next;
+}
 function literalRow(row) {
   if (!isLiteralValueContent(row)) {
     throw new Error(`Expected literal instance row "${row.id}".`);
@@ -34207,40 +34917,37 @@ function resolveVariantInstanceGraphForDocument(args) {
     rootMember,
     readRecorder: args.readRecorder
   });
-  const priorGraph = resolveVirtualInstanceGraph({
+  let priorInstanceRoot = args.priorInstanceRoot;
+  let nextInstanceRoot = args.nextInstanceRoot;
+  const resolvePriorGraph = () => resolveVirtualInstanceGraph({
     document: document2,
-    instanceRoot: args.priorInstanceRoot,
+    instanceRoot: priorInstanceRoot,
     rootMember,
     expandedRoot: priorExpanded.root,
     expandedRows: priorExpanded.rows,
     materializedRows: [...materializedById.values()],
     readRecorder: args.readRecorder
   });
-  const priorAnsweredIds = [];
-  const incomingAnsweredIds = [];
-  for (const valueId of args.answeredValueIds) {
-    const bucket = priorGraph.locationsById.has(valueId) ? priorAnsweredIds : incomingAnsweredIds;
-    bucket.push(valueId);
-  }
   const clearedValueIds = /* @__PURE__ */ new Set();
-  let nextInstanceRoot = args.nextInstanceRoot;
-  const resetAnsweredValues = (graph, valueIds) => {
-    if (valueIds.length === 0) return;
-    const reset = planVirtualOverrideResets({ graph, valueIds });
+  const applyReset = (graph, reset) => {
     for (const valueId of reset.deletes) {
       clearedValueIds.add(valueId);
       materializedById.delete(valueId);
     }
     for (const update of reset.updates) {
       if (update.valueId === nextInstanceRoot.id) {
-        const nextRecord = { ...stringRecord(nextInstanceRoot.value) };
         const resetRecord = stringRecord(update.value);
         const priorRecord = stringRecord(graph.root.materializedRow?.value);
-        for (const schemaKey of Object.keys(priorRecord)) {
-          if (!Object.hasOwn(resetRecord, schemaKey))
-            delete nextRecord[schemaKey];
-        }
-        nextInstanceRoot = { ...nextInstanceRoot, value: nextRecord };
+        const withoutReset = (root2) => {
+          const record4 = { ...stringRecord(root2.value) };
+          for (const schemaKey of Object.keys(priorRecord)) {
+            if (!Object.hasOwn(resetRecord, schemaKey))
+              delete record4[schemaKey];
+          }
+          return { ...root2, value: record4 };
+        };
+        priorInstanceRoot = withoutReset(literalRow(priorInstanceRoot));
+        nextInstanceRoot = withoutReset(literalRow(nextInstanceRoot));
       }
       const existing = materializedById.get(update.valueId);
       if (existing !== void 0) {
@@ -34252,6 +34959,28 @@ function resolveVariantInstanceGraphForDocument(args) {
     }
     materializedById.set(nextInstanceRoot.id, nextInstanceRoot);
   };
+  let priorGraph = resolvePriorGraph();
+  if (args.virtualCopyIds !== void 0 && args.virtualCopyIds.length > 0) {
+    const collapse = planCollapseVirtualInstance({
+      graph: priorGraph,
+      removableValueIds: new Set(args.virtualCopyIds)
+    });
+    if (collapse.deletes.length > 0 || collapse.updates.length > 0) {
+      applyReset(priorGraph, collapse);
+      materializedById.set(priorInstanceRoot.id, priorInstanceRoot);
+      priorGraph = resolvePriorGraph();
+    }
+  }
+  const priorAnsweredIds = [];
+  const incomingAnsweredIds = [];
+  for (const valueId of args.answeredValueIds) {
+    const bucket = priorGraph.locationsById.has(valueId) ? priorAnsweredIds : incomingAnsweredIds;
+    bucket.push(valueId);
+  }
+  const resetAnsweredValues = (graph, valueIds) => {
+    if (valueIds.length === 0) return;
+    applyReset(graph, planVirtualOverrideResets({ graph, valueIds }));
+  };
   resetAnsweredValues(priorGraph, priorAnsweredIds);
   materializedById.set(nextInstanceRoot.id, nextInstanceRoot);
   const nextExpanded = expandStoredInstance({
@@ -34295,10 +35024,15 @@ function resolveVariantInstanceGraphForDocument(args) {
       `ToVariant failed to resolve instance root '${args.nextInstanceRoot.id}'.`
     );
   }
+  const virtualValueIds = /* @__PURE__ */ new Set();
+  for (const location of nextGraph.locationsById.values()) {
+    if (location.materializedRow === null) virtualValueIds.add(location.id);
+  }
   return {
     root,
     rows: [...nextGraph.rowsById.values()],
-    clearedValueIds: [...clearedValueIds]
+    clearedValueIds: [...clearedValueIds],
+    virtualValueIds: [...virtualValueIds]
   };
 }
 function variantSwapDeclaredMember(document2, rootValueId) {
@@ -34685,6 +35419,7 @@ function initializerEvaluatorLookups(document2, readTracking) {
         return resolved;
       },
       virtualInstanceRowsForValue: (receiverValueId) => databaseVM.virtualInstanceRowsForValue(receiverValueId),
+      virtualInstanceRootIdForValue: (valueId) => databaseVM.virtualInstanceRootIdForValue(valueId),
       ...databaseVM.worldGridQueryIndex === void 0 ? {} : { worldGridQueryIndex: () => databaseVM.worldGridQueryIndex() },
       rowForValueReference: (value) => databaseVM.rowForValueReference?.(value) ?? null,
       resolveVariantInstanceGraph: (args) => {
@@ -34740,6 +35475,9 @@ function initializerEvaluatorLookups(document2, readTracking) {
     valueById: (id) => indexedLookups.valueById(id) ?? headlessVirtualResolver.valueById(id),
     rowForValueReference: (value) => indexedLookups.rowForValueReference?.(value) ?? headlessVirtualResolver.rowForValueReference(value),
     virtualInstanceRowsForValue: (receiverValueId) => headlessVirtualResolver.virtualInstanceRowsForValue(receiverValueId),
+    virtualInstanceRootIdForValue: (valueId) => owningInstanceRootId(
+      headlessVirtualResolver.virtualInstanceGraphForValue(valueId)
+    ),
     recordVirtualInstanceReads: (reads, read) => headlessVirtualResolver.recordReads(reads, read),
     // Headless hosts still evaluate `ToVariant` during
     // stored-construction replay — production's variant-constructed
@@ -34862,6 +35600,7 @@ function evaluateMemberInitializer(args) {
   );
   const compiled = compileMemberInitializer(args, databaseVM);
   const ctx = {
+    ...args.sessionValues === void 0 ? {} : { __runtimeSessionValues: args.sessionValues },
     debugSink: args.document.debugSink,
     beforeValueAllocation: args.document.beforeValueAllocation,
     listenerDefaultCapture: args.document.listenerDefaultCapture,
@@ -34932,10 +35671,13 @@ function evaluateMemberInitializer(args) {
         args.argumentValues ?? [],
         {
           exportInitializerValues: true,
-          initializerResult: {
-            member: args.member,
-            genericEnv: args.genericEnv
-          }
+          // Seeded rows already hold their placement.
+          ...args.sessionValues === void 0 ? {
+            initializerResult: {
+              member: args.member,
+              genericEnv: args.genericEnv
+            }
+          } : {}
         }
       );
     } catch (error) {
@@ -34958,9 +35700,12 @@ function evaluateMemberInitializer(args) {
     );
   }
   const rootRow = initializerRootRow(result.value, created);
+  const pinnedSchemaKeysByValueId = /* @__PURE__ */ new Map();
   for (const row of created) {
     if (row === rootRow) continue;
     args.createdValues.push(row);
+    const keys = typeof row.value === "object" && row.value !== null ? ctx.__constructedFieldSchemaKeysByValue?.get(row.value) : void 0;
+    if (keys !== void 0) pinnedSchemaKeysByValueId.set(row.id, keys);
   }
   if (rootRow === null) return { value: result.value, classId: null };
   const constructorArgs = (typeof result.value === "object" && result.value !== null ? ctx.__constructedArgumentsByValue?.get(result.value) : void 0) ?? // An implicit `new()` records its empty args on the row rather than in
@@ -34968,17 +35713,13 @@ function evaluateMemberInitializer(args) {
   // origin or the recipe reads as an unrecorded overload.
   rootRow.constructorArgs ?? void 0;
   const pinnedRootSchemaKeys = typeof result.value === "object" && result.value !== null ? ctx.__constructedFieldSchemaKeysByValue?.get(result.value) : void 0;
-  const provenance = pickInstanceProvenance({
-    constructorArgs,
-    instanceConstructorId: rootRow.instanceConstructorId,
-    instanceVariantId: rootRow.instanceVariantId,
-    instanceVariantRowValueId: rootRow.instanceVariantRowValueId
-  });
+  const provenance = pickInstanceProvenance({ ...rootRow, constructorArgs });
   return {
     value: result.value,
     classId: rootRow.classId ?? null,
     ...rootRow.genericBindings === void 0 ? {} : { genericBindings: { ...rootRow.genericBindings } },
     ...pinnedRootSchemaKeys === void 0 ? {} : { pinnedRootSchemaKeys },
+    ...pinnedSchemaKeysByValueId.size === 0 ? {} : { pinnedSchemaKeysByValueId },
     provisionalRootId: rootRow.id,
     ...provenance,
     ...provenance.constructorArgs === void 0 ? {} : {
@@ -35052,6 +35793,7 @@ function headlessVirtualInstanceLookups(document2, options = {}) {
     valueById: (id) => indexed.valueById(id) ?? virtual.valueById(id),
     rowForValueReference: (value) => indexed.rowForValueReference(value) ?? virtual.rowForValueReference(value),
     virtualInstanceRowsForValue: (receiverValueId) => virtual.virtualInstanceRowsForValue(receiverValueId),
+    virtualInstanceRootIdForValue: (valueId) => owningInstanceRootId(virtual.virtualInstanceGraphForValue(valueId)),
     // Stored-construction replay evaluates `ToVariant`, and production's
     // variant-constructed placements collapse through exactly this path.
     resolveVariantInstanceGraph: (args) => resolveVariantInstanceGraphForDocument2({
@@ -41296,7 +42038,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     };
   }
   resolveDictionaryKey(expectedKey, keyAst, scope, pos, requireNonOptional, dictionaryLiteral = false) {
-    const key = this.resolveExpression(keyAst, scope);
+    const key = this.resolveExpression(keyAst, scope, expectedKey);
     if (requireNonOptional && isNullable(key.type)) {
       throw new CompileError(
         `Dictionary keys must be non-optional; got ${this.describe(key.type)}`,
@@ -42443,13 +43185,12 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     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,
@@ -46776,21 +47517,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)
         );
@@ -46808,6 +47562,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,
@@ -46876,6 +47631,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((parameter3, index) => {
     const argument2 = type.typeArguments?.[index];
@@ -58796,7 +59559,7 @@ var INITIALIZER_KEY_PLACEHOLDER = new RegExp(
 
 // ../packages/manifest/schema-contract/registry.mjs
 var PROJECT_SCHEMA_CONTRACT = Object.freeze({
-  cliVersion: "0.81.0",
+  cliVersion: "0.81.2",
   projectFileUploadBatchSize: 32,
   documentRecords: {
     member: {