@neocompose/cli 0.83.0 → 0.84.1

package/dist/neo-runtime.mjs

@@ -8152,6 +8152,35 @@ var init_world_system_classes_generated = __esm({
             ],
             dispatch: 0 /* Synchronous */,
             schemaKey: "TryConvert"
+          },
+          {
+            memberId: "system_a92b0911-8e7e-48ef-a12e-f3c55c33f64b",
+            memberKind: "function",
+            docsText: "The nearest tile grid that owns this tile, or null when no grid owns it or that grid is not a T. A tile in an object's tile layer answers with the object's grid.",
+            returnTypeInfo: {
+              type: 21,
+              required: false,
+              ownerMemberId: "system_a92b0911-8e7e-48ef-a12e-f3c55c33f64b",
+              index: 0
+            },
+            argumentTypes: [],
+            genericParams: [
+              {
+                name: "T",
+                constraint: {
+                  type: 7,
+                  required: true,
+                  classId: "system_b78f7f1d-f63c-4abb-ae65-852e69246534"
+                },
+                defaultType: {
+                  type: 7,
+                  required: true,
+                  classId: "system_b78f7f1d-f63c-4abb-ae65-852e69246534"
+                }
+              }
+            ],
+            dispatch: 0 /* Synchronous */,
+            schemaKey: "GetArea"
           }
         ],
         worldKind: "tile"
@@ -8199,6 +8228,35 @@ var init_world_system_classes_generated = __esm({
             docsText: "The object's box collider, or null for none. Any world object can carry one: placed objects, nested children, and sprites alike.",
             schemaClassWorldKind: "objectCollider",
             schemaKey: "Collider"
+          },
+          {
+            memberId: "system_7ad477e2-be5b-4892-b9ba-2a2f2476988d",
+            memberKind: "function",
+            docsText: "The nearest tile grid that owns this value, or null when no grid owns it or that grid is not a T. Nested children answer with their placed root's grid.",
+            returnTypeInfo: {
+              type: 21,
+              required: false,
+              ownerMemberId: "system_7ad477e2-be5b-4892-b9ba-2a2f2476988d",
+              index: 0
+            },
+            argumentTypes: [],
+            genericParams: [
+              {
+                name: "T",
+                constraint: {
+                  type: 7,
+                  required: true,
+                  classId: "system_b78f7f1d-f63c-4abb-ae65-852e69246534"
+                },
+                defaultType: {
+                  type: 7,
+                  required: true,
+                  classId: "system_b78f7f1d-f63c-4abb-ae65-852e69246534"
+                }
+              }
+            ],
+            dispatch: 0 /* Synchronous */,
+            schemaKey: "GetArea"
           }
         ],
         worldKind: "objectBase"
@@ -17529,7 +17587,7 @@ var init_registry = __esm({
   "../packages/manifest/schema-contract/registry.mjs"() {
     "use strict";
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
-      cliVersion: "0.83.0",
+      cliVersion: "0.84.1",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -22807,9 +22865,14 @@ function indexFirstById(values) {
   }
   return result;
 }
+function isDerivedNewValueId(valueId, isStored) {
+  return !isPendingId(valueId) && !isUuidV4Id(valueId) && !isStored(valueId);
+}
 var init_lower_support = __esm({
   "src/project-source/lower-support.ts"() {
     "use strict";
+    init_value_comparison();
+    init_pending_id();
     init_executable_parser();
   }
 });
@@ -32956,7 +33019,7 @@ var init_collection_query = __esm({
 });
 
 // ../packages/neoscript-language/src/cell-pattern.ts
-var NEO_CELL_PATTERN_CLASS_ID, NEO_CELL_PATTERN_CONSTRUCTOR_ID, NEO_CELL_PATTERN_MEMBER_IDS, NEO_OBJECT_GRID_MEMBER_IDS, NEO_CELL_PATTERN_PURE_NATIVE_MEMBER_IDS, NEO_OBJECT_CLASS_ID;
+var NEO_CELL_PATTERN_CLASS_ID, NEO_CELL_PATTERN_CONSTRUCTOR_ID, NEO_CELL_PATTERN_MEMBER_IDS, NEO_OBJECT_GRID_MEMBER_IDS, NEO_GET_AREA_MEMBER_IDS, NEO_CELL_PATTERN_PURE_NATIVE_MEMBER_IDS, NEO_OBJECT_CLASS_ID, NEO_TILE_GRID_CLASS_ID;
 var init_cell_pattern = __esm({
   "../packages/neoscript-language/src/cell-pattern.ts"() {
     "use strict";
@@ -32987,6 +33050,10 @@ var init_cell_pattern = __esm({
       GetTile: "system_593e6208-e2ca-505e-9933-04b17102b6d2",
       GetTiles: "system_5a41d36a-bcd9-4867-9e46-d743f6e09582"
     };
+    NEO_GET_AREA_MEMBER_IDS = {
+      NeoObjectBase: "system_7ad477e2-be5b-4892-b9ba-2a2f2476988d",
+      NeoTile: "system_a92b0911-8e7e-48ef-a12e-f3c55c33f64b"
+    };
     NEO_CELL_PATTERN_PURE_NATIVE_MEMBER_IDS = /* @__PURE__ */ new Set([
       NEO_CELL_PATTERN_MEMBER_IDS.Contains,
       NEO_CELL_PATTERN_MEMBER_IDS.Cells,
@@ -32996,6 +33063,7 @@ var init_cell_pattern = __esm({
       NEO_CELL_PATTERN_MEMBER_IDS.Union
     ]);
     NEO_OBJECT_CLASS_ID = "system_f671535d-0eb6-4139-9caf-5c5276febd31";
+    NEO_TILE_GRID_CLASS_ID = "system_b78f7f1d-f63c-4abb-ae65-852e69246534";
   }
 });
 
@@ -80192,39 +80260,26 @@ function isCenter(offset) {
   return offset.x === 0 && offset.y === 0;
 }
 function evaluateCellPatternNative(memberId, receiver, args, ctx) {
-  if (!NEO_CELL_PATTERN_PURE_NATIVE_MEMBER_IDS.has(memberId)) {
-    return { handled: false };
-  }
-  const pattern = (offsets2) => ({
-    handled: true,
-    value: ctx.constructPattern(offsets2)
-  });
   const offsets = ctx.readPattern(receiver);
   switch (memberId) {
     case NEO_CELL_PATTERN_MEMBER_IDS.Contains: {
       const offset = vector(args[0], "Contains offset");
-      return {
-        handled: true,
-        value: offsets.some(
-          (cell) => cell.x === offset.x && cell.y === offset.y
-        )
-      };
+      return offsets.some((cell) => cell.x === offset.x && cell.y === offset.y);
     }
     case NEO_CELL_PATTERN_MEMBER_IDS.Cells:
-      return {
-        handled: true,
-        value: translated(offsets, vector(args[0], "Cells origin"))
-      };
+      return translated(offsets, vector(args[0], "Cells origin"));
     case NEO_CELL_PATTERN_MEMBER_IDS.WithCenter:
-      if (offsets.some(isCenter)) return { handled: true, value: receiver };
-      return pattern([{ x: 0, y: 0 }, ...offsets]);
+      if (offsets.some(isCenter)) return receiver;
+      return ctx.constructPattern([{ x: 0, y: 0 }, ...offsets]);
     case NEO_CELL_PATTERN_MEMBER_IDS.WithoutCenter:
-      if (!offsets.some(isCenter)) return { handled: true, value: receiver };
-      return pattern(offsets.filter((offset) => !isCenter(offset)));
+      if (!offsets.some(isCenter)) return receiver;
+      return ctx.constructPattern(
+        offsets.filter((offset) => !isCenter(offset))
+      );
     case NEO_CELL_PATTERN_MEMBER_IDS.Translate: {
       const offset = vector(args[0], "Translate offset");
-      if (isCenter(offset)) return { handled: true, value: receiver };
-      return pattern(translated(offsets, offset));
+      if (isCenter(offset)) return receiver;
+      return ctx.constructPattern(translated(offsets, offset));
     }
     case NEO_CELL_PATTERN_MEMBER_IDS.Union: {
       const other = ctx.readPattern(args[0]);
@@ -80238,7 +80293,7 @@ function evaluateCellPatternNative(memberId, receiver, args, ctx) {
           result.push(offset);
         }
       }
-      return pattern(result);
+      return ctx.constructPattern(result);
     }
     default:
       throw new Error(
@@ -85846,6 +85901,21 @@ function evalCollectionMutationInstruction(ins, scope, ctx, options) {
       ctx
     );
   }
+  if (unorderedContainerValueId !== null && Array.isArray(targetValue)) {
+    const cache = unorderedListProjectionCache(ctx);
+    const appended = ins.mutation === "Add" /* Add */ && cache.writtenContainerIds.has(unorderedContainerValueId);
+    releaseWrittenUnorderedEntries(
+      unorderedContainerValueId,
+      unorderedEntriesBeforeMutation ?? [],
+      cache
+    );
+    trackWrittenUnorderedEntries(
+      unorderedContainerValueId,
+      targetValue,
+      appended ? targetValue.length - 1 : 0,
+      cache
+    );
+  }
   invalidateEvaluatorIndexes(ctx, targetValue);
   switch (ins.mutation) {
     case "Insert" /* Insert */:
@@ -86851,10 +86921,8 @@ function evalPointerCore(pointer, scope, ctx, resultUsage = "value") {
       if (member.kind === 13 /* Function */) {
         const systemResult = evaluateSystemNative(
           member.id,
-          innerThis,
-          args,
-          ctx,
-          typeArguments
+          { receiver: innerThis, args, typeArguments },
+          ctx
         );
         if (systemResult.handled) return systemResult.value;
         const hosted = ctx.unavailableNativeHandler?.({
@@ -87196,8 +87264,11 @@ function invokeDelegateValue(value, args, ctx, callSiteId, ownerReceiver, result
       if (member.kind === 13 /* Function */) {
         const systemResult = evaluateSystemNative(
           member.id,
-          receiver,
-          args,
+          {
+            receiver,
+            args,
+            typeArguments: calleeTypeArguments(void 0, member, ctx)
+          },
           ctx
         );
         if (systemResult.handled) return systemResult.value;
@@ -88704,6 +88775,8 @@ function createUnorderedListProjectionCache() {
   return {
     byContainerId: /* @__PURE__ */ new Map(),
     containerIdByArray: /* @__PURE__ */ new WeakMap(),
+    writtenContainerIds: /* @__PURE__ */ new Set(),
+    writtenEntryParents: /* @__PURE__ */ new Map(),
     scalarEntryIds: /* @__PURE__ */ new Set(),
     referenceEntryIndexesByArray: /* @__PURE__ */ new WeakMap(),
     referenceEntryKeysByRecord: /* @__PURE__ */ new WeakMap()
@@ -88764,9 +88837,27 @@ function invalidateUnorderedListProjection(containerValueId, ctx) {
   const projection = cache.byContainerId.get(containerValueId);
   if (projection === void 0) return;
   detachRemovedUnorderedScalarEntries(projection, [], ctx);
+  releaseWrittenUnorderedEntries(containerValueId, projection, cache);
   cache.byContainerId.delete(containerValueId);
+  cache.writtenContainerIds.delete(containerValueId);
   cache.containerIdByArray.delete(projection);
 }
+function trackWrittenUnorderedEntries(containerValueId, projection, start, cache, references = cache.referenceEntryIndexesByArray.get(projection)) {
+  cache.writtenContainerIds.add(containerValueId);
+  for (let index = start; index < projection.length; index++) {
+    const entry = projection[index];
+    if (typeof entry === "string" && references?.has(index) !== true) {
+      cache.writtenEntryParents.set(entry, containerValueId);
+    }
+  }
+}
+function releaseWrittenUnorderedEntries(containerValueId, entries, cache) {
+  for (const entry of entries) {
+    if (typeof entry === "string" && cache.writtenEntryParents.get(entry) === containerValueId) {
+      cache.writtenEntryParents.delete(entry);
+    }
+  }
+}
 function updateUnorderedListProjectionAfterAssignment(row, value, ctx) {
   invalidateUnorderedListProjection(row.id, ctx);
   const member = memberForValueRow(row, ctx);
@@ -88785,6 +88876,7 @@ function updateUnorderedListProjectionAfterAssignment(row, value, ctx) {
   }
   cache.byContainerId.set(row.id, projection);
   cache.containerIdByArray.set(projection, row.id);
+  trackWrittenUnorderedEntries(row.id, projection, 0, cache, referenceIndexes);
 }
 function evaluatorUnorderedListEntryIds(containerValueId, ctx) {
   ctx.containerDependencies?.add(containerValueId);
@@ -88937,7 +89029,8 @@ function resolveMemberForValueRow(row, ctx, visited) {
   ctx.onUnattributableValueRead?.(
     ownershipChainRead("member-owner-resolution", row.id)
   );
-  for (const link of evaluatorParentLinks(indexes4, row.id)) {
+  for (const link of evaluatorParentEdges(row, ctx, indexes4)) {
+    if ("memberId" in link) return evalMemberById(ctx.vm, link.memberId);
     const parent = evalValueById(
       ctx,
       link.parentId,
@@ -88960,6 +89053,93 @@ function resolveMemberForValueRow(row, ctx, visited) {
   }
   return null;
 }
+function* evaluatorParentEdges(row, ctx, indexes4) {
+  const cache = ctx.__unorderedListProjections;
+  const writtenParentId = cache?.writtenEntryParents.get(row.id);
+  if (writtenParentId !== void 0) {
+    yield { parentId: writtenParentId, key: "" };
+  }
+  const written = cache?.writtenContainerIds;
+  for (const link of indexes4.parentLinksByChildId.get(row.id) ?? []) {
+    if (written?.has(link.parentId) !== true) yield link;
+  }
+  const database = ctx.vm.databaseVM;
+  const documentContainerId = database?.evaluatorIndexes?.valueById.get(
+    row.id
+  )?.containerId;
+  const rewritten = indexes4.shadowedBaseRowIds.has(row.id);
+  const stale = (parentId) => written?.has(parentId) === true || indexes4.shadowedBaseRowIds.has(parentId) || row.containerId !== parentId && (documentContainerId === parentId || rewritten && database?.valueById(row.id)?.containerId === parentId);
+  const placement = database?.storedValuePlacementForValueId?.(row.id);
+  const placedParentId = placement?.parentValueId;
+  if (placement !== null && placement !== void 0 && typeof placedParentId === "string" && !stale(placedParentId)) {
+    yield { parentId: placedParentId, memberId: placement.memberId };
+  }
+  for (const link of indexes4.baseParentLinksByChildId?.get(row.id) ?? []) {
+    if (!stale(link.parentId)) yield link;
+  }
+}
+function currentUnorderedContainerId(row, ctx) {
+  const cache = ctx.__unorderedListProjections;
+  const writtenParentId = cache?.writtenEntryParents.get(row.id);
+  if (writtenParentId !== void 0) return writtenParentId;
+  const containerId = row.containerId;
+  if (typeof containerId !== "string") return void 0;
+  const released = cache?.writtenContainerIds.has(containerId) === true;
+  return released ? void 0 : containerId;
+}
+function firstOwnerEdge(row, ctx) {
+  const indexes4 = evaluatorIndexes(ctx);
+  const edge = evaluatorParentEdges(row, ctx, indexes4).next().value;
+  if (edge !== void 0) return edge;
+  const rows = ctx.vm.databaseVM?.virtualInstanceRowsForValue(row.id);
+  if (rows === void 0 || rows.length === 0) return void 0;
+  ensureVirtualExpansionIndexed(rows, ctx, indexes4);
+  return evaluatorParentEdges(row, ctx, indexes4).next().value;
+}
+function untrackedValueById(id2, ctx) {
+  if (ctx.__removedValueIds?.has(id2)) return null;
+  const local = ctx.__runtimeSessionValues?.get(id2) ?? ctx.__valueOverlay?.get(id2);
+  if (local !== void 0) return local;
+  const database = ctx.vm.databaseVM;
+  if (database !== void 0) return database.valueById(id2);
+  return ctx.vm.values.find((value) => value.id === id2) ?? null;
+}
+function placingMemberBinding(row, ctx) {
+  const direct = evaluatorIndexes(ctx).memberByValueId.get(row.id);
+  if (direct !== void 0) return direct;
+  const root = rootMemberForValueRow(row, ctx);
+  if (root !== null) return root;
+  const staticRoot = activeStaticBindingRoot(row.id, ctx);
+  if (staticRoot !== null) return staticRoot.member;
+  const placement = ctx.vm.databaseVM?.storedValuePlacementForValueId?.(row.id);
+  if (placement !== null && placement !== void 0) {
+    if (placement.parentValueId === null) {
+      return evalMemberById(ctx.vm, placement.memberId);
+    }
+  }
+  const syntheticMemberId = memberIdFromSyntheticDefaultValueId(row.id);
+  return syntheticMemberId === null ? null : evalMemberById(ctx.vm, syntheticMemberId);
+}
+function placingMember(row, ctx, ownerEdge, depth = 0) {
+  const bound = placingMemberBinding(row, ctx);
+  if (bound !== null) return bound;
+  const edge = ownerEdge ?? firstOwnerEdge(row, ctx);
+  if (edge === void 0) return null;
+  if ("memberId" in edge) return evalMemberById(ctx.vm, edge.memberId);
+  if (depth >= MAX_AREA_DEPTH) return null;
+  const parent = untrackedValueById(edge.parentId, ctx);
+  if (parent === null) return null;
+  const parentMember = parent.classId === void 0 ? placingMember(parent, ctx, void 0, depth + 1) : null;
+  if (parentMember !== null && isMemberWithEntries(parentMember)) {
+    return evalMemberById(ctx.vm, parentMember.entryMemberId);
+  }
+  const classId = parent.classId ?? (parentMember !== null && isClassTypedMember(parentMember) ? parentMember.classId : void 0);
+  return classId === void 0 ? null : memberForCustomSchemaValue(classId, edge.key, ctx);
+}
+function placedClassId(row, ctx, ownerEdge) {
+  const member = placingMember(row, ctx, ownerEdge);
+  return member !== null && isClassTypedMember(member) ? member.classId : void 0;
+}
 function worldGridQueryIndexForContext(context) {
   const ctx = withEvaluationRuntime(context, []);
   const vm = ctx.vm;
@@ -89176,107 +89356,74 @@ function gridQueryClassFilter(typeArgument, ctx) {
     );
   }
   const classId = typeArgument.classId;
-  if (classId === NEO_OBJECT_CLASS_ID || classId === NEO_TILE_CLASS_ID) {
+  if (classId === NEO_OBJECT_CLASS_ID || classId === NEO_TILE_CLASS_ID || classId === NEO_TILE_GRID_CLASS_ID) {
     return void 0;
   }
   const schema = evaluatorSchemaIndex(ctx);
   return (candidate) => schema.classIsOrExtends(candidate, classId);
 }
-function evaluateSystemNative(memberId, receiver, args, ctx, typeArguments) {
-  try {
-    if (memberId === NEO_OBJECT_GRID_MEMBER_IDS.GetCell || memberId === NEO_OBJECT_GRID_MEMBER_IDS.GetObjects || memberId === NEO_OBJECT_GRID_MEMBER_IDS.GetTile || memberId === NEO_OBJECT_GRID_MEMBER_IDS.GetTiles) {
-      const receiverRow = trackedRowForValueReference(receiver, ctx);
-      if (receiverRow === null) {
-        throw new NSGetterRuntimeError(
-          "Grid queries require a placed NeoObject receiver."
-        );
-      }
-      const index = worldGridQueryIndexForContext(ctx);
-      const placement = index.placement(
-        receiverRow.id,
-        ctx.worldQueryDependencies
-      );
-      if (memberId === NEO_OBJECT_GRID_MEMBER_IDS.GetCell)
-        return { handled: true, value: { ...placement.cell } };
-      const offsets = readCellPattern(args[0], ctx);
-      const shift = readGridQueryOffset(args[1]);
-      const accepts = gridQueryClassFilter(typeArguments?.[0], ctx);
-      if (memberId === NEO_OBJECT_GRID_MEMBER_IDS.GetObjects) {
-        const value = index.objects(
-          placement,
-          offsets,
-          ctx.worldQueryDependencies,
-          shift,
-          accepts
-        );
-        return { handled: true, value: referenceEntryList(value, ctx) };
-      }
-      if (memberId === NEO_OBJECT_GRID_MEMBER_IDS.GetTiles) {
-        const value = index.tiles(
-          placement,
-          offsets,
-          ctx.worldQueryDependencies,
-          shift,
-          accepts
-        );
-        return { handled: true, value: referenceEntryList(value, ctx) };
-      }
-      const tile = index.tile(
-        placement,
-        offsets,
-        ctx.worldQueryDependencies,
-        shift,
-        accepts
-      );
-      if (tile === null) return { handled: true, value: null };
-      const row = evalValueById(
-        ctx,
-        tile.placementValueId,
-        ctx.__runtimeSessionValues,
-        ctx.__valueOverlay
-      );
-      if (row === null) {
-        throw new NSGetterRuntimeError(
-          `Tile placement '${tile.placementValueId}' is missing.`
-        );
-      }
-      return { handled: true, value: readRowValue(row, ctx) };
-    }
-    return evaluateCellPatternNative(memberId, receiver, args, {
-      readPattern: (value) => readCellPattern(value, ctx),
-      constructPattern: (offsets) => constructDeclaredClassValue(
-        {
-          schemaClassInfo: {
-            type: 7 /* Class */,
-            required: true,
-            classId: NEO_CELL_PATTERN_CLASS_ID
-          },
-          constructorId: NEO_CELL_PATTERN_CONSTRUCTOR_ID,
-          args: [
-            {
-              name: "offsets",
-              valuePointer: {
-                type: "value" /* value */,
-                value: {
-                  typeInfo: {
-                    type: 6 /* List */,
-                    required: true,
-                    entryTypeInfo: {
-                      type: 15 /* Vector2Int */,
-                      required: true
-                    }
-                  },
-                  value: offsets
-                }
+function gridQueryPlacement(receiver, ctx) {
+  const receiverRow = trackedRowForValueReference(receiver, ctx);
+  if (receiverRow === null) {
+    throw new NSGetterRuntimeError(
+      "Grid queries require a placed NeoObject receiver."
+    );
+  }
+  const index = worldGridQueryIndexForContext(ctx);
+  return {
+    index,
+    placement: index.placement(receiverRow.id, ctx.worldQueryDependencies)
+  };
+}
+function gridQueryArguments(call, ctx) {
+  return {
+    offsets: readCellPattern(call.args[0], ctx),
+    shift: readGridQueryOffset(call.args[1]),
+    accepts: gridQueryClassFilter(call.typeArguments?.[0], ctx)
+  };
+}
+function cellPatternNative(memberId) {
+  return (call, ctx) => evaluateCellPatternNative(memberId, call.receiver, call.args, {
+    readPattern: (value) => readCellPattern(value, ctx),
+    constructPattern: (offsets) => constructDeclaredClassValue(
+      {
+        schemaClassInfo: {
+          type: 7 /* Class */,
+          required: true,
+          classId: NEO_CELL_PATTERN_CLASS_ID
+        },
+        constructorId: NEO_CELL_PATTERN_CONSTRUCTOR_ID,
+        args: [
+          {
+            name: "offsets",
+            valuePointer: {
+              type: "value" /* value */,
+              value: {
+                typeInfo: {
+                  type: 6 /* List */,
+                  required: true,
+                  entryTypeInfo: {
+                    type: 15 /* Vector2Int */,
+                    required: true
+                  }
+                },
+                value: offsets
               }
             }
-          ],
-          fields: []
-        },
-        createTopLevelScope(ctx),
-        ctx
-      )
-    });
+          }
+        ],
+        fields: []
+      },
+      createTopLevelScope(ctx),
+      ctx
+    )
+  });
+}
+function evaluateSystemNative(memberId, call, ctx) {
+  const handler = SYSTEM_NATIVE_HANDLERS.get(memberId);
+  if (handler === void 0) return { handled: false };
+  try {
+    return { handled: true, value: handler(call, ctx) };
   } catch (error) {
     if (error instanceof RangeError || error instanceof TypeError || error instanceof WorldGridQueryError) {
       throw new NSGetterRuntimeError(error.message, { cause: error });
@@ -93506,10 +93653,11 @@ function currentOwnedValueAttachments(valueId, ctx) {
     ctx.__runtimeSessionValues,
     ctx.__valueOverlay
   );
-  if (typeof row?.containerId === "string") {
+  const containerId = row === null ? void 0 : currentUnorderedContainerId(row, ctx);
+  if (containerId !== void 0) {
     add({
-      identity: `value:${row.containerId}:unordered-entry:${valueId}`,
-      label: row.containerId
+      identity: `value:${containerId}:unordered-entry:${valueId}`,
+      label: containerId
     });
   }
   const activeStaticRoot = activeStaticBindingRoot(valueId, ctx);
@@ -94889,7 +95037,7 @@ function recordWrittenEntry(collection, key, reference2, ctx) {
   if (reference2) keys.add(String(key));
   else keys.delete(String(key));
 }
-var DELEGATE_LEXICAL_THIS, DELEGATE_LEXICAL_ROOT, DELEGATE_LEXICAL_TYPE_ARGUMENTS, NonCatchableNSGetterRuntimeError, NativeFunctionDelegateUnavailableError, CorruptNeoScriptIRError, NeoScriptWallClockTimeoutError, liveListIndexesByProject, evaluatorOwnershipCachesByBase, MAX_CONSTRUCTION_DEPTH, resolutionCacheByMembers, NO_SCHEMA_REVISION, NO_INTERFACES2, LazyValueOverlay, READONLY_FOREACH_BINDING_ERROR, READONLY_CATCH_BINDING_ERROR, DIALOGUE_CONTEXT_PARAMETER_ID, STRING_TYPE_INFO, INT_TYPE_INFO, STORE_LIFETIME, STORE_NAMES, FORWARDING_TYPE_ARGUMENTS, constantDeclarationRoots, UNKNOWN_LOOKUP_TARGET, NS_MATH_OP_NAMES, DOUBLE_INTEGRAL_MAGNITUDE, EMPTY_SUPPLIED_CONSTRUCTOR_FIELDS, variantResolutionCopiesByOverlay, NO_BOUND_MEMBERS, NO_GENERIC_ENV;
+var DELEGATE_LEXICAL_THIS, DELEGATE_LEXICAL_ROOT, DELEGATE_LEXICAL_TYPE_ARGUMENTS, NonCatchableNSGetterRuntimeError, NativeFunctionDelegateUnavailableError, CorruptNeoScriptIRError, NeoScriptWallClockTimeoutError, liveListIndexesByProject, evaluatorOwnershipCachesByBase, MAX_CONSTRUCTION_DEPTH, resolutionCacheByMembers, NO_SCHEMA_REVISION, NO_INTERFACES2, LazyValueOverlay, READONLY_FOREACH_BINDING_ERROR, READONLY_CATCH_BINDING_ERROR, DIALOGUE_CONTEXT_PARAMETER_ID, STRING_TYPE_INFO, INT_TYPE_INFO, STORE_LIFETIME, STORE_NAMES, FORWARDING_TYPE_ARGUMENTS, constantDeclarationRoots, UNKNOWN_LOOKUP_TARGET, MAX_AREA_DEPTH, getAreaNative, SYSTEM_NATIVE_HANDLERS, NS_MATH_OP_NAMES, DOUBLE_INTEGRAL_MAGNITUDE, EMPTY_SUPPLIED_CONSTRUCTOR_FIELDS, variantResolutionCopiesByOverlay, NO_BOUND_MEMBERS, NO_GENERIC_ENV;
 var init_evaluateNSGetter = __esm({
   "../packages/neoscript-runtime/src/neoscript/evaluateNSGetter.ts"() {
     "use strict";
@@ -95112,6 +95260,121 @@ var init_evaluateNSGetter = __esm({
       type: NS_TYPE_UNKNOWN,
       required: true
     };
+    MAX_AREA_DEPTH = 256;
+    getAreaNative = (call, ctx) => {
+      const receiver = trackedRowForValueReference(call.receiver, ctx);
+      let row = receiver === null ? null : evalValueById(
+        ctx,
+        receiver.id,
+        ctx.__runtimeSessionValues,
+        ctx.__valueOverlay
+      );
+      const schema = evaluatorSchemaIndex(ctx);
+      for (let depth = 0; row !== null && depth < MAX_AREA_DEPTH; depth++) {
+        let edge;
+        if (!Array.isArray(row.value)) {
+          let classId = row.classId ?? void 0;
+          if (classId === void 0) {
+            edge = firstOwnerEdge(row, ctx);
+            classId = placedClassId(row, ctx, edge);
+          }
+          if (classId !== void 0 && schema.classIsOrExtends(classId, NEO_TILE_GRID_CLASS_ID)) {
+            const accepts = gridQueryClassFilter(call.typeArguments?.[0], ctx);
+            return accepts === void 0 || accepts(classId) ? readRowValue(row, ctx) : null;
+          }
+        }
+        const parentId = (edge ?? firstOwnerEdge(row, ctx))?.parentId;
+        if (parentId === void 0) {
+          if (placingMemberBinding(row, ctx) === null) {
+            ctx.onUnattributableValueRead?.(
+              ownershipChainRead("owned-value-parents", row.id)
+            );
+          }
+          return null;
+        }
+        row = currentUnorderedContainerId(row, ctx) === parentId ? untrackedValueById(parentId, ctx) : evalValueById(
+          ctx,
+          parentId,
+          ctx.__runtimeSessionValues,
+          ctx.__valueOverlay
+        );
+      }
+      return null;
+    };
+    SYSTEM_NATIVE_HANDLERS = new Map([
+      [
+        NEO_OBJECT_GRID_MEMBER_IDS.GetCell,
+        (call, ctx) => ({
+          ...gridQueryPlacement(call.receiver, ctx).placement.cell
+        })
+      ],
+      [
+        NEO_OBJECT_GRID_MEMBER_IDS.GetObjects,
+        (call, ctx) => {
+          const { index, placement } = gridQueryPlacement(call.receiver, ctx);
+          const { offsets, shift, accepts } = gridQueryArguments(call, ctx);
+          return referenceEntryList(
+            index.objects(
+              placement,
+              offsets,
+              ctx.worldQueryDependencies,
+              shift,
+              accepts
+            ),
+            ctx
+          );
+        }
+      ],
+      [
+        NEO_OBJECT_GRID_MEMBER_IDS.GetTiles,
+        (call, ctx) => {
+          const { index, placement } = gridQueryPlacement(call.receiver, ctx);
+          const { offsets, shift, accepts } = gridQueryArguments(call, ctx);
+          return referenceEntryList(
+            index.tiles(
+              placement,
+              offsets,
+              ctx.worldQueryDependencies,
+              shift,
+              accepts
+            ),
+            ctx
+          );
+        }
+      ],
+      [
+        NEO_OBJECT_GRID_MEMBER_IDS.GetTile,
+        (call, ctx) => {
+          const { index, placement } = gridQueryPlacement(call.receiver, ctx);
+          const { offsets, shift, accepts } = gridQueryArguments(call, ctx);
+          const tile = index.tile(
+            placement,
+            offsets,
+            ctx.worldQueryDependencies,
+            shift,
+            accepts
+          );
+          if (tile === null) return null;
+          const row = evalValueById(
+            ctx,
+            tile.placementValueId,
+            ctx.__runtimeSessionValues,
+            ctx.__valueOverlay
+          );
+          if (row === null) {
+            throw new NSGetterRuntimeError(
+              `Tile placement '${tile.placementValueId}' is missing.`
+            );
+          }
+          return readRowValue(row, ctx);
+        }
+      ],
+      [NEO_GET_AREA_MEMBER_IDS.NeoObjectBase, getAreaNative],
+      [NEO_GET_AREA_MEMBER_IDS.NeoTile, getAreaNative],
+      ...[...NEO_CELL_PATTERN_PURE_NATIVE_MEMBER_IDS].map(
+        (id2) => [id2, cellPatternNative(id2)]
+      )
+    ]);
     NS_MATH_OP_NAMES = {
       min: "Min",
       max: "Max",
@@ -96585,6 +96848,356 @@ var init_stored_value_placement_index = __esm({
   }
 });
 
+// ../packages/neoscript-runtime/src/values/initializer-identifiers.ts
+function initializerReferencedIdentifiers(source) {
+  let expression;
+  try {
+    expression = parseExpression(source);
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+  const identifiers = /* @__PURE__ */ new Set();
+  const pending = [expression];
+  const visited = /* @__PURE__ */ new Set();
+  while (pending.length > 0) {
+    const value = pending.pop();
+    if (value === null || typeof value !== "object" || visited.has(value)) {
+      continue;
+    }
+    visited.add(value);
+    if (Reflect.get(value, "kind") === "ident") {
+      const name = Reflect.get(value, "name");
+      if (typeof name === "string") identifiers.add(name);
+    }
+    for (const child2 of Object.values(value)) pending.push(child2);
+  }
+  return identifiers;
+}
+function initializerReferencesAnyIdentifier(source, names) {
+  const identifiers = initializerReferencedIdentifiers(source);
+  for (const name of names) {
+    if (identifiers.has(name)) return true;
+  }
+  return false;
+}
+var init_initializer_identifiers = __esm({
+  "../packages/neoscript-runtime/src/values/initializer-identifiers.ts"() {
+    "use strict";
+    init_executable_parser();
+  }
+});
+
+// ../packages/neoscript-runtime/src/initializer-materialization.ts
+function declarationInitializerContext(document) {
+  const key = initializerEvaluatorCacheKey(document);
+  const revision = initializerEvaluatorCacheRevision(document);
+  const cached = declarationInitializerContextByDocument.get(key);
+  if (cached !== void 0 && (revision === void 0 ? cached.members === document.members && cached.values === document.values : cached.revision === revision)) {
+    return cached.context;
+  }
+  const initializerValueIds = new Set(
+    document.values.filter(isInitValueContent).map((value) => value.id)
+  );
+  const valuesById = new Map(
+    document.values.map((value) => [value.id, value])
+  );
+  const rootOwners = /* @__PURE__ */ new Map();
+  resolveOwnerMembersForValues(
+    document,
+    initializerValueIds,
+    void 0,
+    rootOwners
+  );
+  const created = { valuesById, rootOwners };
+  declarationInitializerContextByDocument.set(key, {
+    members: document.members,
+    values: document.values,
+    revision,
+    context: created
+  });
+  return created;
+}
+function evaluateInitializerMaterialization(args) {
+  const createdValues = [];
+  const storageKeyDeclarations = /* @__PURE__ */ new Map();
+  const evaluated = args.evaluateInitializer({
+    genericEnv: args.genericEnv,
+    init: args.init,
+    member: args.member,
+    document: args.document,
+    createdValues,
+    storageKeyDeclarations,
+    ...args.storedConstructionReplay === true ? { storedConstructionReplay: true } : {},
+    ...args.constructionBaselineReplay === true ? { constructionBaselineReplay: true } : {},
+    ...args.argumentValues === void 0 ? {} : { argumentValues: args.argumentValues },
+    sourceValueId: args.sourceValueId ?? null,
+    readTracking: args.readTracking,
+    saveStaticBindings: args.saveStaticBindings,
+    sessionStaticBindings: args.sessionStaticBindings
+  });
+  return { evaluated, createdValues, storageKeyDeclarations };
+}
+function materializeInPlaceFields(document, root, createdValues) {
+  const owners = [root, ...createdValues];
+  for (const owner of owners) {
+    const record7 = owner.value;
+    if (typeof owner.classId !== "string") continue;
+    if (typeof record7 !== "object" || record7 === null) continue;
+    if (Array.isArray(record7)) continue;
+    let memberIds;
+    for (const [schemaKey, value] of Object.entries(record7)) {
+      if (typeof value === "string" || value === null) continue;
+      memberIds ??= new Map(
+        resolvedClassSchema(
+          owner.classId,
+          document.classes,
+          document.members
+        ).surface.map((entry) => [entry.schemaKey, entry.memberId])
+      );
+      const memberId = memberIds.get(schemaKey);
+      if (memberId === void 0) {
+        throw new Error(
+          `Class "${owner.classId}" holds "${schemaKey}" in place, which its schema doesn't declare.`
+        );
+      }
+      const row = {
+        id: virtualValueId(owner.id, memberId),
+        projectId: owner.projectId,
+        createdAt: owner.createdAt,
+        updatedAt: owner.updatedAt,
+        value
+      };
+      createdValues.push(row);
+      record7[schemaKey] = row.id;
+    }
+  }
+}
+function finalizeMaterializedRoot(args) {
+  materializeInPlaceFields(args.document, args.root, args.createdValues);
+  const allCreated = [args.root, ...args.createdValues];
+  for (const created of allCreated) {
+    if (created === args.root) continue;
+    if (created.classId === void 0) delete created.classId;
+  }
+  stampCreatedValuesMapKey(allCreated, args.mapKey);
+  if (args.supersededRootId !== void 0) {
+    args.storageKeyDeclarations.delete(args.supersededRootId);
+  }
+  args.storageKeyDeclarations.delete(args.root.id);
+  applyDeclaredStorageKeyOverrides({
+    createdValues: allCreated,
+    declarationByValueId: args.storageKeyDeclarations,
+    existingParentContextById: /* @__PURE__ */ new Map([
+      [
+        args.root.id,
+        {
+          mapKey: args.mapKey ?? null,
+          classId: args.root.classId ?? void 0
+        }
+      ]
+    ])
+  });
+}
+function materializeInitializerValue(args) {
+  const { evaluated, createdValues, storageKeyDeclarations } = evaluateInitializerMaterialization({
+    evaluateInitializer: args.evaluateInitializer,
+    init: args.row.init,
+    member: args.member,
+    document: args.document,
+    ...args.storedConstructionReplay === true ? { storedConstructionReplay: true } : {},
+    ...args.constructionBaselineReplay === true ? { constructionBaselineReplay: true } : {},
+    ...args.argumentValues === void 0 ? {} : { argumentValues: args.argumentValues },
+    genericEnv: envFromStamp(args.row.genericBindings),
+    sourceValueId: args.row.id,
+    readTracking: args.readTracking,
+    saveStaticBindings: args.saveStaticBindings,
+    sessionStaticBindings: args.sessionStaticBindings
+  });
+  const {
+    init: _init,
+    value: _value,
+    classId: _classId,
+    ...envelope
+  } = args.row;
+  void _init;
+  void _value;
+  void _classId;
+  const root = {
+    ...envelope,
+    value: evaluated.value,
+    ...evaluated.classId === null ? {} : { classId: evaluated.classId },
+    ...evaluated.genericBindings === void 0 ? {} : { genericBindings: { ...evaluated.genericBindings } },
+    ...deepClonePlainData(pickInstanceProvenance(evaluated))
+  };
+  if (evaluated.provisionalRootId !== void 0) {
+    args.document.listenerDefaultCapture?.retarget(
+      evaluated.provisionalRootId,
+      root.id
+    );
+    retargetInitializerRootValueIds(
+      [root, ...createdValues],
+      evaluated.provisionalRootId,
+      root.id
+    );
+  }
+  finalizeMaterializedRoot({
+    document: args.document,
+    root,
+    createdValues,
+    mapKey: args.row.mapKey,
+    storageKeyDeclarations
+  });
+  return {
+    root,
+    createdValues,
+    pinnedRootSchemaKeys: evaluated.pinnedRootSchemaKeys ?? /* @__PURE__ */ new Set(),
+    pinnedSchemaKeysByValueId: evaluated.pinnedSchemaKeysByValueId ?? /* @__PURE__ */ new Map()
+  };
+}
+function materializeMemberDefaultValue(args) {
+  const createdValues = [];
+  const storageKeyDeclarations = /* @__PURE__ */ new Map();
+  const declarationArguments = (member, init, sourceValueId) => {
+    const { valuesById, rootOwners } = declarationInitializerContext(
+      args.document
+    );
+    const ownerClass = typeof sourceValueId === "string" ? initializerOwnerContext(
+      args.document,
+      sourceValueId,
+      rootOwners,
+      valuesById,
+      (id2) => args.readTracking?.valueIds.add(id2)
+    ).ownerClass : typeof Reflect.get(member, "id") === "string" && !isStaticMember(member) ? findSchemaPlacement(
+      String(Reflect.get(member, "id")),
+      args.document.classes
+    )?.ownerClass ?? null : null;
+    if (ownerClass === null) return [];
+    const constructorId = ownerClass.requiredConstructorId;
+    if (typeof constructorId !== "string") return [];
+    const constructor2 = args.document.constructors?.find(
+      (candidate) => candidate.id === constructorId
+    );
+    if (constructor2 === void 0) return [];
+    const parameterNames = new Set(
+      constructor2.argumentTypes.map((argument2) => argument2.name)
+    );
+    return declarationInitializerArgumentValues(
+      constructor2.argumentTypes,
+      `Declaration template on '${ownerClass.name}'`,
+      initializerReferencesAnyIdentifier(init.code, parameterNames)
+    );
+  };
+  let lookups;
+  const evaluatorLookups = () => lookups ??= args.initializerEvaluatorLookups(
+    args.document,
+    args.readTracking
+  );
+  const plans = args.readTracking !== void 0 && args.document.databaseVM === void 0 ? void 0 : args.defaultValuePlans(args.document);
+  const database = args.document.databaseVM;
+  const hostPlan = database?.materializationPlan;
+  const built = buildDefaultMemberValue({
+    document: {
+      ...args.document,
+      // The declaration rows a default clones are reads of this
+      // materialization, like any row its initializers read.
+      valueById: (id2) => {
+        args.readTracking?.valueIds.add(id2);
+        const database2 = evaluatorLookups();
+        return database2.defaultValueById !== void 0 ? database2.defaultValueById(id2) : database2.valueById(id2);
+      },
+      unorderedListEntryIds: (containerId) => {
+        args.readTracking?.containerIds.add(containerId);
+        const entryIds = evaluatorLookups().unorderedListEntryIds?.(containerId);
+        if (entryIds === void 0) {
+          throw new Error(
+            `Initializer lookups resolve no unordered-list membership for container "${containerId}".`
+          );
+        }
+        return entryIds;
+      },
+      // Not `resolvedMember`: its id-keyed cache would answer for the
+      // caller's rewritten copy of a member with the stored original.
+      ...plans === void 0 ? {} : {
+        instanceEnv: plans.instanceEnv,
+        storedInstanceMaterializationPlan: hostPlan === void 0 ? plans.storedInstanceMaterializationPlan : (classId, instanceEnv) => hostPlan.call(database, classId, instanceEnv)
+      },
+      recordPlanReads: (reads) => {
+        for (const id2 of reads.valueIds) args.readTracking?.valueIds.add(id2);
+        for (const id2 of reads.containerIds)
+          args.readTracking?.containerIds.add(id2);
+      }
+    },
+    projectId: args.envelope.projectId,
+    member: args.member,
+    createdValues,
+    storageKeyDeclarations,
+    declarationRoot: args.declarationRoot,
+    ...args.genericEnv === void 0 ? {} : { genericEnv: args.genericEnv },
+    // A declaration default may itself be init-backed one level down (P43 §2),
+    // and those nested initializers must evaluate against the same document.
+    initEvaluator: (member, init, sourceValueId, genericEnv) => args.evaluateInitializer({
+      genericEnv,
+      storageKeyDeclarations,
+      init,
+      member,
+      document: args.document,
+      createdValues,
+      storedConstructionReplay: true,
+      argumentValues: declarationArguments(
+        member,
+        init,
+        sourceValueId ?? null
+      ),
+      sourceValueId: sourceValueId ?? null,
+      readTracking: args.readTracking,
+      saveStaticBindings: args.saveStaticBindings,
+      sessionStaticBindings: args.sessionStaticBindings
+    })
+  });
+  const interior = createdValues.filter((created) => created.id !== built.id);
+  const root = {
+    ...args.envelope,
+    value: built.value,
+    ...built.changeListeners === void 0 ? {} : { changeListeners: built.changeListeners },
+    ...built.changeListenerEndpoints === void 0 ? {} : { changeListenerEndpoints: built.changeListenerEndpoints },
+    ...built.classId === void 0 ? {} : { classId: built.classId },
+    ...built.genericBindings == null ? {} : { genericBindings: { ...built.genericBindings } }
+  };
+  args.document.listenerDefaultCapture?.retarget(built.id, root.id);
+  retargetInitializerRootValueIds([root, ...interior], built.id, root.id);
+  finalizeMaterializedRoot({
+    document: args.document,
+    root,
+    createdValues: interior,
+    mapKey: args.envelope.mapKey,
+    storageKeyDeclarations,
+    supersededRootId: built.id
+  });
+  return {
+    root,
+    createdValues: interior,
+    pinnedRootSchemaKeys: /* @__PURE__ */ new Set(),
+    pinnedSchemaKeysByValueId: /* @__PURE__ */ new Map()
+  };
+}
+var declarationInitializerContextByDocument;
+var init_initializer_materialization = __esm({
+  "../packages/neoscript-runtime/src/initializer-materialization.ts"() {
+    "use strict";
+    init_deep_clone_plain_data();
+    init_members();
+    init_inheritance();
+    init_member_value_id();
+    init_instance_provenance();
+    init_generics();
+    init_evaluateNSGetter();
+    init_initializer_context();
+    init_value_row_owner_members();
+    init_initializer_identifiers();
+    declarationInitializerContextByDocument = /* @__PURE__ */ new WeakMap();
+  }
+});
+
 // ../packages/neoscript-runtime/src/declaration-default-source.ts
 function declarationDefaultSource(id2, stored, resolveGraph) {
   if (stored !== null && !isCollapseStampedInstanceRoot(stored)) return stored;
@@ -96599,6 +97212,37 @@ var init_declaration_default_source = __esm({
   }
 });
 
+// ../packages/neoscript-runtime/src/virtual-value-identity.ts
+function claimVirtualIdentity(args) {
+  if (args.fixedVirtualId !== void 0) {
+    args.claimedVirtualIds.set(args.fixedVirtualId, args.pathKey);
+    return {
+      sourceIdentity: args.rawSourceIdentity,
+      virtualId: args.fixedVirtualId
+    };
+  }
+  const valueId = (sourceIdentity4) => derivedVirtualValueId(args.instanceRootId, sourceIdentity4);
+  const derivedId = valueId(args.rawSourceIdentity);
+  const claimedPath = args.claimedVirtualIds.get(derivedId);
+  if (claimedPath === void 0 || claimedPath === args.pathKey) {
+    args.claimedVirtualIds.set(derivedId, args.pathKey);
+    return { sourceIdentity: args.rawSourceIdentity, virtualId: derivedId };
+  }
+  const sourceIdentity3 = `${args.rawSourceIdentity}:${args.pathKey}`;
+  const virtualId = valueId(sourceIdentity3);
+  args.claimedVirtualIds.set(virtualId, args.pathKey);
+  return { sourceIdentity: sourceIdentity3, virtualId };
+}
+function derivedVirtualValueId(instanceRootId, sourceIdentity3) {
+  return instanceRootId.startsWith("__pending__:") || hasPendingVirtualSourceIdentity(sourceIdentity3) ? pendingVirtualValueId(instanceRootId, sourceIdentity3) : virtualValueId(instanceRootId, sourceIdentity3);
+}
+var init_virtual_value_identity = __esm({
+  "../packages/neoscript-runtime/src/virtual-value-identity.ts"() {
+    "use strict";
+    init_member_value_id();
+  }
+});
+
 // ../packages/neoscript-runtime/src/listener-endpoint-projection.ts
 function projectListenerEndpoint(args) {
   const { descriptor } = args;
@@ -96628,7 +97272,7 @@ function projectListenerEndpoint(args) {
 var init_listener_endpoint_projection = __esm({
   "../packages/neoscript-runtime/src/listener-endpoint-projection.ts"() {
     "use strict";
-    init_virtual_instance_graph();
+    init_virtual_value_identity();
   }
 });
 
@@ -96783,29 +97427,6 @@ function projectNestedListenerEndpoint(id2, descriptor, sourceRoot, targetRoot)
     return derive(targetRoot, positional);
   return void 0;
 }
-function claimVirtualIdentity(args) {
-  if (args.fixedVirtualId !== void 0) {
-    args.claimedVirtualIds.set(args.fixedVirtualId, args.pathKey);
-    return {
-      sourceIdentity: args.rawSourceIdentity,
-      virtualId: args.fixedVirtualId
-    };
-  }
-  const valueId = (sourceIdentity4) => derivedVirtualValueId(args.instanceRootId, sourceIdentity4);
-  const derivedId = valueId(args.rawSourceIdentity);
-  const claimedPath = args.claimedVirtualIds.get(derivedId);
-  if (claimedPath === void 0 || claimedPath === args.pathKey) {
-    args.claimedVirtualIds.set(derivedId, args.pathKey);
-    return { sourceIdentity: args.rawSourceIdentity, virtualId: derivedId };
-  }
-  const sourceIdentity3 = `${args.rawSourceIdentity}:${args.pathKey}`;
-  const virtualId = valueId(sourceIdentity3);
-  args.claimedVirtualIds.set(virtualId, args.pathKey);
-  return { sourceIdentity: sourceIdentity3, virtualId };
-}
-function derivedVirtualValueId(instanceRootId, sourceIdentity3) {
-  return instanceRootId.startsWith("__pending__:") || hasPendingVirtualSourceIdentity(sourceIdentity3) ? pendingVirtualValueId(instanceRootId, sourceIdentity3) : virtualValueId(instanceRootId, sourceIdentity3);
-}
 function materializationReadTracking(recorder) {
   if (recorder === void 0)
     return { readTracking: void 0, trackMaterialization: (m) => m() };
@@ -96949,7 +97570,7 @@ function expandStoredInstance(args) {
       code: `virtual-replay:${args.instanceRoot.id}`
     });
     return trackMaterialization(
-      () => materializeInitializerValue({
+      () => args.materializeInitializerValue({
         evaluateInitializer: args.evaluateInitializer,
         document: args.document,
         member: replayMember,
@@ -96965,7 +97586,7 @@ function expandStoredInstance(args) {
   const replayDeclaredDefault = () => {
     const stampEnv = instanceRoot.genericBindings == null || Object.keys(instanceRoot.genericBindings).length === 0 ? null : envFromStamp(instanceRoot.genericBindings);
     const built = trackMaterialization(
-      () => materializeMemberDefaultValue({
+      () => args.materializeMemberDefaultValue({
         evaluateInitializer: args.evaluateInitializer,
         document: args.document,
         member: replayMember,
@@ -97958,6 +98579,8 @@ function resolveStoredInstanceGraphs(args) {
     if (isMaterializedSpine(resolvedLocations.get(next.root.id))) continue;
     const graph = isClassSlotMember(next.member) ? args.resolveClassGraph?.(next.root, next.member) ?? resolveStoredClassValue({
       evaluateInitializer: args.evaluateInitializer,
+      materializeInitializerValue: args.materializeInitializerValue,
+      materializeMemberDefaultValue: args.materializeMemberDefaultValue,
       document,
       instanceRoot: next.root,
       rootMember: next.member,
@@ -98054,7 +98677,7 @@ function expandStoredClassValue(args) {
     args.readRecorder
   );
   const materialized = trackMaterialization(
-    () => materializeMemberDefaultValue({
+    () => args.materializeMemberDefaultValue({
       ...readTracking === void 0 ? {} : { readTracking },
       saveStaticBindings: args.saveStaticBindings,
       sessionStaticBindings: args.sessionStaticBindings,
@@ -99791,6 +100414,8 @@ function resolveVariantInstanceGraphForDocument(args) {
   materializedById.set(args.priorInstanceRoot.id, args.priorInstanceRoot);
   const priorExpanded = expandStoredInstance({
     evaluateInitializer: args.evaluateInitializer,
+    materializeInitializerValue: args.materializeInitializerValue,
+    materializeMemberDefaultValue: args.materializeMemberDefaultValue,
     document,
     instanceRoot: args.priorInstanceRoot,
     rootMember,
@@ -99864,6 +100489,8 @@ function resolveVariantInstanceGraphForDocument(args) {
   materializedById.set(nextInstanceRoot.id, nextInstanceRoot);
   const nextExpanded = expandStoredInstance({
     evaluateInitializer: args.evaluateInitializer,
+    materializeInitializerValue: args.materializeInitializerValue,
+    materializeMemberDefaultValue: args.materializeMemberDefaultValue,
     document,
     instanceRoot: nextInstanceRoot,
     rootMember,
@@ -100990,6 +101617,8 @@ function createHeadlessVirtualInstanceResolver(args) {
           const replayDocument = evidence === null ? resolverDocumentOnce() : frameDocument(evidence);
           const resolution2 = prepareStoredClassValueResolution({
             evaluateInitializer: args.evaluateInitializer,
+            materializeInitializerValue: args.materializeInitializerValue,
+            materializeMemberDefaultValue: args.materializeMemberDefaultValue,
             document: replayDocument,
             instanceRoot,
             rootMember: member,
@@ -101284,7 +101913,8 @@ var init_virtual_instance_graph = __esm({
     init_immutable_json();
     init_members();
     init_instance_provenance();
-    init_member_value_id();
+    init_virtual_value_identity();
+    init_virtual_value_identity();
     init_stored_value_placement_index();
     init_unordered_list_membership();
     init_neoscript_types();
@@ -101292,7 +101922,6 @@ var init_virtual_instance_graph = __esm({
     init_project_schema_index();
     init_initializer_context();
     init_strict_ir();
-    init_initializer_materialization();
     init_unattributable_reads();
     init_member_body_reads();
     KEPT_ROW_SAMPLE_LIMIT = 12;
@@ -101526,6 +102155,8 @@ function initializerEvaluatorLookups(document, readTracking) {
   const shareFrom = document.evaluatorOverlay === void 0 ? void 0 : sharedHeadlessResolver(document.evaluatorOverlay);
   const headlessVirtualResolver = createHeadlessVirtualInstanceResolver({
     evaluateInitializer: evaluateMemberInitializer,
+    materializeInitializerValue,
+    materializeMemberDefaultValue: materializeMemberDefaultValue2,
     documentMaterializationPlan,
     document,
     resolverLookups: () => lookups,
@@ -101554,6 +102185,8 @@ function initializerEvaluatorLookups(document, readTracking) {
     // nested resolver.
     resolveVariantInstanceGraph: (args) => resolveVariantInstanceGraphForDocument({
       evaluateInitializer: evaluateMemberInitializer,
+      materializeInitializerValue,
+      materializeMemberDefaultValue: materializeMemberDefaultValue2,
       document,
       resolverLookups: lookups,
       readRecorder: headlessVirtualResolver.readRecorder,
@@ -101742,6 +102375,8 @@ function createInitializerMaterializationBatch(authoredDocument, pendingInitiali
       let resolver;
       const virtual = () => resolver ??= createHeadlessVirtualInstanceResolver({
         evaluateInitializer: evaluateMemberInitializer,
+        materializeInitializerValue,
+        materializeMemberDefaultValue: materializeMemberDefaultValue2,
         documentMaterializationPlan,
         document,
         membersById: indexed.membersById,
@@ -101824,6 +102459,8 @@ function createInitializerMaterializationBatch(authoredDocument, pendingInitiali
         virtualInstanceRootIdForValue: (id2) => owningInstanceRootId(virtual().virtualInstanceGraphForValue(id2)),
         resolveVariantInstanceGraph: (args) => resolveVariantInstanceGraphForDocument({
           evaluateInitializer: evaluateMemberInitializer,
+          materializeInitializerValue,
+          materializeMemberDefaultValue: materializeMemberDefaultValue2,
           document,
           resolverLookups: lookups,
           ...args
@@ -102057,10 +102694,18 @@ function storedConstructionReplaySlot(member, sourceRow, document) {
     }
   };
 }
+function materializeMemberDefaultValue2(args) {
+  return materializeMemberDefaultValue({
+    ...args,
+    initializerEvaluatorLookups,
+    defaultValuePlans
+  });
+}
 var evaluatorLookupsByDocument, headlessResolversByLookupKey, indexedEvaluatorLookupsByDocument, defaultValuePlansByDocument;
 var init_evaluateInitializer = __esm({
   "../packages/neoscript-runtime/src/neoscript/evaluateInitializer.ts"() {
     "use strict";
+    init_initializer_materialization();
     init_NSGetterRuntimeError();
     init_declaration_default_source();
     init_member_change_listeners();
@@ -102081,354 +102726,6 @@ var init_evaluateInitializer = __esm({
   }
 });
 
-// ../packages/neoscript-runtime/src/values/initializer-identifiers.ts
-function initializerReferencedIdentifiers(source) {
-  let expression;
-  try {
-    expression = parseExpression(source);
-  } catch {
-    return /* @__PURE__ */ new Set();
-  }
-  const identifiers = /* @__PURE__ */ new Set();
-  const pending = [expression];
-  const visited = /* @__PURE__ */ new Set();
-  while (pending.length > 0) {
-    const value = pending.pop();
-    if (value === null || typeof value !== "object" || visited.has(value)) {
-      continue;
-    }
-    visited.add(value);
-    if (Reflect.get(value, "kind") === "ident") {
-      const name = Reflect.get(value, "name");
-      if (typeof name === "string") identifiers.add(name);
-    }
-    for (const child2 of Object.values(value)) pending.push(child2);
-  }
-  return identifiers;
-}
-function initializerReferencesAnyIdentifier(source, names) {
-  const identifiers = initializerReferencedIdentifiers(source);
-  for (const name of names) {
-    if (identifiers.has(name)) return true;
-  }
-  return false;
-}
-var init_initializer_identifiers = __esm({
-  "../packages/neoscript-runtime/src/values/initializer-identifiers.ts"() {
-    "use strict";
-    init_executable_parser();
-  }
-});
-
-// ../packages/neoscript-runtime/src/initializer-materialization.ts
-function declarationInitializerContext(document) {
-  const key = initializerEvaluatorCacheKey(document);
-  const revision = initializerEvaluatorCacheRevision(document);
-  const cached = declarationInitializerContextByDocument.get(key);
-  if (cached !== void 0 && (revision === void 0 ? cached.members === document.members && cached.values === document.values : cached.revision === revision)) {
-    return cached.context;
-  }
-  const initializerValueIds = new Set(
-    document.values.filter(isInitValueContent).map((value) => value.id)
-  );
-  const valuesById = new Map(
-    document.values.map((value) => [value.id, value])
-  );
-  const rootOwners = /* @__PURE__ */ new Map();
-  resolveOwnerMembersForValues(
-    document,
-    initializerValueIds,
-    void 0,
-    rootOwners
-  );
-  const created = { valuesById, rootOwners };
-  declarationInitializerContextByDocument.set(key, {
-    members: document.members,
-    values: document.values,
-    revision,
-    context: created
-  });
-  return created;
-}
-function evaluateInitializerMaterialization(args) {
-  const createdValues = [];
-  const storageKeyDeclarations = /* @__PURE__ */ new Map();
-  const evaluated = args.evaluateInitializer({
-    genericEnv: args.genericEnv,
-    init: args.init,
-    member: args.member,
-    document: args.document,
-    createdValues,
-    storageKeyDeclarations,
-    ...args.storedConstructionReplay === true ? { storedConstructionReplay: true } : {},
-    ...args.constructionBaselineReplay === true ? { constructionBaselineReplay: true } : {},
-    ...args.argumentValues === void 0 ? {} : { argumentValues: args.argumentValues },
-    sourceValueId: args.sourceValueId ?? null,
-    readTracking: args.readTracking,
-    saveStaticBindings: args.saveStaticBindings,
-    sessionStaticBindings: args.sessionStaticBindings
-  });
-  return { evaluated, createdValues, storageKeyDeclarations };
-}
-function materializeInPlaceFields(document, root, createdValues) {
-  const owners = [root, ...createdValues];
-  for (const owner of owners) {
-    const record7 = owner.value;
-    if (typeof owner.classId !== "string") continue;
-    if (typeof record7 !== "object" || record7 === null) continue;
-    if (Array.isArray(record7)) continue;
-    let memberIds;
-    for (const [schemaKey, value] of Object.entries(record7)) {
-      if (typeof value === "string" || value === null) continue;
-      memberIds ??= new Map(
-        resolvedClassSchema(
-          owner.classId,
-          document.classes,
-          document.members
-        ).surface.map((entry) => [entry.schemaKey, entry.memberId])
-      );
-      const memberId = memberIds.get(schemaKey);
-      if (memberId === void 0) {
-        throw new Error(
-          `Class "${owner.classId}" holds "${schemaKey}" in place, which its schema doesn't declare.`
-        );
-      }
-      const row = {
-        id: virtualValueId(owner.id, memberId),
-        projectId: owner.projectId,
-        createdAt: owner.createdAt,
-        updatedAt: owner.updatedAt,
-        value
-      };
-      createdValues.push(row);
-      record7[schemaKey] = row.id;
-    }
-  }
-}
-function finalizeMaterializedRoot(args) {
-  materializeInPlaceFields(args.document, args.root, args.createdValues);
-  const allCreated = [args.root, ...args.createdValues];
-  for (const created of allCreated) {
-    if (created === args.root) continue;
-    if (created.classId === void 0) delete created.classId;
-  }
-  stampCreatedValuesMapKey(allCreated, args.mapKey);
-  if (args.supersededRootId !== void 0) {
-    args.storageKeyDeclarations.delete(args.supersededRootId);
-  }
-  args.storageKeyDeclarations.delete(args.root.id);
-  applyDeclaredStorageKeyOverrides({
-    createdValues: allCreated,
-    declarationByValueId: args.storageKeyDeclarations,
-    existingParentContextById: /* @__PURE__ */ new Map([
-      [
-        args.root.id,
-        {
-          mapKey: args.mapKey ?? null,
-          classId: args.root.classId ?? void 0
-        }
-      ]
-    ])
-  });
-}
-function materializeInitializerValue(args) {
-  const { evaluated, createdValues, storageKeyDeclarations } = evaluateInitializerMaterialization({
-    evaluateInitializer: args.evaluateInitializer,
-    init: args.row.init,
-    member: args.member,
-    document: args.document,
-    ...args.storedConstructionReplay === true ? { storedConstructionReplay: true } : {},
-    ...args.constructionBaselineReplay === true ? { constructionBaselineReplay: true } : {},
-    ...args.argumentValues === void 0 ? {} : { argumentValues: args.argumentValues },
-    genericEnv: envFromStamp(args.row.genericBindings),
-    sourceValueId: args.row.id,
-    readTracking: args.readTracking,
-    saveStaticBindings: args.saveStaticBindings,
-    sessionStaticBindings: args.sessionStaticBindings
-  });
-  const {
-    init: _init,
-    value: _value,
-    classId: _classId,
-    ...envelope
-  } = args.row;
-  void _init;
-  void _value;
-  void _classId;
-  const root = {
-    ...envelope,
-    value: evaluated.value,
-    ...evaluated.classId === null ? {} : { classId: evaluated.classId },
-    ...evaluated.genericBindings === void 0 ? {} : { genericBindings: { ...evaluated.genericBindings } },
-    ...deepClonePlainData(pickInstanceProvenance(evaluated))
-  };
-  if (evaluated.provisionalRootId !== void 0) {
-    args.document.listenerDefaultCapture?.retarget(
-      evaluated.provisionalRootId,
-      root.id
-    );
-    retargetInitializerRootValueIds(
-      [root, ...createdValues],
-      evaluated.provisionalRootId,
-      root.id
-    );
-  }
-  finalizeMaterializedRoot({
-    document: args.document,
-    root,
-    createdValues,
-    mapKey: args.row.mapKey,
-    storageKeyDeclarations
-  });
-  return {
-    root,
-    createdValues,
-    pinnedRootSchemaKeys: evaluated.pinnedRootSchemaKeys ?? /* @__PURE__ */ new Set(),
-    pinnedSchemaKeysByValueId: evaluated.pinnedSchemaKeysByValueId ?? /* @__PURE__ */ new Map()
-  };
-}
-function materializeMemberDefaultValue(args) {
-  const createdValues = [];
-  const storageKeyDeclarations = /* @__PURE__ */ new Map();
-  const declarationArguments = (member, init, sourceValueId) => {
-    const { valuesById, rootOwners } = declarationInitializerContext(
-      args.document
-    );
-    const ownerClass = typeof sourceValueId === "string" ? initializerOwnerContext(
-      args.document,
-      sourceValueId,
-      rootOwners,
-      valuesById,
-      (id2) => args.readTracking?.valueIds.add(id2)
-    ).ownerClass : typeof Reflect.get(member, "id") === "string" && !isStaticMember(member) ? findSchemaPlacement(
-      String(Reflect.get(member, "id")),
-      args.document.classes
-    )?.ownerClass ?? null : null;
-    if (ownerClass === null) return [];
-    const constructorId = ownerClass.requiredConstructorId;
-    if (typeof constructorId !== "string") return [];
-    const constructor2 = args.document.constructors?.find(
-      (candidate) => candidate.id === constructorId
-    );
-    if (constructor2 === void 0) return [];
-    const parameterNames = new Set(
-      constructor2.argumentTypes.map((argument2) => argument2.name)
-    );
-    return declarationInitializerArgumentValues(
-      constructor2.argumentTypes,
-      `Declaration template on '${ownerClass.name}'`,
-      initializerReferencesAnyIdentifier(init.code, parameterNames)
-    );
-  };
-  let lookups;
-  const evaluatorLookups = () => lookups ??= initializerEvaluatorLookups(args.document, args.readTracking);
-  const plans = args.readTracking !== void 0 && args.document.databaseVM === void 0 ? void 0 : defaultValuePlans(args.document);
-  const database = args.document.databaseVM;
-  const hostPlan = database?.materializationPlan;
-  const built = buildDefaultMemberValue({
-    document: {
-      ...args.document,
-      // The declaration rows a default clones are reads of this
-      // materialization, like any row its initializers read.
-      valueById: (id2) => {
-        args.readTracking?.valueIds.add(id2);
-        const database2 = evaluatorLookups();
-        return database2.defaultValueById !== void 0 ? database2.defaultValueById(id2) : database2.valueById(id2);
-      },
-      unorderedListEntryIds: (containerId) => {
-        args.readTracking?.containerIds.add(containerId);
-        const entryIds = evaluatorLookups().unorderedListEntryIds?.(containerId);
-        if (entryIds === void 0) {
-          throw new Error(
-            `Initializer lookups resolve no unordered-list membership for container "${containerId}".`
-          );
-        }
-        return entryIds;
-      },
-      // Not `resolvedMember`: its id-keyed cache would answer for the
-      // caller's rewritten copy of a member with the stored original.
-      ...plans === void 0 ? {} : {
-        instanceEnv: plans.instanceEnv,
-        storedInstanceMaterializationPlan: hostPlan === void 0 ? plans.storedInstanceMaterializationPlan : (classId, instanceEnv) => hostPlan.call(database, classId, instanceEnv)
-      },
-      recordPlanReads: (reads) => {
-        for (const id2 of reads.valueIds) args.readTracking?.valueIds.add(id2);
-        for (const id2 of reads.containerIds)
-          args.readTracking?.containerIds.add(id2);
-      }
-    },
-    projectId: args.envelope.projectId,
-    member: args.member,
-    createdValues,
-    storageKeyDeclarations,
-    declarationRoot: args.declarationRoot,
-    ...args.genericEnv === void 0 ? {} : { genericEnv: args.genericEnv },
-    // A declaration default may itself be init-backed one level down (P43 §2),
-    // and those nested initializers must evaluate against the same document.
-    initEvaluator: (member, init, sourceValueId, genericEnv) => args.evaluateInitializer({
-      genericEnv,
-      storageKeyDeclarations,
-      init,
-      member,
-      document: args.document,
-      createdValues,
-      storedConstructionReplay: true,
-      argumentValues: declarationArguments(
-        member,
-        init,
-        sourceValueId ?? null
-      ),
-      sourceValueId: sourceValueId ?? null,
-      readTracking: args.readTracking,
-      saveStaticBindings: args.saveStaticBindings,
-      sessionStaticBindings: args.sessionStaticBindings
-    })
-  });
-  const interior = createdValues.filter((created) => created.id !== built.id);
-  const root = {
-    ...args.envelope,
-    value: built.value,
-    ...built.changeListeners === void 0 ? {} : { changeListeners: built.changeListeners },
-    ...built.changeListenerEndpoints === void 0 ? {} : { changeListenerEndpoints: built.changeListenerEndpoints },
-    ...built.classId === void 0 ? {} : { classId: built.classId },
-    ...built.genericBindings == null ? {} : { genericBindings: { ...built.genericBindings } }
-  };
-  args.document.listenerDefaultCapture?.retarget(built.id, root.id);
-  retargetInitializerRootValueIds([root, ...interior], built.id, root.id);
-  finalizeMaterializedRoot({
-    document: args.document,
-    root,
-    createdValues: interior,
-    mapKey: args.envelope.mapKey,
-    storageKeyDeclarations,
-    supersededRootId: built.id
-  });
-  return {
-    root,
-    createdValues: interior,
-    pinnedRootSchemaKeys: /* @__PURE__ */ new Set(),
-    pinnedSchemaKeysByValueId: /* @__PURE__ */ new Map()
-  };
-}
-var declarationInitializerContextByDocument;
-var init_initializer_materialization = __esm({
-  "../packages/neoscript-runtime/src/initializer-materialization.ts"() {
-    "use strict";
-    init_deep_clone_plain_data();
-    init_members();
-    init_inheritance();
-    init_member_value_id();
-    init_instance_provenance();
-    init_generics();
-    init_evaluateInitializer();
-    init_evaluateNSGetter();
-    init_initializer_context();
-    init_value_row_owner_members();
-    init_initializer_identifiers();
-    declarationInitializerContextByDocument = /* @__PURE__ */ new WeakMap();
-  }
-});
-
 // ../packages/neoscript-runtime/src/effective-value-reader.ts
 function rootReadScope(document) {
   const cached = rootReadScopes.get(document);
@@ -103071,7 +103368,7 @@ var init_effective_value_reader = __esm({
           });
           if (slot.kind !== "declaration") continue;
           if (record7 === row.value) record7 = { ...record7 };
-          const materialized = materializeMemberDefaultValue({
+          const materialized = materializeMemberDefaultValue2({
             ...this.context,
             evaluateInitializer: evaluateMemberInitializer,
             document: this.declarationDocument,
@@ -103148,6 +103445,8 @@ var init_effective_value_reader = __esm({
           instanceRoot: root,
           rootMember: placement,
           evaluateInitializer: evaluateMemberInitializer,
+          materializeInitializerValue,
+          materializeMemberDefaultValue: materializeMemberDefaultValue2,
           materializedIndex: this.materializedIndex,
           resolveClassGraph: this.context.readTracking === void 0 && this.context.saveStaticBindings === void 0 && this.context.sessionStaticBindings === void 0 ? (root2, member) => initializerStoredClassGraph(this.readDocument, root2.id, member) : void 0,
           onResolvedListenerDefaults: (ownerId, entry) => {
@@ -103192,7 +103491,7 @@ var init_effective_value_reader = __esm({
         const cached = this.defaultRows.get(memberKey)?.get(envKey);
         if (cached !== void 0) return cached;
         let evaluatedInitializer = false;
-        const result = materializeMemberDefaultValue({
+        const result = materializeMemberDefaultValue2({
           ...this.context,
           evaluateInitializer: (args) => {
             evaluatedInitializer = true;
@@ -103456,31 +103755,40 @@ var init_neoscript2 = __esm({
 function expandStoredInstance2(args) {
   return expandStoredInstance({
     ...args,
-    evaluateInitializer: evaluateMemberInitializer
+    evaluateInitializer: evaluateMemberInitializer,
+    materializeInitializerValue,
+    materializeMemberDefaultValue: materializeMemberDefaultValue2
   });
 }
 function resolveVariantInstanceGraphForDocument2(args) {
   return resolveVariantInstanceGraphForDocument({
     ...args,
-    evaluateInitializer: evaluateMemberInitializer
+    evaluateInitializer: evaluateMemberInitializer,
+    materializeInitializerValue,
+    materializeMemberDefaultValue: materializeMemberDefaultValue2
   });
 }
 function createHeadlessVirtualInstanceResolver2(args) {
   return createHeadlessVirtualInstanceResolver({
     ...args,
     evaluateInitializer: evaluateMemberInitializer,
+    materializeInitializerValue,
+    materializeMemberDefaultValue: materializeMemberDefaultValue2,
     documentMaterializationPlan
   });
 }
 function resolveStoredClassValue2(args) {
   return resolveStoredClassValue({
     ...args,
-    evaluateInitializer: evaluateMemberInitializer
+    evaluateInitializer: evaluateMemberInitializer,
+    materializeInitializerValue,
+    materializeMemberDefaultValue: materializeMemberDefaultValue2
   });
 }
 var init_virtual_instance_values = __esm({
   "../packages/neoscript-runtime/src/virtual-instance-values.ts"() {
     "use strict";
+    init_initializer_materialization();
     init_evaluateInitializer();
     init_virtual_instance_graph();
     init_virtual_instance_graph();
@@ -126565,11 +126873,10 @@ function appendAuthoredOwnedValueCascadeDeletes(args) {
     for (const rootId of survivingConstructionIds) {
       const instanceRoot = compiledReplayRows.get(rootId) ?? postValuesById.get(rootId);
       const rootMember = postPlacements.get(rootId).member;
-      const expanded = expandStoredInstance({
+      const expanded = expandStoredInstance2({
         document: resolverDocument,
         instanceRoot,
-        rootMember,
-        evaluateInitializer: evaluateMemberInitializer
+        rootMember
       });
       const graph = resolveVirtualInstanceGraph({
         document: resolverDocument,
@@ -139445,6 +139752,10 @@ function verifyProjectSourceCommitAgainstStateV4(args) {
       trustedPendingProjectFiles.set(pendingId2, metadata);
     }
   }
+  const derivedSeedRowIds = derivedCandidateSeedRowIds(
+    args.authoredValueSeeds,
+    args.stateRecords
+  );
   const status = computeWorkspaceStatus(workspace, {
     forceRecompile: args.forceRecompile,
     skipProjectBinaryInspection: true,
@@ -139470,7 +139781,8 @@ ${blockingErrors.map((error) => error.message).join("\n")}` : `Trusted source lo
   auditAuthoredSeedRowIdentities(
     status.authoredValueSeeds,
     args.stateRecords,
-    assignments
+    assignments,
+    derivedSeedRowIds
   );
   const usedAssignments = /* @__PURE__ */ new Set();
   const positionless = positionIndependentAssignments(assignments);
@@ -139533,14 +139845,14 @@ function isDerivedOnlyRefresh(change, stateRecords) {
   if (!isObjectRecord(base.data)) return false;
   return canonicalStringify(comparisonData(change.recordKind, change.nextData)) === canonicalStringify(comparisonData(change.recordKind, base.data));
 }
-function auditAuthoredSeedRowIdentities(seeds, stateRecords, assignments) {
+function auditAuthoredSeedRowIdentities(seeds, stateRecords, assignments, derivedRowIds = /* @__PURE__ */ new Set()) {
   const mintedIds = new Set(assignments.values());
   const authoredCreates = /* @__PURE__ */ new Set();
   for (const [memberId, seed] of seeds) {
     for (const row of seed.values ?? []) {
       if (isPendingId(row.id)) continue;
       if (stateRecords[`value:${row.id}`] !== void 0) continue;
-      if (!isUuidV4Id(row.id)) {
+      if (!isUuidV4Id(row.id) && !derivedRowIds.has(row.id)) {
         throw new ProjectSourceCommitVerificationError(
           `Static value seed for member ${memberId} creates row ${row.id}, which is not a UUID v4. A new row's authored identity must wear the same shape a minted one does.`
         );
@@ -139559,6 +139871,19 @@ function auditAuthoredSeedRowIdentities(seeds, stateRecords, assignments) {
     }
   }
 }
+function derivedCandidateSeedRowIds(seeds, stateRecords) {
+  const derived = /* @__PURE__ */ new Set();
+  for (const seed of seeds) {
+    for (const row of seed.values ?? []) {
+      if (isDerivedNewValueId(
+        row.id,
+        (id2) => stateRecords[`value:${id2}`] !== void 0
+      ))
+        derived.add(row.id);
+    }
+  }
+  return derived;
+}
 function validateAssignments(value) {
   const assignments = /* @__PURE__ */ new Map();
   const assignedIds = /* @__PURE__ */ new Set();
@@ -142011,6 +142336,9 @@ function emitStoredConstructorExpression(context, member, valueId, visited = /*
     targetTyped
   );
   if (constructor2 !== null) return constructor2;
+  if (hasStoredConstruction && value.instanceConstructorId === null) {
+    return targetTyped ? "new()" : `new ${className}`;
+  }
   if (projection === null || projection.arguments.length === 0 && schemaClass2.requiredConstructorId === void 0) {
     throw new Error(
       `Stored materialized value ${valueId} has no constructor arguments.`
@@ -149559,6 +149887,9 @@ function classValueBody(context, member, value, visited, targetTyped, outerEnvir
       }
       continue;
     }
+    const storedBase = context.storedValueBase;
+    if (storedBase !== void 0 && isDerivedNewValueId(childId, (id2) => storedBase.has(id2)))
+      continue;
     const preservesBinding = context.collectionBindingValueIds.has(childId) || context.localValues?.byValueId.has(childId) === true;
     const baseChildBody = context.storedValueBase?.get(childId)?.value;
     const clearedStoredClassOverrides = isObjectRecord(baseChildBody) && Object.keys(baseChildBody).length > 0;
@@ -151732,6 +152063,7 @@ var init_value_sources = __esm({
   "src/project-source/value-sources.ts"() {
     "use strict";
     init_immutable_json3();
+    init_lower_support();
     init_record_fields();
     init_source_syntax_cache();
     init_lexer();
@@ -153003,8 +153335,7 @@ function materializeInitializersLocallyV4(args) {
   const sourceRoots = initializerSourceRootIds(
     args.changes,
     args.authoredValueSeeds,
-    records3,
-    args.workspace.state.records
+    records3
   );
   const written = [...args.changes];
   for (const seed of args.authoredValueSeeds) {
@@ -153402,28 +153733,23 @@ function initializerCode(records3, valueId) {
   }
   return row.init.code;
 }
-function initializerSourceRootIds(changes, seeds, records3, baseRecords) {
+function initializerSourceRootIds(changes, seeds, records3) {
   const ids = /* @__PURE__ */ new Set();
-  const needsFirstMaterialization = (valueId) => {
-    const base = baseRecords[`value:${valueId}`]?.data;
-    return base === void 0 || isObjectRecord(base) && isObjectRecord(base.init);
-  };
   for (const change of changes) {
     if (change.recordKind !== "value") continue;
     if (!isObjectRecord(change.nextData)) continue;
     if (!isObjectRecord(change.nextData.init)) continue;
-    if (!needsFirstMaterialization(change.recordId)) continue;
     ids.add(change.recordId);
   }
   for (const seed of seeds) {
     const member = records3.get(`member:${seed.memberId}`)?.data;
     const instanceBinding = isObjectRecord(member) && (member.modifier === 3 || member.valueId === seed.valueId);
     if (!instanceBinding) continue;
-    if (seed.nodeType === "initializer" && typeof seed.valueId === "string" && needsFirstMaterialization(seed.valueId)) {
+    if (seed.nodeType === "initializer" && typeof seed.valueId === "string") {
       ids.add(seed.valueId);
     }
     for (const row of seed.values ?? []) {
-      if (row.nodeType === "initializer" && needsFirstMaterialization(row.id)) {
+      if (row.nodeType === "initializer") {
         ids.add(row.id);
       }
     }
@@ -156757,6 +157083,13 @@ function walkValueSegments(walk, startId, segments, path, subject, fail2) {
       return null;
     }
     if (!isObjectRecord(body)) {
+      const initializer = pending !== void 0 ? pending.nodeType === "initializer" : isInitValueContent(walk.state[`value:${cursor}`]?.data);
+      if (initializer) {
+        fail2(
+          `${subject} ${path} stops before segment ${segment}: an init block constructs the row it reaches, so a path cannot name its members yet.`
+        );
+        return null;
+      }
       fail2(
         `${subject} ${path} stops before segment ${segment}: the row it reaches stores no single-valued members.`
       );
@@ -156854,6 +157187,7 @@ var init_root_source = __esm({
     "use strict";
     init_project_root();
     init_value_comparison();
+    init_members();
     init_value_sources();
     init_source_format();
     init_stored_value_placements();
@@ -182644,8 +182978,8 @@ function emitsStaticMember(ctx, member) {
   if (!isStaticMember(member)) return false;
   return ctx.singleton || requiresUnitySingleton(member);
 }
-function isPlatformNativeMemberId(memberId) {
-  return memberId === NEO_TILE_CONVERT_MEMBER_ID || NEO_CELL_PATTERN_PURE_NATIVE_MEMBER_IDS.has(memberId) || Object.values(NEO_OBJECT_GRID_MEMBER_IDS).some((id2) => id2 === memberId);
+function isPlatformNative(memberId, member) {
+  return member.kind === 13 /* Function */ && memberId.startsWith("system_");
 }
 function collectFunctionInvokers(ctx) {
   const invokers = [];
@@ -182656,13 +182990,13 @@ function collectFunctionInvokers(ctx) {
     for (const [schemaKey, memberId] of Object.entries(classDef.schema)) {
       if (memberId === null) continue;
       if (seen.has(memberId)) continue;
-      if (isPlatformNativeMemberId(memberId)) continue;
       const member = resolveMemberById(
         ctx,
         memberId,
         `classes.${classDef.id}.schema.${schemaKey}`
       );
       if (member === null || !isMemberFunctionBase(member)) continue;
+      if (isPlatformNative(memberId, member)) continue;
       seen.add(memberId);
       if (isStaticMember(member) === true) {
         if (!emitsStaticMember(ctx, ctx.exportData.members[memberId])) continue;
@@ -184469,12 +184803,12 @@ function generateNeoSchemaClassLines(ctx, classId, constructions) {
   });
   const ownNativeFunctionEntries = ownCallableEntries.filter(([, memberId]) => {
     const member = resolveMemberById(ctx, memberId, `members.${memberId}`);
-    return member !== null && isMemberFunctionBase(member) && !isPlatformNativeMemberId(memberId);
+    return member !== null && isMemberFunctionBase(member) && !isPlatformNative(memberId, member);
   });
   const ownStaticNativeFunctionEntries = ownStaticMemberEntries.filter(
     ([, memberId]) => {
       const member = resolveMemberById(ctx, memberId, `members.${memberId}`);
-      return member !== null && isMemberFunctionBase(member) && !isPlatformNativeMemberId(memberId);
+      return member !== null && isMemberFunctionBase(member) && !isPlatformNative(memberId, member);
     }
   );
   const inheritedSchemaKeys = inheritedSchemaKeySet(ctx, classDef);
@@ -185996,9 +186330,9 @@ function classEmitsFunctionHandlerInterface(ctx, classId) {
   const classDef = ctx.exportData.classes[classId];
   if (classDef === void 0 || !ctx.typeNames.has(classId)) return false;
   return Object.values(classDef.schema).some((memberId) => {
-    if (memberId === null || isPlatformNativeMemberId(memberId)) return false;
+    if (memberId === null) return false;
     const member = ctx.exportData.members[memberId];
-    return isMemberFunctionBase(member) && isStaticMember(member) !== true;
+    return isMemberFunctionBase(member) && !isPlatformNative(memberId, member) && isStaticMember(member) !== true;
   });
 }
 function nearestFunctionHandlerAncestor(ctx, classDef) {
@@ -189164,7 +189498,7 @@ function generateFunctionMethod(ctx, member, schemaKey, modifier = "", emitBody
       "}"
     ];
   }
-  if (isPlatformNativeMemberId(member.id) && !isFunctionVoidTypeInfo(member.returnTypeInfo)) {
+  if (isPlatformNative(member.id, member) && !isFunctionVoidTypeInfo(member.returnTypeInfo)) {
     return [
       ...docs,
       ...stamp,
@@ -190925,7 +191259,6 @@ var NEO_MEMORY_SCHEMA_KEYS, NEO_MEMORY_CLASS_NAMES, CELL_PATTERN_VALUE_BASE, DET
 var init_generate_unity_classes = __esm({
   "../src/models/exports/unity-codegen/generate-unity-classes.ts"() {
     "use strict";
-    init_cell_pattern();
     init_tile_conversion();
     init_project2();
     init_animation_clips();
@@ -194338,7 +194671,7 @@ var UNITY_CODEGEN_REVISION;
 var init_unity_codegen_revision = __esm({
   "../src/models/exports/unity-codegen-revision.ts"() {
     "use strict";
-    UNITY_CODEGEN_REVISION = "90421033eb03f03fcfab25a35784fa8890ae4377edbeee0b925a985754c15d42";
+    UNITY_CODEGEN_REVISION = "231557c5a40a20ab9e630415d45556845d7561d54e335a4d92c1cdbc1024a705";
   }
 });
 
@@ -197094,12 +197427,36 @@ var init_export = __esm({
 
 // src/project-source/evaluation-workspace.ts
 function workspaceForLocalEvaluation(workspace) {
+  const compiled = compilePendingBodies(
+    Object.entries(workspace.state.records),
+    () => {
+      const records3 = /* @__PURE__ */ new Map();
+      for (const [key, record7] of Object.entries(workspace.state.records))
+        records3.set(key, { ...record7, deleted: false });
+      return records3;
+    }
+  );
+  if (compiled === null) return workspace;
+  const refreshed = { ...workspace.state.records };
+  for (const [key, data] of compiled.bodies)
+    refreshed[key] = { ...refreshed[key], data };
+  return { ...workspace, state: { ...workspace.state, records: refreshed } };
+}
+function recordsForLocalEvaluation(records3) {
+  const compiled = compilePendingBodies(records3, () => new Map(records3));
+  if (compiled === null) return records3;
+  for (const [key, data] of compiled.bodies)
+    compiled.records.set(key, { ...records3.get(key), data });
+  return compiled.records;
+}
+function compilePendingBodies(entries, copyRecords) {
   const memberIds = /* @__PURE__ */ new Set();
   const constructorIds = /* @__PURE__ */ new Set();
   const pending = /* @__PURE__ */ new Map();
   const scriptSources = /* @__PURE__ */ new Map();
-  for (const [key, record7] of Object.entries(workspace.state.records)) {
+  for (const [key, record7] of entries) {
     const kind = record7.recordKind;
+    if (record7.deleted === true) continue;
     if (kind !== "member" && kind !== "constructor") continue;
     const stale = firstRejectedNeoScriptCompiledBody(record7.data, null);
     if (stale !== null) {
@@ -197110,34 +197467,27 @@ function workspaceForLocalEvaluation(workspace) {
     } else if (!hasPendingNeoScriptDerivation(kind, record7.data)) continue;
     (kind === "member" ? memberIds : constructorIds).add(record7.recordId);
     scriptSources.set(key, neoScriptRecordSources(record7.data));
-    pending.set(key, {
-      ...record7,
-      deleted: false,
-      data: stripClientDerivedBodies(kind, record7.data)
-    });
+    pending.set(key, stripClientDerivedBodies(kind, record7.data));
   }
-  if (pending.size === 0) return workspace;
-  const records3 = /* @__PURE__ */ new Map();
-  for (const [key, record7] of Object.entries(workspace.state.records))
-    records3.set(key, pending.get(key) ?? { ...record7, deleted: false });
-  const document = readPulledProjectDocumentV4(records3);
+  if (pending.size === 0) return null;
+  const compilable = copyRecords();
+  for (const [key, data] of pending)
+    compilable.set(key, { ...compilable.get(key), data });
+  const document = readPulledProjectDocumentV4(compilable);
   compilePulledProjectDocumentForEvaluationV4(document, void 0, {
     memberIds,
     constructorIds,
     scriptSources
   });
-  const refreshed = { ...workspace.state.records };
+  const bodies = /* @__PURE__ */ new Map();
   for (const member of document.members) {
-    if (!memberIds.has(member.id)) continue;
-    const key = `member:${member.id}`;
-    refreshed[key] = { ...refreshed[key], data: member };
+    if (memberIds.has(member.id)) bodies.set(`member:${member.id}`, member);
   }
   for (const constructor2 of document.constructors ?? []) {
-    if (!constructorIds.has(constructor2.id)) continue;
-    const key = `constructor:${constructor2.id}`;
-    refreshed[key] = { ...refreshed[key], data: constructor2 };
+    if (constructorIds.has(constructor2.id))
+      bodies.set(`constructor:${constructor2.id}`, constructor2);
   }
-  return { ...workspace, state: { ...workspace.state, records: refreshed } };
+  return { records: compilable, bodies };
 }
 var init_evaluation_workspace = __esm({
   "src/project-source/evaluation-workspace.ts"() {
@@ -198453,11 +198803,7 @@ async function prepareLocalPushArtifactsV4(workspace, status, onPhase = () => vo
   } : void 0;
   onPhase("Hashing project source\u2026");
   const source = projectSourceIdentityForStatus(status);
-  const verificationSource = options.fullValidation ? createPendingProjectSourceIdentityV4(
-    workspace,
-    status,
-    status.authoredValueSeeds
-  ) : null;
+  const verificationSource = options.fullValidation ? locatedPendingProjectSourceIdentity(workspace, status) : null;
   onPhase("Assigning pending value identities\u2026");
   const pendingAssignment = assignPendingIds(
     status.changes,
@@ -198589,6 +198935,17 @@ function locatePreparationError(error, status, assigned) {
   if (source === void 0) return error;
   return new Error(`${source.file}:${source.line} \u2014 ${error.message}`);
 }
+function locatedPendingProjectSourceIdentity(workspace, status) {
+  try {
+    return createPendingProjectSourceIdentityV4(
+      workspace,
+      status,
+      status.authoredValueSeeds
+    );
+  } catch (error) {
+    throw locatePreparationError(error, status, /* @__PURE__ */ new Map());
+  }
+}
 async function prepareLocalCandidateV4(workspace, options = {}) {
   const pushOptions = {
     dryRun: options.dryRun ?? true,
@@ -198953,19 +199310,22 @@ function createPendingProjectSourceIdentityV4(workspace, status, authoredValueSe
     }
   }
   materializePendingSourceLocalization(records3, status);
-  const emission = emitProjectDocumentFilesV4(records3, {
-    dialogueGroupSymbols: authoredDialogueGroupSymbols(
-      status.sourceSnapshot?.analysis
-    ),
-    storedValueBase: storedValueRowsByIdV4(
-      Object.values(workspace.state.records)
-    ),
-    recordFiles: projectRecordFilesV4(
-      Object.values(workspace.state.records),
-      status.reconstructed.values()
-    ),
-    localValues: status.localValues
-  });
+  const emission = emitProjectDocumentFilesV4(
+    recordsForLocalEvaluation(records3),
+    {
+      dialogueGroupSymbols: authoredDialogueGroupSymbols(
+        status.sourceSnapshot?.analysis
+      ),
+      storedValueBase: storedValueRowsByIdV4(
+        Object.values(workspace.state.records)
+      ),
+      recordFiles: projectRecordFilesV4(
+        Object.values(workspace.state.records),
+        status.reconstructed.values()
+      ),
+      localValues: status.localValues
+    }
+  );
   const files = emission.files.map((file) => {
     const kind = neoProjectSourceKind(file.path, file.content);
     if (kind === null || !isNeoProjectProductionSourceKind(kind)) {
@@ -201985,7 +202345,7 @@ async function finishFormat4Pull(args) {
   const formatSource = createWorkspaceSourceFormatter(workspace.root);
   const localResult = emitProjectDocumentFilesV4(
     candidateValueRecordsForEmissionV4(
-      localRecords,
+      recordsForLocalEvaluation(localRecords),
       workspace.state.records,
       workspace.config.projectId
     ),
@@ -202468,17 +202828,19 @@ function buildEmitRecordSet(document, plans, side) {
         resolvedRecordKind,
         resolvedRecordId,
         data,
-        serverRecord
+        // A locally created record's derived fields, such as a new
+        // static field's pending valueId, came from this same lowering.
+        serverRecord ?? (plan.conflicted ? void 0 : { data })
       ) : data
     });
   }
   return records3;
 }
-function composeProspectivePullRecord(recordKind, recordId, data, serverRecord) {
+function composeProspectivePullRecord(recordKind, recordId, data, base) {
   if (!isSchemaRecordKindV4(recordKind) || !isObjectRecord(data)) return data;
   let baseRecord = null;
-  if (serverRecord !== void 0) {
-    if (!isObjectRecord(serverRecord.data)) {
+  if (base !== void 0) {
+    if (!isObjectRecord(base.data)) {
       throw new Error(
         `Cannot compose pulled ${recordKind} record ${JSON.stringify(recordId)} because its server payload is not an object.`
       );
@@ -202486,7 +202848,7 @@ function composeProspectivePullRecord(recordKind, recordId, data, serverRecord)
     baseRecord = {
       recordKind,
       recordId,
-      data: serverRecord.data
+      data: base.data
     };
   }
   return composeDocumentRecord(
@@ -202527,6 +202889,7 @@ var init_pull = __esm({
     init_static_member_ownership_recovery();
     init_value_base_desync();
     init_packed_value_parity();
+    init_evaluation_workspace();
     init_compiler_metadata();
   }
 });
@@ -215446,7 +215809,7 @@ var releaseWorkspaceLock = () => void 0;
 async function main() {
   const args = parseArgs(process.argv.slice(2));
   if (args.command === "--version") {
-    console.log("0.83.0");
+    console.log("0.84.1");
     return;
   }
   if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {