@neocompose/cli 0.80.0 → 0.81.1

package/dist/test-worker.mjs

@@ -1013,11 +1013,11 @@ var NeoWorldSystemClassKind = {
   ObjectCollider: "objectCollider",
   SortingGroup: "sortingGroup",
   LayerGroupBase: "layerGroupBase",
-  SpriteObject: "spriteObject",
   PlacementTile: "placementTile",
   TileLayerLink: "tileLayerLink",
   ObjectLayerLink: "objectLayerLink",
   Object: "object",
+  SpriteObject: "spriteObject",
   SmartTile: "smartTile",
   SmartTileRule: "smartTileRule",
   SmartTileNeighbor: "smartTileNeighbor",
@@ -3600,6 +3600,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 +5286,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 +5314,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 +6088,8 @@ var LITERAL_INSTANCE_IDENTITY_FIELDS = [
   "instanceConstructorId",
   "instanceVariantId",
   "instanceVariantRowValueId",
+  "instanceAppliedVariantId",
+  "instanceAppliedVariantRowValueId",
   "genericBindings"
 ];
 function replaceLiteralValueClass(value, classId) {
@@ -6103,7 +6112,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 +6289,7 @@ function decodeContentField(container, field, scope, children) {
       )
     };
   }
-  const decoded = {};
+  const decoded = /* @__PURE__ */ Object.create(null);
   for (const [key, entry] of Object.entries(
     container
   )) {
@@ -7343,64 +7356,6 @@ var WORLD_SYSTEM_CLASS_DEFINITIONS = [
     modifier: 1 /* Abstract */,
     worldKind: "layerGroupBase"
   },
-  {
-    classId: "system_d48b66ab-4d59-47e7-a25a-591fe97062de",
-    name: "NeoSpriteObject",
-    extendsWorldKind: "objectBase",
-    schemaFields: [
-      {
-        memberId: "system_441cb790-a45f-4488-a5a9-6f375af6c369",
-        memberKind: "string",
-        defaultValue: "",
-        format: 1 /* Plain */,
-        distribution: 1 /* Packed */,
-        requirement: 1 /* Required */,
-        schemaKey: "Name"
-      },
-      {
-        memberId: "system_e9288ba9-f5a2-4485-8443-6afb155b31e0",
-        memberKind: "sprite",
-        defaultValue: { fileId: "", sliceIndex: 0 },
-        requirement: 1 /* Required */,
-        schemaKey: "Sprite"
-      },
-      {
-        memberId: "system_9fcab37a-9743-4e35-8eee-80cb560f1433",
-        memberKind: "bool",
-        defaultValue: false,
-        docsText: "Mirrors the sprite horizontally about its own centre. Maps to SpriteRenderer.flipX.",
-        requirement: 1 /* Required */,
-        schemaKey: "FlipX"
-      },
-      {
-        memberId: "system_ddd09f08-1656-4404-b36b-5570a4c01fcf",
-        memberKind: "bool",
-        defaultValue: false,
-        docsText: "Mirrors the sprite vertically about its own centre. Maps to SpriteRenderer.flipY.",
-        requirement: 1 /* Required */,
-        schemaKey: "FlipY"
-      },
-      {
-        memberId: "system_f2a8c86d-ace5-421b-9475-0f3f6f97b2a6",
-        memberKind: "enum",
-        defaultValue: ["system_9d607a4f-60c3-4347-94fc-f24b538bf468"],
-        docsText: "How this sprite reacts to sprite masks. Maps to SpriteRenderer.maskInteraction. The web canvas has no real sprite mask, so anything other than None previews as a distinguishable treatment rather than as the mask itself \u2014 only Unity renders the real thing.",
-        enumId: "system_4e6c4d6f-1d0b-402a-ad3a-be92242dceec",
-        requirement: 1 /* Required */,
-        schemaKey: "MaskInteraction"
-      },
-      {
-        memberId: "system_6f32f1f2-83ea-42fc-8647-34ed0946b7f1",
-        memberKind: "int",
-        defaultValue: null,
-        docsText: "Added to the object layer's sorting order; it does not replace it. The result competes with every renderer in the sorting layer, or in the enclosing sorting group, and among equal orders the renderer lower on screen draws in front. Leave unset to use the layer's order.",
-        minValue: -32768,
-        maxValue: 32767,
-        schemaKey: "SortingOrder"
-      }
-    ],
-    worldKind: "spriteObject"
-  },
   {
     classId: "system_ccc3330c-2db5-44dc-9c8e-5ebfe430dec9",
     name: "NeoPlacementTile",
@@ -7479,6 +7434,7 @@ var WORLD_SYSTEM_CLASS_DEFINITIONS = [
         memberId: "system_5a9ca1f5-a21b-4d4e-8c55-00341af594b4",
         memberKind: "list",
         defaultValue: [],
+        docsText: "The cells this object occupies, as offsets from its placement cell. An empty list occupies nothing: the object blocks no placement and answers no cell query, but a placed object still has a Cell.",
         entryMemberId: "system_96c7650a-1805-5b27-ae99-d1e49d3cb207",
         requirement: 1 /* Required */,
         schemaKey: "PlacementTiles"
@@ -7663,6 +7619,64 @@ var WORLD_SYSTEM_CLASS_DEFINITIONS = [
     ],
     worldKind: "object"
   },
+  {
+    classId: "system_d48b66ab-4d59-47e7-a25a-591fe97062de",
+    name: "NeoSpriteObject",
+    extendsWorldKind: "object",
+    schemaFields: [
+      {
+        memberId: "system_441cb790-a45f-4488-a5a9-6f375af6c369",
+        memberKind: "string",
+        defaultValue: "",
+        format: 1 /* Plain */,
+        distribution: 1 /* Packed */,
+        requirement: 1 /* Required */,
+        schemaKey: "Name"
+      },
+      {
+        memberId: "system_e9288ba9-f5a2-4485-8443-6afb155b31e0",
+        memberKind: "sprite",
+        defaultValue: { fileId: "", sliceIndex: 0 },
+        requirement: 1 /* Required */,
+        schemaKey: "Sprite"
+      },
+      {
+        memberId: "system_9fcab37a-9743-4e35-8eee-80cb560f1433",
+        memberKind: "bool",
+        defaultValue: false,
+        docsText: "Mirrors the sprite horizontally about its own centre. Maps to SpriteRenderer.flipX.",
+        requirement: 1 /* Required */,
+        schemaKey: "FlipX"
+      },
+      {
+        memberId: "system_ddd09f08-1656-4404-b36b-5570a4c01fcf",
+        memberKind: "bool",
+        defaultValue: false,
+        docsText: "Mirrors the sprite vertically about its own centre. Maps to SpriteRenderer.flipY.",
+        requirement: 1 /* Required */,
+        schemaKey: "FlipY"
+      },
+      {
+        memberId: "system_f2a8c86d-ace5-421b-9475-0f3f6f97b2a6",
+        memberKind: "enum",
+        defaultValue: ["system_9d607a4f-60c3-4347-94fc-f24b538bf468"],
+        docsText: "How this sprite reacts to sprite masks. Maps to SpriteRenderer.maskInteraction. The web canvas has no real sprite mask, so anything other than None previews as a distinguishable treatment rather than as the mask itself \u2014 only Unity renders the real thing.",
+        enumId: "system_4e6c4d6f-1d0b-402a-ad3a-be92242dceec",
+        requirement: 1 /* Required */,
+        schemaKey: "MaskInteraction"
+      },
+      {
+        memberId: "system_6f32f1f2-83ea-42fc-8647-34ed0946b7f1",
+        memberKind: "int",
+        defaultValue: null,
+        docsText: "Added to the object layer's sorting order; it does not replace it. The result competes with every renderer in the sorting layer, or in the enclosing sorting group, and among equal orders the renderer lower on screen draws in front. Leave unset to use the layer's order.",
+        minValue: -32768,
+        maxValue: 32767,
+        schemaKey: "SortingOrder"
+      }
+    ],
+    worldKind: "spriteObject"
+  },
   {
     classId: "system_9f34deed-2616-43c9-b614-d812da89ee51",
     name: "NeoSmartTile",
@@ -11532,12 +11546,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) {
@@ -11870,15 +11880,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) {
@@ -11959,11 +11963,7 @@ function completeDefaultClassRecord(args) {
     if (!shouldMaterializeChildDefaultForRoot(
       args.constructorRoot,
       resolvedChildMember,
-      defaultSettlesConstruction2,
-      documentHasInitValueContent(
-        args.document,
-        resolvedChildMember.defaultValue
-      )
+      defaultSettlesConstruction2
     )) {
       continue;
     }
@@ -12074,7 +12074,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,
@@ -12351,9 +12351,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)
     }
@@ -12391,11 +12389,6 @@ function shouldMaterializeChildDefault(member) {
   }
   return member.defaultValue !== void 0;
 }
-function shouldMaterializeConstructorChildDefault(member, isInitializer = isInitValueContent(member.defaultValue)) {
-  if (isInitializer) return true;
-  if (!isRequiredMember(member)) return false;
-  return shouldMaterializeChildDefault(member);
-}
 function skipProvidedConstructorSchemaKey(constructorRoot, schemaKey, member, defaultSettlesConstruction2, isInitializer = isInitValueContent(member.defaultValue)) {
   if (constructorRoot === void 0) return false;
   if (!constructorRoot.providedSchemaKeys.has(schemaKey)) return false;
@@ -12404,16 +12397,11 @@ function skipProvidedConstructorSchemaKey(constructorRoot, schemaKey, member, de
   }
   return !isInitializer && !defaultSettlesConstruction2;
 }
-function shouldMaterializeChildDefaultForRoot(constructorRoot, member, defaultSettlesConstruction2, isInitializer = isInitValueContent(member.defaultValue)) {
-  if (constructorRoot === void 0)
-    return shouldMaterializeChildDefault(member);
-  if (constructorRoot.omitMissingRequired === true && !defaultSettlesConstruction2) {
+function shouldMaterializeChildDefaultForRoot(constructorRoot, member, defaultSettlesConstruction2) {
+  if (constructorRoot?.omitMissingRequired === true && !defaultSettlesConstruction2) {
     return false;
   }
-  if (constructorRoot.runsMemberInitializers === true) {
-    return shouldMaterializeChildDefault(member);
-  }
-  return shouldMaterializeConstructorChildDefault(member, isInitializer);
+  return shouldMaterializeChildDefault(member);
 }
 function primitiveFallbackValue(document2, member) {
   if (isMemberBoolBase(member)) return { value: false };
@@ -13342,7 +13330,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;
@@ -16249,7 +16237,11 @@ function buildIndex(source) {
         }
         const placement = {
           valueId,
-          isNeoObject: kinds.get(row.classId) === NeoWorldSystemClassKind.Object,
+          isNeoObject: classInheritsWorldKind(
+            row.classId,
+            NeoWorldSystemClassKind.Object,
+            relations.classesById
+          ),
           classId: row.classId,
           gridId: root.id,
           layerId,
@@ -16980,6 +16972,7 @@ function makeUnindexedEvaluatorLookups(members, storedValues) {
     hasStoredValueId: (id) => valueById.has(id),
     unorderedListEntryIds: (containerValueId) => unorderedListMembership.get(containerValueId) ?? [],
     virtualInstanceRowsForValue: () => [],
+    virtualInstanceRootIdForValue: () => null,
     rowForValueReference: (value) => valueRefMap.get(value) ?? null
   };
 }
@@ -17163,6 +17156,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 ? {} : {
@@ -17280,6 +17274,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
@@ -17685,13 +17680,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") {
@@ -26499,12 +26496,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,
@@ -27369,7 +27361,7 @@ function evalVariantInitialize(info, scope, ctx) {
       scope,
       ctx
     );
-    stampInstanceVariantProvenance(instance, selection, ctx, true);
+    stampInstanceVariantProvenance(instance, selection, ctx);
     return instance;
   }
   const graph = resolveVariantGraph(selection, ctx);
@@ -27400,12 +27392,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) {
@@ -27417,12 +27413,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,
@@ -27431,13 +27427,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,
@@ -27447,17 +27448,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) {
@@ -27466,26 +27462,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(
@@ -27499,14 +27510,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;
@@ -27589,6 +27656,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) {
@@ -27629,7 +27697,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 {
@@ -28022,7 +28089,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),
@@ -28066,7 +28133,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)) {
@@ -28309,7 +28376,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,
@@ -32312,12 +32379,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) {
@@ -32340,7 +32402,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) {
@@ -32457,7 +32520,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
@@ -32487,6 +32555,7 @@ function buildVirtualInstanceMaterializedIndex(args) {
     })
   };
 }
+var KEPT_ROW_SAMPLE_LIMIT = 12;
 function derivesContentFromMemberDefault(args) {
   const member = args.member;
   if (!isMemberClassBase(member)) return false;
@@ -32639,6 +32708,8 @@ function expandStoredInstance(args) {
     instanceConstructorId: _instanceConstructorId,
     instanceVariantId: _instanceVariantId,
     instanceVariantRowValueId: _instanceVariantRowValueId,
+    instanceAppliedVariantId: _instanceAppliedVariantId,
+    instanceAppliedVariantRowValueId: _instanceAppliedVariantRowValueId,
     ...envelope
   } = instanceRoot;
   void _value;
@@ -32647,6 +32718,8 @@ function expandStoredInstance(args) {
   void _instanceConstructorId;
   void _instanceVariantId;
   void _instanceVariantRowValueId;
+  void _instanceAppliedVariantId;
+  void _instanceAppliedVariantRowValueId;
   const closedRootMember = closeClassArgumentsFromRowStamp(
     rootMember,
     instanceRoot
@@ -32728,11 +32801,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 {
@@ -32741,6 +32829,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;
@@ -33559,6 +33721,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;
@@ -33648,6 +33815,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;
@@ -33986,7 +34540,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 {
@@ -33997,10 +34553,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}".`);
@@ -34216,40 +34842,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) {
@@ -34261,6 +34884,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({
@@ -34304,10 +34949,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) {
@@ -34694,6 +35344,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) => {
@@ -34749,6 +35400,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
@@ -34871,6 +35525,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,
@@ -34941,10 +35596,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) {
@@ -34967,9 +35625,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
@@ -34977,17 +35638,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 ? {} : {
@@ -35061,6 +35718,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({
@@ -41305,7 +41963,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)}`,
@@ -53768,7 +54426,6 @@ var TILE_CLASS_LEVEL_KEYS = worldSystemSchemaFieldsForKind(
 ).flatMap(
   (field) => field.mutability === 1 /* ReadOnly */ ? [field.schemaKey] : []
 );
-var WORLD_PLACEMENT_ASSET_KIND = /* @__PURE__ */ new Map([[NeoWorldSystemClassKind.Object, NeoWorldSystemClassKind.Object]]);
 
 // ../src/database/general-function-call-ir-source-recompile.ts
 var VOID_ACTION_TYPE_INFO = {
@@ -58806,7 +59463,7 @@ var INITIALIZER_KEY_PLACEHOLDER = new RegExp(
 
 // ../packages/manifest/schema-contract/registry.mjs
 var PROJECT_SCHEMA_CONTRACT = Object.freeze({
-  cliVersion: "0.80.0",
+  cliVersion: "0.81.1",
   projectFileUploadBatchSize: 32,
   documentRecords: {
     member: {
@@ -60647,7 +61304,7 @@ var SCRIPT_COLLECTION_READERS = {
 };
 
 // ../src/models/exports/unity-codegen-revision.ts
-var UNITY_CODEGEN_REVISION = "edfd4061dffcd1a747b234cd135b99beca6f4cf1958cb69715029c5935dd7f1b";
+var UNITY_CODEGEN_REVISION = "d4026a3848848c8507d45dd54b6d31c1a0588b17b64c35e3fe9b25c89eb2fc05";
 
 // src/export-cache.ts
 var CACHE_BUILD = JSON.stringify([