@neocompose/cli 0.81.0 → 0.81.1

package/dist/test-worker.mjs

@@ -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
   )) {
@@ -11533,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) {
@@ -11871,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) {
@@ -12071,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,
@@ -12348,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)
     }
@@ -13329,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;
@@ -16971,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
   };
 }
@@ -17154,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 ? {} : {
@@ -17271,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
@@ -17676,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") {
@@ -26490,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,
@@ -27360,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);
@@ -27391,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) {
@@ -27408,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,
@@ -27422,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,
@@ -27438,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) {
@@ -27457,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(
@@ -27490,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;
@@ -27580,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) {
@@ -27620,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 {
@@ -28013,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),
@@ -28057,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)) {
@@ -28300,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,
@@ -32303,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) {
@@ -32331,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) {
@@ -32448,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
@@ -32478,6 +32555,7 @@ function buildVirtualInstanceMaterializedIndex(args) {
     })
   };
 }
+var KEPT_ROW_SAMPLE_LIMIT = 12;
 function derivesContentFromMemberDefault(args) {
   const member = args.member;
   if (!isMemberClassBase(member)) return false;
@@ -32630,6 +32708,8 @@ function expandStoredInstance(args) {
     instanceConstructorId: _instanceConstructorId,
     instanceVariantId: _instanceVariantId,
     instanceVariantRowValueId: _instanceVariantRowValueId,
+    instanceAppliedVariantId: _instanceAppliedVariantId,
+    instanceAppliedVariantRowValueId: _instanceAppliedVariantRowValueId,
     ...envelope
   } = instanceRoot;
   void _value;
@@ -32638,6 +32718,8 @@ function expandStoredInstance(args) {
   void _instanceConstructorId;
   void _instanceVariantId;
   void _instanceVariantRowValueId;
+  void _instanceAppliedVariantId;
+  void _instanceAppliedVariantRowValueId;
   const closedRootMember = closeClassArgumentsFromRowStamp(
     rootMember,
     instanceRoot
@@ -32719,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 {
@@ -32732,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;
@@ -33550,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;
@@ -33639,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;
@@ -33977,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 {
@@ -33988,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}".`);
@@ -34207,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) {
@@ -34252,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({
@@ -34295,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) {
@@ -34685,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) => {
@@ -34740,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
@@ -34862,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,
@@ -34932,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) {
@@ -34958,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
@@ -34968,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 ? {} : {
@@ -35052,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({
@@ -41296,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)}`,
@@ -58796,7 +59463,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.1",
   projectFileUploadBatchSize: 32,
   documentRecords: {
     member: {