@neocompose/cli 0.52.4 → 0.53.0

package/dist/neo.mjs

@@ -5012,6 +5012,15 @@ function identPathSegments(expression) {
   if (receiver === null) return null;
   return [...receiver, expression.name];
 }
+function receiverNarrowings(path, rootEntry, scope) {
+  const facts = [];
+  for (let dot = path.indexOf("."); dot !== -1; dot = path.indexOf(".", dot + 1)) {
+    const prefix = path.slice(0, dot);
+    const type = scope.lookupNarrowedType(prefix, rootEntry);
+    if (type !== null) facts.push([prefix, type]);
+  }
+  return facts;
+}
 function pathRoot(path) {
   const dot = path.indexOf(".");
   return dot === -1 ? path : path.slice(0, dot);
@@ -7536,7 +7545,15 @@ var init_strict_resolver = __esm({
         if (assignedPath) {
           const rootEntry = scope.lookup(pathRoot(assignedPath));
           if (rootEntry) {
+            const receiverFacts = receiverNarrowings(
+              assignedPath,
+              rootEntry,
+              scope
+            );
             scope.invalidate(rootEntry);
+            for (const [path, type] of receiverFacts) {
+              scope.narrow(path, rootEntry, type);
+            }
             if (statement.op === "=" && !isNullable(value.type)) {
               scope.narrow(assignedPath, rootEntry, {
                 ...target.type,
@@ -7627,7 +7644,17 @@ var init_strict_resolver = __esm({
         const assignedPath = canonicalPath(statement.target);
         if (assignedPath) {
           const rootEntry = scope.lookup(pathRoot(assignedPath));
-          if (rootEntry) scope.invalidate(rootEntry);
+          if (rootEntry) {
+            const receiverFacts = receiverNarrowings(
+              assignedPath,
+              rootEntry,
+              scope
+            );
+            scope.invalidate(rootEntry);
+            for (const [path, type] of receiverFacts) {
+              scope.narrow(path, rootEntry, type);
+            }
+          }
         }
         const kind = statement.op === "+=" ? "addActionListener" /* AddActionListener */ : "removeActionListener" /* RemoveActionListener */;
         return {
@@ -53539,11 +53566,14 @@ function requiredMembersForConstruction(classId, document, classArguments2) {
   );
 }
 function contextFor(document, env = /* @__PURE__ */ new Map()) {
-  return {
-    document,
-    membersById: new Map(document.members.map((member) => [member.id, member])),
-    env
-  };
+  const indexed = document.memberById;
+  if (indexed !== void 0) {
+    return { document, memberById: (id2) => indexed(id2) ?? void 0, env };
+  }
+  const membersById = new Map(
+    document.members.map((member) => [member.id, member])
+  );
+  return { document, memberById: (id2) => membersById.get(id2), env };
 }
 function unsettledMembers(classId, context, classArguments2, path) {
   const previousEnv = context.env;
@@ -53561,7 +53591,7 @@ function unsettledMembers(classId, context, classArguments2, path) {
   }
 }
 function constructionMembers(classId, context) {
-  const { document, membersById, env } = context;
+  const { document, memberById: memberById2, env } = context;
   if (firstUnboundParamId(env) !== null) return [];
   const result = [];
   for (const entry of mergeStoredInstanceSchema(
@@ -53569,7 +53599,7 @@ function constructionMembers(classId, context) {
     document.classes,
     document.members
   )) {
-    const raw = membersById.get(entry.memberId);
+    const raw = memberById2(entry.memberId);
     if (raw === void 0) continue;
     const member = {
       ...raw,
@@ -53632,7 +53662,7 @@ function valueSettlesConstruction(member, body, context, path, storedRow = false
     if (isCollection) {
       if (body.genericBindings != null)
         context.env = envFromStamp(body.genericBindings);
-      const entry = context.membersById.get(member.entryMemberId);
+      const entry = context.memberById(member.entryMemberId);
       if (entry === void 0) return false;
       const resolvedEntry = substituteMember(
         entry,
@@ -55060,7 +55090,8 @@ function evaluateLiteralContainer(args) {
   const evaluated = args.initEvaluator(
     args.member,
     body.init,
-    args.sourceValueId
+    args.sourceValueId,
+    args.genericEnv
   );
   const literal3 = {
     value: evaluated.value,
@@ -55113,6 +55144,7 @@ function buildDefaultMemberValue(args) {
   if (documentHasInitValueContent(args.document, declaredDefault)) {
     const initializerCreatedValuesStart = args.createdValues.length;
     const evaluated = evaluateLiteralContainer({
+      genericEnv: args.genericEnv,
       body: declaredDefault,
       member,
       initEvaluator: args.initEvaluator
@@ -55134,7 +55166,7 @@ function buildDefaultMemberValue(args) {
       value2.genericBindings = { ...evaluated.genericBindings };
     }
     if (evaluated.provisionalRootId !== void 0) {
-      retargetDelegateReceiverValueIds(
+      retargetInitializerRootValueIds(
         [value2, ...args.createdValues.slice(initializerCreatedValuesStart)],
         evaluated.provisionalRootId,
         value2.id
@@ -55436,7 +55468,7 @@ function buildNewValue(projectId, body, timestamp2 = Date.now()) {
   }
   return props;
 }
-function retargetDelegateReceiverValueIds(rows, fromValueId, toValueId) {
+function retargetInitializerRootValueIds(rows, fromValueId, toValueId) {
   const visited = /* @__PURE__ */ new WeakSet();
   const visit = (value) => {
     if (typeof value !== "object" || value === null) return;
@@ -55453,6 +55485,7 @@ function retargetDelegateReceiverValueIds(rows, fromValueId, toValueId) {
     for (const entry of Object.values(value)) visit(entry);
   };
   for (const row of rows) {
+    if (row.containerId === fromValueId) row.containerId = toValueId;
     if (!isLiteralValueContent(row)) continue;
     visit(row.value);
     visit(row.constructorArgs);
@@ -55582,6 +55615,7 @@ function cloneDefaultValueForMember(args) {
   if (documentHasInitValueContent(args.document, sourceValue)) {
     const initializerCreatedValuesStart = args.createdValues.length;
     const evaluated = evaluateLiteralContainer({
+      genericEnv: args.genericEnv,
       body: sourceValue,
       member,
       initEvaluator: args.initEvaluator,
@@ -55604,7 +55638,7 @@ function cloneDefaultValueForMember(args) {
       evaluatedRow.genericBindings = { ...evaluated.genericBindings };
     }
     if (evaluated.provisionalRootId !== void 0) {
-      retargetDelegateReceiverValueIds(
+      retargetInitializerRootValueIds(
         [
           evaluatedRow,
           ...args.createdValues.slice(initializerCreatedValuesStart)
@@ -68040,6 +68074,247 @@ var init_read_class_member = __esm({
   }
 });
 
+// ../src/runtime/neoscript/unattributable-reads.ts
+function ownershipChainRead(kind, rowId) {
+  return `${kind}:${rowId}`;
+}
+function containerEntriesRead(containerId) {
+  return `${CONTAINER_ENTRIES_PREFIX}${containerId}`;
+}
+function classifyUnattributableRead(reason) {
+  for (const prefix of OWNERSHIP_CHAIN_PREFIXES) {
+    if (reason.startsWith(prefix)) {
+      return { scope: "ownership-chain" /* OwnershipChain */ };
+    }
+  }
+  if (reason.startsWith(CONTAINER_ENTRIES_PREFIX)) {
+    return {
+      scope: "container" /* Container */,
+      containerId: reason.slice(CONTAINER_ENTRIES_PREFIX.length)
+    };
+  }
+  return { scope: "corpus" /* Corpus */ };
+}
+var OWNERSHIP_CHAIN_PREFIXES, CONTAINER_ENTRIES_PREFIX, OWNERSHIP_CHAIN_READ;
+var init_unattributable_reads = __esm({
+  "../src/runtime/neoscript/unattributable-reads.ts"() {
+    "use strict";
+    OWNERSHIP_CHAIN_PREFIXES = [
+      "generic-parent-resolution:",
+      "member-owner-resolution:",
+      "owned-value-parents:",
+      "declaration-owner-resolution:"
+    ];
+    CONTAINER_ENTRIES_PREFIX = "container-entries:";
+    OWNERSHIP_CHAIN_READ = ownershipChainRead(
+      "member-owner-resolution",
+      "*"
+    );
+  }
+});
+
+// ../src/runtime/neoscript/cell-pattern.ts
+function integer2(value, name, minimum = -2147483648) {
+  if (typeof value !== "number" || !Number.isInteger(value)) {
+    throw new TypeError(`${name} must be an integer.`);
+  }
+  if (value < minimum) {
+    throw new RangeError(`${name} must be at least ${minimum}.`);
+  }
+  if (value > 2147483647) {
+    throw new RangeError(`${name} exceeds the supported integer range.`);
+  }
+  return value === 0 ? 0 : value;
+}
+function vector(value, name) {
+  if (!isVector2IntValue(value)) {
+    throw new TypeError(`${name} must be a Vector2Int.`);
+  }
+  return { x: integer2(value.x, `${name}.x`), y: integer2(value.y, `${name}.y`) };
+}
+function exclusion(value) {
+  if (!Array.isArray(value) || value.length !== 1) {
+    throw new TypeError(
+      "excluding must select one NeoCellPatternExcluding option."
+    );
+  }
+  if (value[0] === NEO_CELL_PATTERN_EXCLUDING_OPTION_IDS.None) return "none";
+  if (value[0] === NEO_CELL_PATTERN_EXCLUDING_OPTION_IDS.Center)
+    return "center";
+  throw new RangeError("excluding is not a NeoCellPatternExcluding option.");
+}
+function reserve(ctx, count) {
+  if (!Number.isSafeInteger(count) || count < 0) {
+    throw new RangeError("Cell pattern contains too many offsets.");
+  }
+  ctx.reserveEntries(count);
+}
+function appendShell(result, radius, minX, maxX, minY, maxY) {
+  if (radius === 0) {
+    if (minX <= 0 && maxX >= 0 && minY <= 0 && maxY >= 0)
+      result.push({ x: 0, y: 0 });
+    return;
+  }
+  const firstY = Math.max(minY, -radius) || 0;
+  const lastY = Math.min(maxY, radius);
+  if (firstY > lastY) return;
+  if (-radius >= minX && -radius <= maxX) {
+    for (let y = firstY; y <= lastY; y++) result.push({ x: -radius, y });
+  }
+  const bottom = -radius >= minY && -radius <= maxY;
+  const top = radius !== 0 && radius >= minY && radius <= maxY;
+  if (bottom || top) {
+    const firstX = Math.max(minX, -radius + 1) || 0;
+    const lastX = Math.min(maxX, radius - 1);
+    for (let x = firstX; x <= lastX; x++) {
+      if (bottom) result.push({ x, y: -radius });
+      if (top) result.push({ x, y: radius });
+    }
+  }
+  if (radius !== 0 && radius >= minX && radius <= maxX) {
+    for (let y = firstY; y <= lastY; y++) result.push({ x: radius, y });
+  }
+}
+function rectangle(ctx, minX, maxX, minY, maxY, excluding) {
+  const count = (maxX - minX + 1) * (maxY - minY + 1);
+  reserve(ctx, count - (excluding === "center" ? 1 : 0));
+  const offsets = [];
+  const radius = Math.max(-minX, maxX, -minY, maxY);
+  for (let shell = excluding === "center" ? 1 : 0; shell <= radius; shell++) {
+    appendShell(offsets, shell, minX, maxX, minY, maxY);
+  }
+  return offsets;
+}
+function translated(offsets, origin, ctx) {
+  reserve(ctx, offsets.length);
+  return offsets.map((offset) => ({
+    x: integer2(offset.x + origin.x, "Translated cell.x"),
+    y: integer2(offset.y + origin.y, "Translated cell.y")
+  }));
+}
+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)
+  });
+  switch (memberId) {
+    case NEO_CELL_PATTERN_MEMBER_IDS.Box: {
+      const x = integer2(args[0], "Box radiusX", 0);
+      const y = args[1] === null ? x : integer2(args[1], "Box radiusY", 0);
+      return pattern(rectangle(ctx, -x, x, -y, y, exclusion(args[2])));
+    }
+    case NEO_CELL_PATTERN_MEMBER_IDS.Cross: {
+      const x = integer2(args[0], "Cross radiusX", 0);
+      const y = args[1] === null ? x : integer2(args[1], "Cross radiusY", 0);
+      const excluding = exclusion(args[2]);
+      reserve(ctx, 2 * (x + y) + (excluding === "none" ? 1 : 0));
+      const offsets2 = excluding === "none" ? [{ x: 0, y: 0 }] : [];
+      for (let distance = 1; distance <= Math.max(x, y); distance++) {
+        if (distance <= x)
+          offsets2.push({ x: -distance, y: 0 }, { x: distance, y: 0 });
+        if (distance <= y)
+          offsets2.push({ x: 0, y: -distance }, { x: 0, y: distance });
+      }
+      return pattern(offsets2);
+    }
+    case NEO_CELL_PATTERN_MEMBER_IDS.Ring: {
+      const radius = integer2(args[0], "Ring radius", 0);
+      reserve(ctx, radius === 0 ? 1 : 8 * radius);
+      const offsets2 = [];
+      appendShell(offsets2, radius, -radius, radius, -radius, radius);
+      return pattern(offsets2);
+    }
+    case NEO_CELL_PATTERN_MEMBER_IDS.Rect: {
+      const size = vector(args[0], "Rect size");
+      integer2(size.x, "Rect size.x", 1);
+      integer2(size.y, "Rect size.y", 1);
+      return pattern(rectangle(ctx, 0, size.x - 1, 0, size.y - 1, "none"));
+    }
+    case NEO_CELL_PATTERN_MEMBER_IDS.Line: {
+      const direction = vector(args[0], "Line direction");
+      if (isCenter(direction))
+        throw new RangeError("Line direction must be non-zero.");
+      const length = integer2(args[1], "Line length", 0);
+      const excluding = exclusion(args[2]);
+      reserve(ctx, length + (excluding === "none" ? 1 : 0));
+      integer2(direction.x * length, "Line endpoint.x");
+      integer2(direction.y * length, "Line endpoint.y");
+      const offsets2 = excluding === "none" ? [{ x: 0, y: 0 }] : [];
+      for (let step = 1; step <= length; step++) {
+        offsets2.push({ x: direction.x * step, y: direction.y * step });
+      }
+      return pattern(offsets2);
+    }
+  }
+  const offsets = ctx.readPattern(receiver);
+  ctx.visitEntries(offsets.length);
+  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
+        )
+      };
+    }
+    case NEO_CELL_PATTERN_MEMBER_IDS.Cells:
+      return {
+        handled: true,
+        value: translated(offsets, vector(args[0], "Cells origin"), ctx)
+      };
+    case NEO_CELL_PATTERN_MEMBER_IDS.WithCenter:
+      if (offsets.some(isCenter)) return { handled: true, value: receiver };
+      reserve(ctx, offsets.length + 1);
+      return pattern([{ x: 0, y: 0 }, ...offsets]);
+    case NEO_CELL_PATTERN_MEMBER_IDS.WithoutCenter: {
+      let count = 0;
+      for (const offset of offsets) if (!isCenter(offset)) count++;
+      if (count === offsets.length) return { handled: true, value: receiver };
+      reserve(ctx, count);
+      return pattern(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, ctx));
+    }
+    case NEO_CELL_PATTERN_MEMBER_IDS.Union: {
+      const other = ctx.readPattern(args[0]);
+      ctx.visitEntries(other.length);
+      const seen = /* @__PURE__ */ new Set();
+      const result = [];
+      for (const source of [offsets, other]) {
+        for (const offset of source) {
+          const key = `${offset.x},${offset.y}`;
+          if (seen.has(key)) continue;
+          reserve(ctx, 1);
+          seen.add(key);
+          result.push(offset);
+        }
+      }
+      return pattern(result);
+    }
+    default:
+      throw new Error(
+        `Cell pattern native member '${memberId}' has no implementation.`
+      );
+  }
+}
+var init_cell_pattern2 = __esm({
+  "../src/runtime/neoscript/cell-pattern.ts"() {
+    "use strict";
+    init_src();
+    init_member_kinds();
+  }
+});
+
 // ../src/models/project/project-types.ts
 function isProject(value) {
   const v = value;
@@ -68823,588 +69098,6 @@ var init_project2 = __esm({
   }
 });
 
-// ../src/models/members/stored-value-placement-index.ts
-function buildStoredValuePlacementIndex(args) {
-  return createStoredValuePlacementTraversal(args)();
-}
-function createStoredValuePlacementTraversal(args, trackReferences = false) {
-  const membersById = /* @__PURE__ */ new Map();
-  for (const member of args.members) membersById.set(member.id, member);
-  const valuesById = args.indexedRows?.valuesById ?? new Map(args.values.map((row) => [row.id, row]));
-  const unorderedEntriesByContainerId = /* @__PURE__ */ new Map();
-  for (const value of args.indexedRows === void 0 ? args.values : []) {
-    if (typeof value.containerId !== "string") continue;
-    const entries = unorderedEntriesByContainerId.get(value.containerId);
-    if (entries === void 0) {
-      unorderedEntriesByContainerId.set(value.containerId, [value]);
-    } else {
-      entries.push(value);
-    }
-  }
-  for (const entries of unorderedEntriesByContainerId.values()) {
-    entries.sort((left, right) => left.id.localeCompare(right.id));
-  }
-  const constructorsById = new Map(
-    args.constructors.map((constructor2) => [constructor2.id, constructor2])
-  );
-  const resolveConstructorSettlement = createConstructorSettlementResolver({
-    classes: args.classes,
-    constructors: args.constructors,
-    members: args.members
-  });
-  const resolvedMemberById = /* @__PURE__ */ new Map();
-  const resolvedMember = (member) => {
-    const cached = resolvedMemberById.get(member.id);
-    if (cached !== void 0) return cached;
-    const resolved = resolveMember2(member, args.members);
-    resolvedMemberById.set(member.id, resolved);
-    return resolved;
-  };
-  const storedSchemaByClassId = /* @__PURE__ */ new Map();
-  const storedSchema = (classId) => {
-    const cached = storedSchemaByClassId.get(classId);
-    if (cached !== void 0) return cached;
-    const schema = mergeStoredInstanceSchema(
-      classId,
-      args.classes,
-      args.members
-    );
-    storedSchemaByClassId.set(classId, schema);
-    return schema;
-  };
-  return (roots) => {
-    const queue = [...roots ?? []];
-    if (roots === void 0) {
-      for (const root of projectRootMembersInDisplayOrder(args.project)) {
-        const member = membersById.get(root.memberId);
-        if (member === void 0 || typeof member.valueId !== "string")
-          continue;
-        queue.push({
-          memberId: member.id,
-          parentValueId: null,
-          source: {
-            kind: "root",
-            label: root.root.label,
-            sourcePath: `root.${root.root.key}`
-          },
-          valueId: member.valueId
-        });
-      }
-      for (const member of args.members) {
-        if (!isStaticMember(member) || memberAccessOf(member) !== 0 /* Public */)
-          continue;
-        const valueId = args.resolveStaticValueId(member.id);
-        if (valueId === null) continue;
-        const placement = findSchemaPlacement(member.id, args.classes);
-        if (placement === null) continue;
-        queue.push({
-          memberId: member.id,
-          parentValueId: null,
-          source: {
-            kind: "static",
-            label: placement.schemaKey,
-            ownerClassName: placement.ownerClass.name,
-            sourcePath: `static:${member.id}`
-          },
-          valueId
-        });
-      }
-    }
-    const placementByValueId = /* @__PURE__ */ new Map();
-    const mutablePlacementsByClassId = /* @__PURE__ */ new Map();
-    const mutablePlacementsByMemberId = /* @__PURE__ */ new Map();
-    const mutablePlacementsByKind = /* @__PURE__ */ new Map();
-    for (let cursor = 0; cursor < queue.length; cursor += 1) {
-      const item = queue[cursor];
-      if (item === void 0 || placementByValueId.has(item.valueId)) continue;
-      const authoredValue = valuesById.get(item.valueId);
-      const storedMember = membersById.get(item.memberId);
-      if (authoredValue === void 0 || storedMember === void 0) continue;
-      const value = args.resolveValue === void 0 ? authoredValue : args.resolveValue(authoredValue);
-      if (value === null) continue;
-      const placement = item;
-      placementByValueId.set(value.id, placement);
-      appendPlacement(mutablePlacementsByMemberId, storedMember.id, placement);
-      const member = resolvedMember(storedMember);
-      appendPlacement(mutablePlacementsByKind, member.kind, placement);
-      if (isMemberClassBase(member)) {
-        const classId = value.classId ?? member.classId;
-        appendPlacement(mutablePlacementsByClassId, classId, placement);
-        if (!isLiteralValueContent(value) || !isStringRecord4(value.value)) {
-          continue;
-        }
-        const settledChildrenBySchemaKey = /* @__PURE__ */ new Map();
-        const constructor2 = typeof value.instanceConstructorId === "string" ? constructorsById.get(value.instanceConstructorId) : void 0;
-        if (constructor2 !== void 0 && constructor2.classId === classId && value.constructorArgs != null) {
-          for (const [
-            index,
-            parameter4
-          ] of constructor2.argumentTypes.entries()) {
-            const settled = resolveConstructorSettlement(
-              classId,
-              parameter4.name,
-              constructor2.id
-            );
-            if (settled === null || Object.hasOwn(value.value, settled.schemaKey)) {
-              continue;
-            }
-            const childValueId = value.constructorArgs[constructorActionParameterId(constructor2, index)];
-            if (typeof childValueId === "string") {
-              settledChildrenBySchemaKey.set(settled.schemaKey, childValueId);
-            }
-          }
-        }
-        for (const entry of storedSchema(classId)) {
-          const childMember = membersById.get(entry.memberId);
-          const childValueId = value.value[entry.schemaKey] ?? settledChildrenBySchemaKey.get(entry.schemaKey);
-          if (childMember === void 0 || typeof childValueId !== "string") {
-            continue;
-          }
-          if (memberAccessOf(childMember) !== 0 /* Public */) continue;
-          queue.push({
-            memberId: childMember.id,
-            parentValueId: value.id,
-            source: { kind: "classField", schemaKey: entry.schemaKey },
-            valueId: childValueId
-          });
-        }
-        continue;
-      }
-      if (!isMemberListBase(member) && !isMemberDictionaryBase(member)) {
-        continue;
-      }
-      const entryMember = membersById.get(member.entryMemberId);
-      if (entryMember === void 0) continue;
-      if (isMemberDictionaryBase(member)) {
-        if (!isStringRecord4(value.value)) continue;
-        for (const [key, childValueId] of Object.entries(value.value)) {
-          queue.push({
-            memberId: entryMember.id,
-            parentValueId: value.id,
-            source: {
-              kind: "collectionEntry",
-              containerMemberId: storedMember.id,
-              entry: { kind: "dict", key, valueId: childValueId }
-            },
-            valueId: childValueId
-          });
-        }
-        continue;
-      }
-      const entries = listKindOf(member) === 1 /* Unordered */ ? args.indexedRows === void 0 ? unorderedEntriesByContainerId.get(value.id) ?? [] : args.indexedRows.unorderedListEntryIds(value.id).flatMap((id2) => {
-        const row = valuesById.get(id2);
-        return row === void 0 ? [] : [row];
-      }) : Array.isArray(value.value) ? value.value.flatMap((childValueId) => {
-        if (typeof childValueId !== "string") return [];
-        const childValue = valuesById.get(childValueId);
-        return childValue === void 0 ? [] : [childValue];
-      }) : [];
-      for (const [index, childValue] of entries.entries()) {
-        queue.push({
-          memberId: entryMember.id,
-          parentValueId: value.id,
-          source: {
-            kind: "collectionEntry",
-            containerMemberId: storedMember.id,
-            entry: { kind: "list", index, valueId: childValue.id }
-          },
-          valueId: childValue.id
-        });
-      }
-    }
-    const referencesByParentId = /* @__PURE__ */ new Map();
-    if (trackReferences) {
-      for (const id2 of placementByValueId.keys())
-        referencesByParentId.set(id2, /* @__PURE__ */ new Set());
-      for (const item of queue) {
-        if (item.parentValueId !== null)
-          referencesByParentId.get(item.parentValueId)?.add(item.valueId);
-      }
-    }
-    return {
-      referencesByParentId,
-      placementByValueId,
-      placementsByClassId: mutablePlacementsByClassId,
-      placementsByKind: mutablePlacementsByKind,
-      placementsByMemberId: mutablePlacementsByMemberId
-    };
-  };
-}
-function createStoredValuePlacementBatch(args) {
-  const traverse = createStoredValuePlacementTraversal(args, true);
-  const initial = traverse();
-  const placementByValueId = new Map(initial.placementByValueId);
-  const childrenByParentId = /* @__PURE__ */ new Map();
-  const referencingParentsById = /* @__PURE__ */ new Map();
-  const referencesByParentId = /* @__PURE__ */ new Map();
-  const declaredRootIds = new Set(
-    args.members.flatMap(
-      (member) => typeof member.valueId === "string" ? [member.valueId] : []
-    )
-  );
-  const indexPlacement = (placement) => {
-    if (placement.parentValueId === null) return;
-    const children = childrenByParentId.get(placement.parentValueId) ?? /* @__PURE__ */ new Set();
-    children.add(placement.valueId);
-    childrenByParentId.set(placement.parentValueId, children);
-  };
-  for (const placement of placementByValueId.values())
-    indexPlacement(placement);
-  const indexReferences2 = (parentId, references) => {
-    for (const id2 of referencesByParentId.get(parentId) ?? []) {
-      const parents = referencingParentsById.get(id2);
-      parents?.delete(parentId);
-      if (parents?.size === 0) referencingParentsById.delete(id2);
-    }
-    referencesByParentId.set(parentId, new Set(references));
-    for (const id2 of references) {
-      const parents = referencingParentsById.get(id2) ?? /* @__PURE__ */ new Set();
-      parents.add(parentId);
-      referencingParentsById.set(id2, parents);
-    }
-  };
-  for (const [parentId, references] of initial.referencesByParentId)
-    indexReferences2(parentId, references);
-  const rebuild = () => {
-    const rebuilt = traverse();
-    placementByValueId.clear();
-    childrenByParentId.clear();
-    referencesByParentId.clear();
-    referencingParentsById.clear();
-    for (const placement of rebuilt.placementByValueId.values()) {
-      placementByValueId.set(placement.valueId, placement);
-      indexPlacement(placement);
-    }
-    for (const [parentId, references] of rebuilt.referencesByParentId)
-      indexReferences2(parentId, references);
-  };
-  return {
-    placementByValueId,
-    /** Call after the external row/membership indexes have received these replacements. */
-    refresh(rows, previousRows) {
-      const affected = /* @__PURE__ */ new Set();
-      const consider = (id2) => {
-        if (typeof id2 === "string" && placementByValueId.has(id2))
-          affected.add(id2);
-      };
-      let needsRootRebuild = false;
-      for (const row of rows) {
-        consider(row.id);
-        if (!placementByValueId.has(row.id)) {
-          for (const parentId of referencingParentsById.get(row.id) ?? [])
-            consider(parentId);
-        }
-        if (!placementByValueId.has(row.id) && declaredRootIds.has(row.id))
-          needsRootRebuild = true;
-      }
-      const previousById = new Map(
-        previousRows.flatMap(
-          (row) => row === void 0 ? [] : [[row.id, row]]
-        )
-      );
-      for (const row of rows) {
-        const previous = previousById.get(row.id);
-        if (previous?.containerId === row.containerId) continue;
-        consider(previous?.containerId);
-        consider(row.containerId);
-      }
-      if (needsRootRebuild) {
-        rebuild();
-        return;
-      }
-      const hasAffectedAncestor = /* @__PURE__ */ new Map();
-      const rootSeeds = [];
-      for (const id2 of affected) {
-        const placement = placementByValueId.get(id2);
-        let parent = placement.parentValueId;
-        const path = [];
-        let found = false;
-        while (parent !== null) {
-          if (affected.has(parent)) {
-            found = true;
-            break;
-          }
-          const cached = hasAffectedAncestor.get(parent);
-          if (cached !== void 0) {
-            found = cached;
-            break;
-          }
-          path.push(parent);
-          parent = placementByValueId.get(parent)?.parentValueId ?? null;
-        }
-        for (const ancestor of path) hasAffectedAncestor.set(ancestor, found);
-        if (!found) rootSeeds.push(placement);
-      }
-      const removed = /* @__PURE__ */ new Set();
-      const queue = rootSeeds.map((root) => root.valueId);
-      for (let index = 0; index < queue.length; index += 1) {
-        const id2 = queue[index];
-        if (removed.has(id2)) continue;
-        removed.add(id2);
-        for (const child of childrenByParentId.get(id2) ?? []) queue.push(child);
-      }
-      for (const id2 of removed) {
-        const oldParent = placementByValueId.get(id2)?.parentValueId;
-        for (const parentId of referencingParentsById.get(id2) ?? []) {
-          if (!removed.has(parentId) && parentId !== oldParent && placementByValueId.has(parentId)) {
-            rebuild();
-            return;
-          }
-        }
-      }
-      for (const id2 of removed) {
-        const parent = placementByValueId.get(id2)?.parentValueId;
-        if (typeof parent === "string")
-          childrenByParentId.get(parent)?.delete(id2);
-        childrenByParentId.delete(id2);
-        placementByValueId.delete(id2);
-      }
-      const next = traverse(rootSeeds);
-      for (const [id2, placement] of next.placementByValueId) {
-        const existing = placementByValueId.get(id2);
-        if (existing !== void 0 && existing.parentValueId !== placement.parentValueId) {
-          rebuild();
-          return;
-        }
-      }
-      for (const id2 of removed) indexReferences2(id2, /* @__PURE__ */ new Set());
-      for (const [parentId, references] of next.referencesByParentId)
-        indexReferences2(parentId, references);
-      for (const placement of next.placementByValueId.values()) {
-        placementByValueId.set(placement.valueId, placement);
-        indexPlacement(placement);
-      }
-    }
-  };
-}
-function appendPlacement(index, key, placement) {
-  const placements = index.get(key);
-  if (placements === void 0) {
-    index.set(key, [placement]);
-  } else {
-    placements.push(placement);
-  }
-}
-function isStringRecord4(value) {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    return false;
-  }
-  return Object.values(value).every((item) => typeof item === "string");
-}
-var init_stored_value_placement_index = __esm({
-  "../src/models/members/stored-value-placement-index.ts"() {
-    "use strict";
-    init_inheritance();
-    init_constructor_parameter_settlement();
-    init_constructors2();
-    init_project2();
-    init_member_kinds();
-    init_members();
-  }
-});
-
-// ../src/runtime/neoscript/cell-pattern.ts
-function integer2(value, name, minimum = -2147483648) {
-  if (typeof value !== "number" || !Number.isInteger(value)) {
-    throw new TypeError(`${name} must be an integer.`);
-  }
-  if (value < minimum) {
-    throw new RangeError(`${name} must be at least ${minimum}.`);
-  }
-  if (value > 2147483647) {
-    throw new RangeError(`${name} exceeds the supported integer range.`);
-  }
-  return value === 0 ? 0 : value;
-}
-function vector(value, name) {
-  if (!isVector2IntValue(value)) {
-    throw new TypeError(`${name} must be a Vector2Int.`);
-  }
-  return { x: integer2(value.x, `${name}.x`), y: integer2(value.y, `${name}.y`) };
-}
-function exclusion(value) {
-  if (!Array.isArray(value) || value.length !== 1) {
-    throw new TypeError(
-      "excluding must select one NeoCellPatternExcluding option."
-    );
-  }
-  if (value[0] === NEO_CELL_PATTERN_EXCLUDING_OPTION_IDS.None) return "none";
-  if (value[0] === NEO_CELL_PATTERN_EXCLUDING_OPTION_IDS.Center)
-    return "center";
-  throw new RangeError("excluding is not a NeoCellPatternExcluding option.");
-}
-function reserve(ctx, count) {
-  if (!Number.isSafeInteger(count) || count < 0) {
-    throw new RangeError("Cell pattern contains too many offsets.");
-  }
-  ctx.reserveEntries(count);
-}
-function appendShell(result, radius, minX, maxX, minY, maxY) {
-  if (radius === 0) {
-    if (minX <= 0 && maxX >= 0 && minY <= 0 && maxY >= 0)
-      result.push({ x: 0, y: 0 });
-    return;
-  }
-  const firstY = Math.max(minY, -radius) || 0;
-  const lastY = Math.min(maxY, radius);
-  if (firstY > lastY) return;
-  if (-radius >= minX && -radius <= maxX) {
-    for (let y = firstY; y <= lastY; y++) result.push({ x: -radius, y });
-  }
-  const bottom = -radius >= minY && -radius <= maxY;
-  const top = radius !== 0 && radius >= minY && radius <= maxY;
-  if (bottom || top) {
-    const firstX = Math.max(minX, -radius + 1) || 0;
-    const lastX = Math.min(maxX, radius - 1);
-    for (let x = firstX; x <= lastX; x++) {
-      if (bottom) result.push({ x, y: -radius });
-      if (top) result.push({ x, y: radius });
-    }
-  }
-  if (radius !== 0 && radius >= minX && radius <= maxX) {
-    for (let y = firstY; y <= lastY; y++) result.push({ x: radius, y });
-  }
-}
-function rectangle(ctx, minX, maxX, minY, maxY, excluding) {
-  const count = (maxX - minX + 1) * (maxY - minY + 1);
-  reserve(ctx, count - (excluding === "center" ? 1 : 0));
-  const offsets = [];
-  const radius = Math.max(-minX, maxX, -minY, maxY);
-  for (let shell = excluding === "center" ? 1 : 0; shell <= radius; shell++) {
-    appendShell(offsets, shell, minX, maxX, minY, maxY);
-  }
-  return offsets;
-}
-function translated(offsets, origin, ctx) {
-  reserve(ctx, offsets.length);
-  return offsets.map((offset) => ({
-    x: integer2(offset.x + origin.x, "Translated cell.x"),
-    y: integer2(offset.y + origin.y, "Translated cell.y")
-  }));
-}
-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)
-  });
-  switch (memberId) {
-    case NEO_CELL_PATTERN_MEMBER_IDS.Box: {
-      const x = integer2(args[0], "Box radiusX", 0);
-      const y = args[1] === null ? x : integer2(args[1], "Box radiusY", 0);
-      return pattern(rectangle(ctx, -x, x, -y, y, exclusion(args[2])));
-    }
-    case NEO_CELL_PATTERN_MEMBER_IDS.Cross: {
-      const x = integer2(args[0], "Cross radiusX", 0);
-      const y = args[1] === null ? x : integer2(args[1], "Cross radiusY", 0);
-      const excluding = exclusion(args[2]);
-      reserve(ctx, 2 * (x + y) + (excluding === "none" ? 1 : 0));
-      const offsets2 = excluding === "none" ? [{ x: 0, y: 0 }] : [];
-      for (let distance = 1; distance <= Math.max(x, y); distance++) {
-        if (distance <= x)
-          offsets2.push({ x: -distance, y: 0 }, { x: distance, y: 0 });
-        if (distance <= y)
-          offsets2.push({ x: 0, y: -distance }, { x: 0, y: distance });
-      }
-      return pattern(offsets2);
-    }
-    case NEO_CELL_PATTERN_MEMBER_IDS.Ring: {
-      const radius = integer2(args[0], "Ring radius", 0);
-      reserve(ctx, radius === 0 ? 1 : 8 * radius);
-      const offsets2 = [];
-      appendShell(offsets2, radius, -radius, radius, -radius, radius);
-      return pattern(offsets2);
-    }
-    case NEO_CELL_PATTERN_MEMBER_IDS.Rect: {
-      const size = vector(args[0], "Rect size");
-      integer2(size.x, "Rect size.x", 1);
-      integer2(size.y, "Rect size.y", 1);
-      return pattern(rectangle(ctx, 0, size.x - 1, 0, size.y - 1, "none"));
-    }
-    case NEO_CELL_PATTERN_MEMBER_IDS.Line: {
-      const direction = vector(args[0], "Line direction");
-      if (isCenter(direction))
-        throw new RangeError("Line direction must be non-zero.");
-      const length = integer2(args[1], "Line length", 0);
-      const excluding = exclusion(args[2]);
-      reserve(ctx, length + (excluding === "none" ? 1 : 0));
-      integer2(direction.x * length, "Line endpoint.x");
-      integer2(direction.y * length, "Line endpoint.y");
-      const offsets2 = excluding === "none" ? [{ x: 0, y: 0 }] : [];
-      for (let step = 1; step <= length; step++) {
-        offsets2.push({ x: direction.x * step, y: direction.y * step });
-      }
-      return pattern(offsets2);
-    }
-  }
-  const offsets = ctx.readPattern(receiver);
-  ctx.visitEntries(offsets.length);
-  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
-        )
-      };
-    }
-    case NEO_CELL_PATTERN_MEMBER_IDS.Cells:
-      return {
-        handled: true,
-        value: translated(offsets, vector(args[0], "Cells origin"), ctx)
-      };
-    case NEO_CELL_PATTERN_MEMBER_IDS.WithCenter:
-      if (offsets.some(isCenter)) return { handled: true, value: receiver };
-      reserve(ctx, offsets.length + 1);
-      return pattern([{ x: 0, y: 0 }, ...offsets]);
-    case NEO_CELL_PATTERN_MEMBER_IDS.WithoutCenter: {
-      let count = 0;
-      for (const offset of offsets) if (!isCenter(offset)) count++;
-      if (count === offsets.length) return { handled: true, value: receiver };
-      reserve(ctx, count);
-      return pattern(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, ctx));
-    }
-    case NEO_CELL_PATTERN_MEMBER_IDS.Union: {
-      const other = ctx.readPattern(args[0]);
-      ctx.visitEntries(other.length);
-      const seen = /* @__PURE__ */ new Set();
-      const result = [];
-      for (const source of [offsets, other]) {
-        for (const offset of source) {
-          const key = `${offset.x},${offset.y}`;
-          if (seen.has(key)) continue;
-          reserve(ctx, 1);
-          seen.add(key);
-          result.push(offset);
-        }
-      }
-      return pattern(result);
-    }
-    default:
-      throw new Error(
-        `Cell pattern native member '${memberId}' has no implementation.`
-      );
-  }
-}
-var init_cell_pattern2 = __esm({
-  "../src/runtime/neoscript/cell-pattern.ts"() {
-    "use strict";
-    init_src();
-    init_member_kinds();
-  }
-});
-
 // ../src/models/classes/world-layer-link-target.ts
 function validateWorldLayerLinkClassTargets(args) {
   const relationResolver = createEffectiveClassRelationResolver(args);
@@ -69596,6 +69289,7 @@ var init_initializer_context = __esm({
   "../src/runtime/neoscript/initializer-context.ts"() {
     "use strict";
     init_collections();
+    init_unattributable_reads();
     init_world_grid_query_reads();
     InitializerReadSet = class {
       valueIds = /* @__PURE__ */ new Set();
@@ -69606,9 +69300,28 @@ var init_initializer_context = __esm({
       worldQueries = new WorldGridQueryReadSet();
       hasValuePlacementRead = false;
       hasUnattributableValueRead = false;
-      recordUnattributableValueRead = (_reason) => {
-        void _reason;
+      /**
+       * The unattributable reads by scope, for a fork of the same document to
+       * re-attribute; see {@link classifyUnattributableRead}. Ownership-chain
+       * reads collapse to one flag: their inputs are already in `valueIds`.
+       */
+      hasOwnershipChainRead = false;
+      containerEntryReadIds = /* @__PURE__ */ new Set();
+      corpusReadReasons = /* @__PURE__ */ new Set();
+      recordUnattributableValueRead = (reason) => {
         this.hasUnattributableValueRead = true;
+        const read = classifyUnattributableRead(reason);
+        switch (read.scope) {
+          case "ownership-chain" /* OwnershipChain */:
+            this.hasOwnershipChainRead = true;
+            return;
+          case "container" /* Container */:
+            this.containerEntryReadIds.add(read.containerId);
+            return;
+          case "corpus" /* Corpus */:
+            this.corpusReadReasons.add(reason);
+            return;
+        }
       };
       recordValuePlacementRead = () => {
         this.hasValuePlacementRead = true;
@@ -70524,10 +70237,10 @@ function evaluatorOwnershipCachesForBase(base) {
   evaluatorOwnershipCachesByBase.set(base, created);
   return created;
 }
-function createEvaluatorBaseIndexBuild(members, values, valueById) {
-  const indexes2 = {
+function blankEvaluatorIndexes(memberByValueId) {
+  return {
     rowByValueReference: /* @__PURE__ */ new WeakMap(),
-    memberByValueId: /* @__PURE__ */ new Map(),
+    memberByValueId,
     parentLinksByChildId: /* @__PURE__ */ new Map(),
     indexedRowIds: /* @__PURE__ */ new Set(),
     indexedOverlayValues: /* @__PURE__ */ new Map(),
@@ -70544,6 +70257,9 @@ function createEvaluatorBaseIndexBuild(members, values, valueById) {
     constructorOwnershipDirtyValueIds: /* @__PURE__ */ new Set(),
     memberByRowId: /* @__PURE__ */ new Map()
   };
+}
+function createEvaluatorBaseIndexBuild(members, values, valueById) {
+  const indexes2 = blankEvaluatorIndexes(/* @__PURE__ */ new Map());
   const membersByValueId = /* @__PURE__ */ new Map();
   for (const member of members) {
     if (typeof member.valueId === "string") {
@@ -70636,6 +70352,114 @@ function createEvaluatorLookupsBuild(members, storedValues, options = {}) {
     }
   };
 }
+function layerEvaluatorLookups(base, overlay) {
+  const baseIndexes = base.evaluatorIndexes;
+  if (baseIndexes === void 0) {
+    throw new Error(
+      "Layered evaluator lookups require a base with value graph indexes."
+    );
+  }
+  const baseConstructorIndexes = base.constructorInitializerIndexes;
+  if (baseConstructorIndexes === void 0) {
+    throw new Error(
+      "Layered evaluator lookups require a base with constructor initializer indexes."
+    );
+  }
+  const masked = (id2) => overlay.rows.has(id2) || overlay.hiddenIds.has(id2);
+  const local = blankEvaluatorIndexes(baseIndexes.memberByValueId);
+  const localUnorderedMembership = /* @__PURE__ */ new Map();
+  for (const row of overlay.rows.values()) {
+    indexEvaluatorRow(local, row);
+    if (typeof row.containerId !== "string") continue;
+    const bucket = localUnorderedMembership.get(row.containerId) ?? [];
+    bucket.push(row.id);
+    localUnorderedMembership.set(row.containerId, bucket);
+  }
+  const parentLinks = /* @__PURE__ */ new Map();
+  const parentLinksFor = (childId) => {
+    const cached = parentLinks.get(childId);
+    if (cached !== void 0) return cached;
+    const inherited = (baseIndexes.parentLinksByChildId.get(childId) ?? []).filter((link) => !masked(link.parentId));
+    const own = local.parentLinksByChildId.get(childId) ?? [];
+    const merged = inherited.length === 0 ? own : [...inherited, ...own];
+    parentLinks.set(childId, merged);
+    return merged.length === 0 ? void 0 : merged;
+  };
+  const unorderedMembership = /* @__PURE__ */ new Map();
+  const unorderedListEntryIds2 = (containerId) => {
+    const cached = unorderedMembership.get(containerId);
+    if (cached !== void 0) return cached;
+    const own = localUnorderedMembership.get(containerId) ?? [];
+    const inherited = overlay.rows.has(containerId) ? [] : (base.unorderedListEntryIds?.(containerId) ?? []).filter(
+      (id2) => !masked(id2)
+    );
+    const merged = [...inherited, ...own].sort();
+    unorderedMembership.set(containerId, merged);
+    return merged;
+  };
+  const evaluatorIndexes2 = {
+    rows: overlay.values,
+    valueById: overlay.valuesById,
+    rowByValueReference: {
+      get: (value) => {
+        const own = local.rowByValueReference.get(value);
+        if (own !== void 0) return own;
+        const inherited = baseIndexes.rowByValueReference.get(value);
+        return inherited === void 0 || masked(inherited.id) ? void 0 : inherited;
+      }
+    },
+    memberByValueId: baseIndexes.memberByValueId,
+    membersByValueId: baseIndexes.membersByValueId,
+    parentLinksByChildId: { get: parentLinksFor },
+    indexedRowIds: {
+      has: (id2) => local.indexedRowIds.has(id2) || !masked(id2) && baseIndexes.indexedRowIds.has(id2)
+    },
+    rowsBySourceValueId: {
+      get: (sourceValueId) => {
+        const inherited = (baseIndexes.rowsBySourceValueId.get(sourceValueId) ?? []).filter((row) => !masked(row.id));
+        const own = local.rowsBySourceValueId.get(sourceValueId) ?? [];
+        if (inherited.length === 0 && own.length === 0) return void 0;
+        return inherited.length === 0 ? own : [...inherited, ...own];
+      }
+    }
+  };
+  const scopeByValueId = /* @__PURE__ */ new Map();
+  const scopeFor = (row) => {
+    const shadowed = baseConstructorIndexes.initializerScopeMemberIdsByValueId.get(row.id);
+    if (shadowed !== void 0) return shadowed;
+    const visited = /* @__PURE__ */ new Set();
+    let currentId = row.id;
+    while (!visited.has(currentId)) {
+      visited.add(currentId);
+      const link = parentLinksFor(currentId)?.[0];
+      if (link === void 0) break;
+      currentId = link.parentId;
+    }
+    return baseIndexes.memberByValueId.get(currentId)?.id;
+  };
+  for (const row of overlay.rows.values()) {
+    if (!isInitValueContent(row)) continue;
+    const scope = scopeFor(row);
+    if (scope !== void 0) scopeByValueId.set(row.id, scope);
+  }
+  const constructorInitializerIndexes2 = {
+    initializerScopeMemberIds: baseConstructorIndexes.initializerScopeMemberIds,
+    initializerScopeMemberIdsByValueId: {
+      get: (id2) => overlay.rows.has(id2) ? scopeByValueId.get(id2) : overlay.hiddenIds.has(id2) ? void 0 : baseConstructorIndexes.initializerScopeMemberIdsByValueId.get(id2)
+    },
+    schemaIndex: baseConstructorIndexes.schemaIndex
+  };
+  return {
+    memberById: (id2) => base.memberById(id2),
+    valueById: (id2) => overlay.rows.get(id2) ?? (overlay.hiddenIds.has(id2) ? null : base.valueById(id2)),
+    hasStoredValueId: (id2) => overlay.rows.has(id2) || !overlay.hiddenIds.has(id2) && (base.hasStoredValueId?.(id2) ?? false),
+    unorderedListEntryIds: unorderedListEntryIds2,
+    virtualInstanceRowsForValue: () => [],
+    rowForValueReference: (value) => evaluatorIndexes2.rowByValueReference.get(value) ?? null,
+    evaluatorIndexes: evaluatorIndexes2,
+    constructorInitializerIndexes: constructorInitializerIndexes2
+  };
+}
 function evaluatorIndexes(ctx) {
   const overlayRevision = ctx.__valueOverlay instanceof LazyValueOverlay ? ctx.__valueOverlay.revision : void 0;
   if (ctx.__indexes !== void 0 && ctx.__indexes.overlayRevision === overlayRevision) {
@@ -71334,6 +71158,29 @@ function evaluateNSGetterWithEffects(getter, ctx, argumentValues = [], options =
       if (getter.typeInfo.type === 20 /* Decimal */ && typeof result.value === "number") {
         result.value = coerceDecimalOperand(result.value, "return");
       }
+      const initializerResult = options.initializerResult;
+      if (initializerResult !== void 0 && result.value !== null && (isMemberListBase(initializerResult.member) || isMemberDictionaryBase(initializerResult.member)) && findKnownRowIdByValueReference(result.value, runtimeCtx) === null) {
+        const createdValues = createdSessionValuesSince(runtimeCtx, creationCheckpoint);
+        const declarations = /* @__PURE__ */ new Map();
+        const root = materializeConstructorArgumentValue({
+          member: initializerResult.member,
+          value: result.value,
+          genericEnv: initializerResult.genericEnv ?? /* @__PURE__ */ new Map(),
+          ctx: runtimeCtx,
+          createdValues,
+          createdById: new Map(createdValues.map((row) => [row.id, row])),
+          storageKeyDeclarations: declarations,
+          collectionEntriesAreReferences: false
+        });
+        declarations.delete(root.id);
+        publishConstructedRows({
+          root,
+          createdValues,
+          storageKeyDeclarations: declarations,
+          ctx: runtimeCtx
+        });
+        result.value = root.value;
+      }
       if (options.exportInitializerValues) {
         const created = createdSessionValuesSince(
           runtimeCtx,
@@ -71585,6 +71432,7 @@ function ownedConstructorArgumentValues(row, ctx, readRow) {
   }
   const owned = [];
   const collect = (value, rawTypeInfo, parameterId) => {
+    if (!genericParametersConcretelyBound(rawTypeInfo, genericEnv)) return;
     let typeInfo = rawTypeInfo;
     try {
       typeInfo = substituteRuntimeTypeInfo(
@@ -71743,9 +71591,7 @@ function finalizeConstructorAllocations(ctx, returnValue, ownsInvocationState, r
             }
           }
         }
-        ctx.onUnattributableValueRead?.(
-          `constructor-argument-list:${argumentId}`
-        );
+        ctx.onUnattributableValueRead?.(containerEntriesRead(argumentId));
         for (const childId of containerEntryIds(argumentId)) {
           scanCreationDataRow({
             id: childId,
@@ -71808,7 +71654,7 @@ function finalizeConstructorAllocations(ctx, returnValue, ownsInvocationState, r
     if (member !== null && isMemberListBase(member)) {
       const entryMember = evalMemberById(ctx.vm, member.entryMemberId);
       if (listKindOf(member) === 1 /* Unordered */) {
-        ctx.onUnattributableValueRead?.(`constructed-unordered-list:${row.id}`);
+        ctx.onUnattributableValueRead?.(containerEntriesRead(row.id));
         for (const childId of containerEntryIds(row.id)) {
           scanOwnedRow(childId, entryMember);
         }
@@ -74296,7 +74142,9 @@ function runtimeGenericEnvForValueRow(row, ctx, visited, readRow) {
 }
 function runtimeParentGenericEnv(row, ctx, visited, readRow) {
   const result = /* @__PURE__ */ new Map();
-  ctx.onUnattributableValueRead?.(`generic-parent-resolution:${row.id}`);
+  ctx.onUnattributableValueRead?.(
+    ownershipChainRead("generic-parent-resolution", row.id)
+  );
   for (const link of evaluatorParentLinks(evaluatorIndexes(ctx), row.id)) {
     const parent = readRow === void 0 ? evalValueById(
       ctx,
@@ -74324,6 +74172,24 @@ function overlayConcreteGenericEntries(target, source) {
     }
   }
 }
+function genericParametersConcretelyBound(typeInfo, env) {
+  if (typeInfo.type === 21 /* Generic */) {
+    return env.get(typeInfo.genericParamId)?.kind === "member";
+  }
+  if (typeInfo.type === 6 /* List */ || typeInfo.type === 5 /* Dictionary */ || typeInfo.type === 9 /* Lookup */) {
+    return genericParametersConcretelyBound(typeInfo.entryTypeInfo, env);
+  }
+  if (typeInfo.type === 25 /* NSDelegate */) {
+    return genericParametersConcretelyBound(typeInfo.returnTypeInfo, env) && typeInfo.argumentTypes.every(
+      (argument2) => genericParametersConcretelyBound(argument2, env)
+    );
+  }
+  if (typeInfo.type !== 7 /* Class */) return true;
+  for (const argument2 of Object.values(typeInfo.typeArguments ?? {})) {
+    if (!genericParametersConcretelyBound(argument2, env)) return false;
+  }
+  return true;
+}
 function substituteRuntimeTypeInfo(typeInfo, env, ctx) {
   if (typeInfo.type === 21 /* Generic */) {
     const binding = env.get(typeInfo.genericParamId);
@@ -74997,17 +74863,19 @@ function readDeclarationDefault(member, ctx) {
         projectId: ctx.vm.project.id,
         member,
         createdValues: created,
-        initEvaluator: (child, init, sourceValueId) => withConstructionGenericSlots(
+        initEvaluator: (child, init, sourceValueId, genericEnv = /* @__PURE__ */ new Map()) => withConstructionGenericSlots(
           child,
           ctx,
-          /* @__PURE__ */ new Map(),
+          genericEnv,
           () => evaluateInitializerInContext(
             init,
             child,
             ctx,
             created,
             [],
-            sourceValueId
+            sourceValueId,
+            void 0,
+            genericEnv
           )
         )
       });
@@ -75279,7 +75147,9 @@ function resolveMemberForValueRow(row, ctx, visited) {
   if (syntheticMemberId !== null) {
     return evalMemberById(ctx.vm, syntheticMemberId);
   }
-  ctx.onUnattributableValueRead?.(`member-owner-resolution:${row.id}`);
+  ctx.onUnattributableValueRead?.(
+    ownershipChainRead("member-owner-resolution", row.id)
+  );
   for (const link of evaluatorParentLinks(indexes2, row.id)) {
     const parent = evalValueById(
       ctx,
@@ -76692,7 +76562,8 @@ function validateClassConstructorDescriptor(info, ctx, requireEveryRequiredField
     members: ctx.vm.members,
     constructors: ctx.vm.constructors ?? [],
     values: ctx.vm.values,
-    valueById: ctx.vm.databaseVM?.valueById
+    valueById: ctx.vm.databaseVM?.valueById,
+    memberById: evaluatorDefaultValueDocument(ctx).memberById
   };
   const classArguments2 = slotArguments ?? resolveConstructionTypeArguments(
     info.schemaClassInfo.typeArguments,
@@ -77796,7 +77667,7 @@ function constructionInitEvaluator(ctx, createdValues, argumentScopes, construct
     }
     return null;
   };
-  return (member, init, sourceValueId) => {
+  return (member, init, sourceValueId, genericEnv = instanceEnv) => {
     const memberId = Reflect.get(member, "id");
     const effectiveMemberId = typeof memberId === "string" ? memberId : null;
     const scopeMemberId = indexes2.initializerScopeMemberIds.get(init) ?? (typeof sourceValueId !== "string" ? void 0 : indexes2.initializerScopeMemberIdsByValueId.get(sourceValueId)) ?? effectiveMemberId;
@@ -77811,7 +77682,7 @@ function constructionInitEvaluator(ctx, createdValues, argumentScopes, construct
       return withConstructionGenericSlots(
         member,
         ctx,
-        instanceEnv,
+        genericEnv,
         () => evaluateInitializerInContext(
           init,
           member,
@@ -77819,7 +77690,8 @@ function constructionInitEvaluator(ctx, createdValues, argumentScopes, construct
           createdValues,
           argumentValues,
           sourceValueId ?? null,
-          scopeMemberId
+          scopeMemberId,
+          genericEnv
         )
       );
     };
@@ -77956,7 +77828,7 @@ function runtimeValueReferencesVariable(value, variableId, visited = /* @__PURE_
     (child) => runtimeValueReferencesVariable(child, variableId, visited)
   );
 }
-function evaluateInitializerInContext(init, member, ctx, createdValues, argumentValues = [], sourceValueId = null, compileMemberId) {
+function evaluateInitializerInContext(init, member, ctx, createdValues, argumentValues = [], sourceValueId = null, compileMemberId, genericEnv = /* @__PURE__ */ new Map()) {
   ctx.__constructedArgumentsByValue ??= /* @__PURE__ */ new WeakMap();
   const compiled = ensureInitializerCompiled({
     init,
@@ -77972,7 +77844,8 @@ function evaluateInitializerInContext(init, member, ctx, createdValues, argument
     result = evaluateNSGetterWithEffects(
       compiled,
       initializerCtx,
-      argumentValues
+      argumentValues,
+      { initializerResult: { member, genericEnv } }
     );
   } finally {
     closeFrame();
@@ -79279,7 +79152,9 @@ function currentOwnedValueAttachments(valueId, ctx) {
       });
     }
   }
-  ctx.onUnattributableValueRead?.(`owned-value-parents:${valueId}`);
+  ctx.onUnattributableValueRead?.(
+    ownershipChainRead("owned-value-parents", valueId)
+  );
   const parentIds = new Set(
     evaluatorParentLinks(indexes2, valueId).map((link) => link.parentId)
   );
@@ -79561,9 +79436,7 @@ function cloneConstructorArgumentGraph(args) {
       if (listKindOf(member) === 1 /* Unordered */) {
         clone.value = [];
         const entryEnv2 = envFromStamp(clone.genericBindings);
-        args.ctx.onUnattributableValueRead?.(
-          `constructor-import-list:${source.id}`
-        );
+        args.ctx.onUnattributableValueRead?.(containerEntriesRead(source.id));
         const entries = evaluatorValues(args.ctx).filter((row) => row.containerId === source.id).sort((left, right) => left.id.localeCompare(right.id));
         for (const entry of entries) {
           cloneRow2(entry, entryMember, entryEnv2, clone.id);
@@ -79620,6 +79493,9 @@ function cloneConstructorLiteralValue(value) {
 }
 function materializeConstructorArgumentValue(args) {
   const trackedValueId = findKnownRowIdByValueReference(args.value, args.ctx);
+  if (args.value === null && !isRequiredMember2(args.member) && (isMemberListBase(args.member) || isMemberDictionaryBase(args.member))) {
+    return registerConstructorArgumentRow(args, null);
+  }
   if (isMemberClassBase(args.member)) {
     if (args.value === null || args.value === void 0) {
       if (isRequiredMember2(args.member)) {
@@ -79697,7 +79573,7 @@ function materializeConstructorArgumentValue(args) {
     let sourceEntries = args.value;
     if (listKindOf(args.member) === 1 /* Unordered */ && trackedValueId !== null) {
       args.ctx.onUnattributableValueRead?.(
-        `constructor-argument-list:${trackedValueId}`
+        containerEntriesRead(trackedValueId)
       );
       const rows = [];
       for (const entry of evaluatorValues(args.ctx)) {
@@ -79955,7 +79831,8 @@ function cloneClassValueGraph(receiver, expectedClassId, ctx) {
       initializerCreatedValues,
       argumentValues,
       sourceRow.id,
-      compileMemberId
+      compileMemberId,
+      isMemberListBase(sourceMember) || isMemberDictionaryBase(sourceMember) ? runtimeGenericEnvForValueRow(sourceRow, ctx, /* @__PURE__ */ new Set()) : void 0
     );
     if (evaluated.existingValueRow !== void 0) {
       const adoptedClone = cloneRow2(
@@ -79990,7 +79867,7 @@ function cloneClassValueGraph(receiver, expectedClassId, ctx) {
       Reflect.deleteProperty(clone, "containerId");
     }
     if (evaluated.provisionalRootId !== void 0) {
-      retargetDelegateReceiverValueIds(
+      retargetInitializerRootValueIds(
         [clone, ...initializerCreatedValues],
         evaluated.provisionalRootId,
         clone.id
@@ -80091,9 +79968,7 @@ function cloneClassValueGraph(receiver, expectedClassId, ctx) {
             entryTypeInfo
           ).id;
         });
-        ctx.onUnattributableValueRead?.(
-          `class-clone-unordered-list:${sourceRow.id}`
-        );
+        ctx.onUnattributableValueRead?.(containerEntriesRead(sourceRow.id));
         for (const child of evaluatorValues(ctx)) {
           if (child.containerId !== sourceRow.id) continue;
           cloneRow2(child, entryMember, id2, entryTypeInfo);
@@ -80342,6 +80217,7 @@ var DELEGATE_LEXICAL_THIS, DELEGATE_LEXICAL_ROOT, NonCatchableNSGetterRuntimeErr
 var init_evaluateNSGetter = __esm({
   "../src/runtime/neoscript/evaluateNSGetter.ts"() {
     "use strict";
+    init_unattributable_reads();
     init_value_row_owner_members();
     init_src();
     init_cell_pattern2();
@@ -80555,6 +80431,7 @@ 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,
@@ -80603,6 +80480,7 @@ function materializeInitializerValue(args) {
     ...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,
@@ -80631,7 +80509,7 @@ function materializeInitializerValue(args) {
   };
   const allCreated = [root, ...createdValues];
   if (evaluated.provisionalRootId !== void 0) {
-    retargetDelegateReceiverValueIds(
+    retargetInitializerRootValueIds(
       allCreated,
       evaluated.provisionalRootId,
       root.id
@@ -80653,7 +80531,7 @@ function materializeMemberDefaultValue(args) {
   const createdValues = [];
   const storageKeyDeclarations = /* @__PURE__ */ new Map();
   args.readTracking?.recordUnattributableValueRead(
-    `declaration-owner-resolution:${args.envelope.id}`
+    ownershipChainRead("declaration-owner-resolution", args.envelope.id)
   );
   const declarationArguments = (member, init, sourceValueId) => {
     const { valuesById, rootOwners } = declarationInitializerContext(
@@ -80694,7 +80572,9 @@ function materializeMemberDefaultValue(args) {
     ...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) => args.evaluateInitializer({
+    initEvaluator: (member, init, sourceValueId, genericEnv) => args.evaluateInitializer({
+      genericEnv,
+      storageKeyDeclarations,
       init,
       member,
       document: args.document,
@@ -80719,7 +80599,7 @@ function materializeMemberDefaultValue(args) {
     ...built.genericBindings == null ? {} : { genericBindings: { ...built.genericBindings } }
   };
   const allCreated = [root, ...interior];
-  retargetDelegateReceiverValueIds(allCreated, built.id, root.id);
+  retargetInitializerRootValueIds(allCreated, built.id, root.id);
   finalizeMaterializedRoot({
     root,
     allCreated,
@@ -80733,9 +80613,11 @@ var declarationInitializerContextByDocument;
 var init_initializer_materialization = __esm({
   "../src/runtime/initializer-materialization.ts"() {
     "use strict";
+    init_unattributable_reads();
     init_deep_clone_plain_data();
     init_members();
     init_inheritance();
+    init_generics();
     init_evaluateNSGetter();
     init_initializer_context();
     init_value_row_owner_members();
@@ -80744,6 +80626,386 @@ var init_initializer_materialization = __esm({
   }
 });
 
+// ../src/models/members/stored-value-placement-index.ts
+function buildStoredValuePlacementIndex(args) {
+  return createStoredValuePlacementTraversal(args)();
+}
+function createStoredValuePlacementTraversal(args, trackReferences = false) {
+  const membersById = /* @__PURE__ */ new Map();
+  for (const member of args.members) membersById.set(member.id, member);
+  const valuesById = args.indexedRows?.valuesById ?? new Map(args.values.map((row) => [row.id, row]));
+  const unorderedEntriesByContainerId = /* @__PURE__ */ new Map();
+  for (const value of args.indexedRows === void 0 ? args.values : []) {
+    if (typeof value.containerId !== "string") continue;
+    const entries = unorderedEntriesByContainerId.get(value.containerId);
+    if (entries === void 0) {
+      unorderedEntriesByContainerId.set(value.containerId, [value]);
+    } else {
+      entries.push(value);
+    }
+  }
+  for (const entries of unorderedEntriesByContainerId.values()) {
+    entries.sort((left, right) => left.id.localeCompare(right.id));
+  }
+  const constructorsById = new Map(
+    args.constructors.map((constructor2) => [constructor2.id, constructor2])
+  );
+  const resolveConstructorSettlement = createConstructorSettlementResolver({
+    classes: args.classes,
+    constructors: args.constructors,
+    members: args.members
+  });
+  const resolvedMemberById = /* @__PURE__ */ new Map();
+  const resolvedMember = (member) => {
+    const cached = resolvedMemberById.get(member.id);
+    if (cached !== void 0) return cached;
+    const resolved = resolveMember2(member, args.members);
+    resolvedMemberById.set(member.id, resolved);
+    return resolved;
+  };
+  const storedSchemaByClassId = /* @__PURE__ */ new Map();
+  const storedSchema = (classId) => {
+    const cached = storedSchemaByClassId.get(classId);
+    if (cached !== void 0) return cached;
+    const schema = mergeStoredInstanceSchema(
+      classId,
+      args.classes,
+      args.members
+    );
+    storedSchemaByClassId.set(classId, schema);
+    return schema;
+  };
+  return (roots) => {
+    const queue = [...roots ?? []];
+    if (roots === void 0) {
+      for (const root of projectRootMembersInDisplayOrder(args.project)) {
+        const member = membersById.get(root.memberId);
+        if (member === void 0 || typeof member.valueId !== "string")
+          continue;
+        queue.push({
+          memberId: member.id,
+          parentValueId: null,
+          source: {
+            kind: "root",
+            label: root.root.label,
+            sourcePath: `root.${root.root.key}`
+          },
+          valueId: member.valueId
+        });
+      }
+      for (const member of args.members) {
+        if (!isStaticMember(member) || memberAccessOf(member) !== 0 /* Public */)
+          continue;
+        const valueId = args.resolveStaticValueId(member.id);
+        if (valueId === null) continue;
+        const placement = findSchemaPlacement(member.id, args.classes);
+        if (placement === null) continue;
+        queue.push({
+          memberId: member.id,
+          parentValueId: null,
+          source: {
+            kind: "static",
+            label: placement.schemaKey,
+            ownerClassName: placement.ownerClass.name,
+            sourcePath: `static:${member.id}`
+          },
+          valueId
+        });
+      }
+    }
+    const placementByValueId = /* @__PURE__ */ new Map();
+    const mutablePlacementsByClassId = /* @__PURE__ */ new Map();
+    const mutablePlacementsByMemberId = /* @__PURE__ */ new Map();
+    const mutablePlacementsByKind = /* @__PURE__ */ new Map();
+    for (let cursor = 0; cursor < queue.length; cursor += 1) {
+      const item = queue[cursor];
+      if (item === void 0 || placementByValueId.has(item.valueId)) continue;
+      const authoredValue = valuesById.get(item.valueId);
+      const storedMember = membersById.get(item.memberId);
+      if (authoredValue === void 0 || storedMember === void 0) continue;
+      const value = args.resolveValue === void 0 ? authoredValue : args.resolveValue(authoredValue);
+      if (value === null) continue;
+      const placement = item;
+      placementByValueId.set(value.id, placement);
+      appendPlacement(mutablePlacementsByMemberId, storedMember.id, placement);
+      const member = resolvedMember(storedMember);
+      appendPlacement(mutablePlacementsByKind, member.kind, placement);
+      if (isMemberClassBase(member)) {
+        const classId = value.classId ?? member.classId;
+        appendPlacement(mutablePlacementsByClassId, classId, placement);
+        if (!isLiteralValueContent(value) || !isStringRecord4(value.value)) {
+          continue;
+        }
+        const settledChildrenBySchemaKey = /* @__PURE__ */ new Map();
+        const constructor2 = typeof value.instanceConstructorId === "string" ? constructorsById.get(value.instanceConstructorId) : void 0;
+        if (constructor2 !== void 0 && constructor2.classId === classId && value.constructorArgs != null) {
+          for (const [
+            index,
+            parameter4
+          ] of constructor2.argumentTypes.entries()) {
+            const settled = resolveConstructorSettlement(
+              classId,
+              parameter4.name,
+              constructor2.id
+            );
+            if (settled === null || Object.hasOwn(value.value, settled.schemaKey)) {
+              continue;
+            }
+            const childValueId = value.constructorArgs[constructorActionParameterId(constructor2, index)];
+            if (typeof childValueId === "string") {
+              settledChildrenBySchemaKey.set(settled.schemaKey, childValueId);
+            }
+          }
+        }
+        for (const entry of storedSchema(classId)) {
+          const childMember = membersById.get(entry.memberId);
+          const childValueId = value.value[entry.schemaKey] ?? settledChildrenBySchemaKey.get(entry.schemaKey);
+          if (childMember === void 0 || typeof childValueId !== "string") {
+            continue;
+          }
+          if (memberAccessOf(childMember) !== 0 /* Public */) continue;
+          queue.push({
+            memberId: childMember.id,
+            parentValueId: value.id,
+            source: { kind: "classField", schemaKey: entry.schemaKey },
+            valueId: childValueId
+          });
+        }
+        continue;
+      }
+      if (!isMemberListBase(member) && !isMemberDictionaryBase(member)) {
+        continue;
+      }
+      const entryMember = membersById.get(member.entryMemberId);
+      if (entryMember === void 0) continue;
+      if (isMemberDictionaryBase(member)) {
+        if (!isStringRecord4(value.value)) continue;
+        for (const [key, childValueId] of Object.entries(value.value)) {
+          queue.push({
+            memberId: entryMember.id,
+            parentValueId: value.id,
+            source: {
+              kind: "collectionEntry",
+              containerMemberId: storedMember.id,
+              entry: { kind: "dict", key, valueId: childValueId }
+            },
+            valueId: childValueId
+          });
+        }
+        continue;
+      }
+      const entries = listKindOf(member) === 1 /* Unordered */ ? args.indexedRows === void 0 ? unorderedEntriesByContainerId.get(value.id) ?? [] : args.indexedRows.unorderedListEntryIds(value.id).flatMap((id2) => {
+        const row = valuesById.get(id2);
+        return row === void 0 ? [] : [row];
+      }) : Array.isArray(value.value) ? value.value.flatMap((childValueId) => {
+        if (typeof childValueId !== "string") return [];
+        const childValue = valuesById.get(childValueId);
+        return childValue === void 0 ? [] : [childValue];
+      }) : [];
+      for (const [index, childValue] of entries.entries()) {
+        queue.push({
+          memberId: entryMember.id,
+          parentValueId: value.id,
+          source: {
+            kind: "collectionEntry",
+            containerMemberId: storedMember.id,
+            entry: { kind: "list", index, valueId: childValue.id }
+          },
+          valueId: childValue.id
+        });
+      }
+    }
+    const referencesByParentId = /* @__PURE__ */ new Map();
+    if (trackReferences) {
+      for (const id2 of placementByValueId.keys())
+        referencesByParentId.set(id2, /* @__PURE__ */ new Set());
+      for (const item of queue) {
+        if (item.parentValueId !== null)
+          referencesByParentId.get(item.parentValueId)?.add(item.valueId);
+      }
+    }
+    return {
+      referencesByParentId,
+      placementByValueId,
+      placementsByClassId: mutablePlacementsByClassId,
+      placementsByKind: mutablePlacementsByKind,
+      placementsByMemberId: mutablePlacementsByMemberId
+    };
+  };
+}
+function createStoredValuePlacementBatch(args) {
+  const traverse = createStoredValuePlacementTraversal(args, true);
+  const initial = traverse();
+  const placementByValueId = new Map(initial.placementByValueId);
+  const childrenByParentId = /* @__PURE__ */ new Map();
+  const referencingParentsById = /* @__PURE__ */ new Map();
+  const referencesByParentId = /* @__PURE__ */ new Map();
+  const declaredRootIds = new Set(
+    args.members.flatMap(
+      (member) => typeof member.valueId === "string" ? [member.valueId] : []
+    )
+  );
+  const indexPlacement = (placement) => {
+    if (placement.parentValueId === null) return;
+    const children = childrenByParentId.get(placement.parentValueId) ?? /* @__PURE__ */ new Set();
+    children.add(placement.valueId);
+    childrenByParentId.set(placement.parentValueId, children);
+  };
+  for (const placement of placementByValueId.values())
+    indexPlacement(placement);
+  const indexReferences2 = (parentId, references) => {
+    for (const id2 of referencesByParentId.get(parentId) ?? []) {
+      const parents = referencingParentsById.get(id2);
+      parents?.delete(parentId);
+      if (parents?.size === 0) referencingParentsById.delete(id2);
+    }
+    referencesByParentId.set(parentId, new Set(references));
+    for (const id2 of references) {
+      const parents = referencingParentsById.get(id2) ?? /* @__PURE__ */ new Set();
+      parents.add(parentId);
+      referencingParentsById.set(id2, parents);
+    }
+  };
+  for (const [parentId, references] of initial.referencesByParentId)
+    indexReferences2(parentId, references);
+  const rebuild = () => {
+    const rebuilt = traverse();
+    placementByValueId.clear();
+    childrenByParentId.clear();
+    referencesByParentId.clear();
+    referencingParentsById.clear();
+    for (const placement of rebuilt.placementByValueId.values()) {
+      placementByValueId.set(placement.valueId, placement);
+      indexPlacement(placement);
+    }
+    for (const [parentId, references] of rebuilt.referencesByParentId)
+      indexReferences2(parentId, references);
+  };
+  return {
+    placementByValueId,
+    /** Call after the external row/membership indexes have received these replacements. */
+    refresh(rows, previousRows) {
+      const affected = /* @__PURE__ */ new Set();
+      const consider = (id2) => {
+        if (typeof id2 === "string" && placementByValueId.has(id2))
+          affected.add(id2);
+      };
+      let needsRootRebuild = false;
+      for (const row of rows) {
+        consider(row.id);
+        if (!placementByValueId.has(row.id)) {
+          for (const parentId of referencingParentsById.get(row.id) ?? [])
+            consider(parentId);
+        }
+        if (!placementByValueId.has(row.id) && declaredRootIds.has(row.id))
+          needsRootRebuild = true;
+      }
+      const previousById = new Map(
+        previousRows.flatMap(
+          (row) => row === void 0 ? [] : [[row.id, row]]
+        )
+      );
+      for (const row of rows) {
+        const previous = previousById.get(row.id);
+        if (previous?.containerId === row.containerId) continue;
+        consider(previous?.containerId);
+        consider(row.containerId);
+      }
+      if (needsRootRebuild) {
+        rebuild();
+        return;
+      }
+      const hasAffectedAncestor = /* @__PURE__ */ new Map();
+      const rootSeeds = [];
+      for (const id2 of affected) {
+        const placement = placementByValueId.get(id2);
+        let parent = placement.parentValueId;
+        const path = [];
+        let found = false;
+        while (parent !== null) {
+          if (affected.has(parent)) {
+            found = true;
+            break;
+          }
+          const cached = hasAffectedAncestor.get(parent);
+          if (cached !== void 0) {
+            found = cached;
+            break;
+          }
+          path.push(parent);
+          parent = placementByValueId.get(parent)?.parentValueId ?? null;
+        }
+        for (const ancestor of path) hasAffectedAncestor.set(ancestor, found);
+        if (!found) rootSeeds.push(placement);
+      }
+      const removed = /* @__PURE__ */ new Set();
+      const queue = rootSeeds.map((root) => root.valueId);
+      for (let index = 0; index < queue.length; index += 1) {
+        const id2 = queue[index];
+        if (removed.has(id2)) continue;
+        removed.add(id2);
+        for (const child of childrenByParentId.get(id2) ?? []) queue.push(child);
+      }
+      for (const id2 of removed) {
+        const oldParent = placementByValueId.get(id2)?.parentValueId;
+        for (const parentId of referencingParentsById.get(id2) ?? []) {
+          if (!removed.has(parentId) && parentId !== oldParent && placementByValueId.has(parentId)) {
+            rebuild();
+            return;
+          }
+        }
+      }
+      for (const id2 of removed) {
+        const parent = placementByValueId.get(id2)?.parentValueId;
+        if (typeof parent === "string")
+          childrenByParentId.get(parent)?.delete(id2);
+        childrenByParentId.delete(id2);
+        placementByValueId.delete(id2);
+      }
+      const next = traverse(rootSeeds);
+      for (const [id2, placement] of next.placementByValueId) {
+        const existing = placementByValueId.get(id2);
+        if (existing !== void 0 && existing.parentValueId !== placement.parentValueId) {
+          rebuild();
+          return;
+        }
+      }
+      for (const id2 of removed) indexReferences2(id2, /* @__PURE__ */ new Set());
+      for (const [parentId, references] of next.referencesByParentId)
+        indexReferences2(parentId, references);
+      for (const placement of next.placementByValueId.values()) {
+        placementByValueId.set(placement.valueId, placement);
+        indexPlacement(placement);
+      }
+    }
+  };
+}
+function appendPlacement(index, key, placement) {
+  const placements = index.get(key);
+  if (placements === void 0) {
+    index.set(key, [placement]);
+  } else {
+    placements.push(placement);
+  }
+}
+function isStringRecord4(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  return Object.values(value).every((item) => typeof item === "string");
+}
+var init_stored_value_placement_index = __esm({
+  "../src/models/members/stored-value-placement-index.ts"() {
+    "use strict";
+    init_inheritance();
+    init_constructor_parameter_settlement();
+    init_constructors2();
+    init_project2();
+    init_member_kinds();
+    init_members();
+  }
+});
+
 // ../src/runtime/virtual-instance-graph.ts
 function buildVirtualInstanceMaterializedIndex(args) {
   const rowsById = new Map(
@@ -80867,8 +81129,14 @@ function expandStoredInstance(args) {
       for (const read of readTracking.worldQueries) {
         recorder?.recordWorldQueryRead?.(read);
       }
-      if (readTracking.hasUnattributableValueRead) {
-        recorder?.recordGlobalRead("initializer-runtime");
+      if (readTracking.hasOwnershipChainRead) {
+        recorder?.recordGlobalRead(OWNERSHIP_CHAIN_READ);
+      }
+      for (const containerId of readTracking.containerEntryReadIds) {
+        recorder?.recordGlobalRead(containerEntriesRead(containerId));
+      }
+      for (const reason of readTracking.corpusReadReasons) {
+        recorder?.recordGlobalRead(reason);
       }
     }
   };
@@ -83171,9 +83439,66 @@ function createHeadlessVirtualInstanceResolver(args) {
   const failedRootIds = /* @__PURE__ */ new Set();
   const expandedRowById = /* @__PURE__ */ new Map();
   const expandedRowByRecord = /* @__PURE__ */ new WeakMap();
+  const readsByRootId = /* @__PURE__ */ new Map();
+  const activeReads = [];
+  const sharedByReceiverId = /* @__PURE__ */ new Map();
+  const mergeReads = (reads) => {
+    for (const active of activeReads) {
+      if (active === reads) continue;
+      for (const id2 of reads.valueIds) active.valueIds.add(id2);
+      for (const id2 of reads.containerIds) active.containerIds.add(id2);
+      if (reads.global) active.global = true;
+    }
+  };
+  const recorder = {
+    recordValueRead: (id2) => {
+      for (const active of activeReads) active.valueIds.add(id2);
+      args.readRecorder?.recordValueRead(id2);
+    },
+    recordLocalizedTextRead: (id2) => args.readRecorder?.recordLocalizedTextRead(id2),
+    recordVariantRead: (id2) => args.readRecorder?.recordVariantRead(id2),
+    recordStaticMemberRead: (id2) => args.readRecorder?.recordStaticMemberRead(id2),
+    recordContainerMembershipRead: (id2) => {
+      for (const active of activeReads) active.containerIds.add(id2);
+      args.readRecorder?.recordContainerMembershipRead(id2);
+    },
+    recordWorldQueryRead: (read) => {
+      for (const active of activeReads) active.global = true;
+      args.readRecorder?.recordWorldQueryRead?.(read);
+    },
+    recordValuePlacementRead: () => args.readRecorder?.recordValuePlacementRead(),
+    recordGlobalRead: (reason) => {
+      const read = classifyUnattributableRead(reason);
+      if (read.scope === "container" /* Container */) {
+        for (const active of activeReads)
+          active.containerIds.add(read.containerId);
+      } else if (read.scope === "corpus" /* Corpus */) {
+        for (const active of activeReads) active.global = true;
+      }
+      args.readRecorder?.recordGlobalRead(reason);
+    }
+  };
+  const remember = (graph, rows) => {
+    graphRowsByRootId.set(graph.instanceRootId, rows);
+    for (const [id2, row] of graph.rowsById) {
+      expandedRowById.set(id2, row);
+      graphByValueId.set(id2, graph);
+      if (typeof row.value === "object" && row.value !== null) {
+        expandedRowByRecord.set(row.value, row);
+      }
+    }
+    for (const id2 of graph.locationsById.keys()) {
+      graphByValueId.set(id2, graph);
+    }
+    graphByValueId.set(graph.instanceRootId, graph);
+  };
   const expandRoot = (rootId, declaredMember) => {
     const cached = graphRowsByRootId.get(rootId);
-    if (cached !== void 0) return cached;
+    if (cached !== void 0) {
+      const reads2 = readsByRootId.get(rootId);
+      if (reads2 !== void 0) mergeReads(reads2);
+      return cached;
+    }
     if (failedRootIds.has(rootId)) return emptyRows;
     const instanceRoot = rawById.get(rootId);
     if (instanceRoot === void 0 || declaredMember === void 0) {
@@ -83189,6 +83514,12 @@ function createHeadlessVirtualInstanceResolver(args) {
       failedRootIds.add(rootId);
       return emptyRows;
     }
+    const reads = {
+      valueIds: /* @__PURE__ */ new Set(),
+      containerIds: /* @__PURE__ */ new Set(),
+      global: false
+    };
+    activeReads.push(reads);
     try {
       const resolverDocument = resolverDocumentOnce();
       materializedIndex ??= buildVirtualInstanceMaterializedIndex({
@@ -83201,33 +83532,52 @@ function createHeadlessVirtualInstanceResolver(args) {
         instanceRoot,
         rootMember: member,
         materializedIndex,
-        readRecorder: args.readRecorder
+        readRecorder: recorder
       });
       const rows = [...graph.rowsById.values()];
-      graphRowsByRootId.set(rootId, rows);
-      for (const [id2, row] of graph.rowsById) {
-        expandedRowById.set(id2, row);
-        graphByValueId.set(id2, graph);
-        if (typeof row.value === "object" && row.value !== null) {
-          expandedRowByRecord.set(row.value, row);
-        }
-      }
-      for (const id2 of graph.locationsById.keys()) {
-        graphByValueId.set(id2, graph);
-      }
-      graphByValueId.set(rootId, graph);
+      readsByRootId.set(rootId, reads);
+      remember(graph, rows);
       return rows;
     } catch {
       failedRootIds.add(rootId);
       return emptyRows;
-    }
+    } finally {
+      activeReads.pop();
+      mergeReads(reads);
+    }
+  };
+  const adoptSharedExpansion = (receiverValueId) => {
+    const share = args.shareFrom;
+    if (share === void 0 || share.masked(receiverValueId)) return null;
+    const adopted = sharedByReceiverId.get(receiverValueId);
+    if (adopted !== void 0) {
+      mergeReads(adopted.reads);
+      return adopted.rows;
+    }
+    const shared = share.resolver.shareExpansion(
+      receiverValueId,
+      share.masked,
+      share.containerChanged
+    );
+    if (shared === null) return null;
+    for (const id2 of shared.reads.valueIds) recorder.recordValueRead(id2);
+    for (const id2 of shared.reads.containerIds)
+      recorder.recordContainerMembershipRead(id2);
+    if (graphRowsByRootId.get(shared.graph.instanceRootId) === void 0) {
+      readsByRootId.set(shared.graph.instanceRootId, shared.reads);
+      remember(shared.graph, shared.rows);
+    }
+    sharedByReceiverId.set(receiverValueId, shared);
+    return shared.rows;
   };
   const virtualInstanceRowsForValue = (receiverValueId) => {
-    args.readRecorder?.recordValuePlacementRead();
-    args.readRecorder?.recordValueRead(receiverValueId);
+    const adopted = adoptSharedExpansion(receiverValueId);
+    if (adopted !== null) return adopted;
+    recorder.recordValuePlacementRead();
+    recorder.recordValueRead(receiverValueId);
     let placement = placements().get(receiverValueId) ?? null;
     while (placement !== null) {
-      args.readRecorder?.recordValueRead(placement.valueId);
+      recorder.recordValueRead(placement.valueId);
       const raw = rawById.get(placement.valueId);
       if (raw !== void 0 && isLiteralValueContent(raw) && isStoredClassResolutionRoot(raw)) {
         return expandRoot(
@@ -83257,6 +83607,33 @@ function createHeadlessVirtualInstanceResolver(args) {
       if (known !== void 0) return known;
       virtualInstanceRowsForValue(valueId);
       return graphByValueId.get(valueId) ?? null;
+    },
+    shareExpansion: (receiverValueId, masked, containerChanged) => {
+      const reads = {
+        valueIds: /* @__PURE__ */ new Set(),
+        containerIds: /* @__PURE__ */ new Set(),
+        global: false
+      };
+      activeReads.push(reads);
+      let rows;
+      try {
+        rows = virtualInstanceRowsForValue(receiverValueId);
+      } finally {
+        activeReads.pop();
+        mergeReads(reads);
+      }
+      const first = rows[0];
+      if (first === void 0 || reads.global) return null;
+      for (const id2 of reads.valueIds) if (masked(id2)) return null;
+      for (const id2 of reads.containerIds)
+        if (containerChanged(id2)) return null;
+      const graph = graphByValueId.get(first.id);
+      if (graph === void 0) {
+        throw new Error(
+          `Virtual expansion for receiver "${receiverValueId}" has rows but no graph.`
+        );
+      }
+      return { graph, rows, reads };
     }
   };
 }
@@ -83294,6 +83671,7 @@ var init_virtual_instance_graph = __esm({
     init_initializer_context();
     init_src();
     init_initializer_materialization();
+    init_unattributable_reads();
     KEPT_ROW_SAMPLE_LIMIT = 12;
     CORPUS_SCANNING_MEMBER_KINDS = /* @__PURE__ */ new Set([
       9 /* Lookup */,
@@ -83314,6 +83692,20 @@ var init_virtual_instance_graph = __esm({
 });
 
 // ../src/runtime/neoscript/evaluateInitializer.ts
+function sharedHeadlessResolver(overlay) {
+  const base = overlay.base;
+  if (base.databaseVM !== void 0) return void 0;
+  initializerEvaluatorLookups(base);
+  const resolver = headlessResolversByLookupKey.get(
+    initializerEvaluatorCacheKey(base)
+  );
+  if (resolver === void 0) return void 0;
+  return {
+    resolver,
+    masked: (id2) => overlay.rows.has(id2) || overlay.hiddenIds.has(id2),
+    containerChanged: (id2) => overlay.changedContainerIds.has(id2)
+  };
+}
 function initializerEvaluatorLookups(document, readTracking) {
   const trackedHeadless = readTracking !== void 0 && document.databaseVM === void 0;
   const indexKey = initializerEvaluatorCacheKey(document);
@@ -83378,10 +83770,12 @@ function initializerEvaluatorLookups(document, readTracking) {
     indexKey,
     revision
   );
+  const shareFrom = document.databaseVM === void 0 && document.evaluatorOverlay !== void 0 ? sharedHeadlessResolver(document.evaluatorOverlay) : void 0;
   const headlessVirtualResolver = document.databaseVM === void 0 ? createHeadlessVirtualInstanceResolver({
     evaluateInitializer: evaluateMemberInitializer,
     document,
     resolverLookups: () => lookups,
+    ...shareFrom === void 0 ? {} : { shareFrom },
     ...readTracking === void 0 ? {} : { readRecorder: virtualReadRecorder(readTracking) }
   }) : null;
   const lookups = {
@@ -83451,6 +83845,8 @@ function initializerEvaluatorLookups(document, readTracking) {
       revision,
       lookups
     });
+    if (headlessVirtualResolver !== null)
+      headlessResolversByLookupKey.set(lookupKey, headlessVirtualResolver);
   }
   return lookups;
 }
@@ -83459,10 +83855,18 @@ function indexedInitializerEvaluatorLookups(document, key, revision) {
   if (cached !== void 0 && (revision === void 0 ? cached.members === document.members && cached.values === document.values : cached.revision === revision)) {
     return cached.lookups;
   }
-  const lookups = makeEvaluatorLookups(document.members, document.values, {
+  const overlay = document.evaluatorOverlay;
+  const lookups = overlay === void 0 ? makeEvaluatorLookups(document.members, document.values, {
     includeValueGraphIndexes: true,
     constructorInitializerDocument: document
-  });
+  }) : layerEvaluatorLookups(
+    indexedInitializerEvaluatorLookups(
+      overlay.base,
+      initializerEvaluatorCacheKey(overlay.base),
+      initializerEvaluatorCacheRevision(overlay.base)
+    ),
+    overlay
+  );
   indexedEvaluatorLookupsByDocument.set(key, {
     members: document.members,
     values: document.values,
@@ -83772,7 +84176,10 @@ function evaluateMemberInitializer(args) {
     compiled,
     ctx,
     args.argumentValues ?? [],
-    { exportInitializerValues: true }
+    {
+      exportInitializerValues: true,
+      initializerResult: { member: args.member, genericEnv: args.genericEnv }
+    }
   );
   const created = result.createdSessionValues ?? [];
   if (isMemberLookupBase(args.member)) {
@@ -83812,7 +84219,7 @@ function evaluateMemberInitializer(args) {
     }
   };
 }
-var evaluatorLookupsByDocument, indexedEvaluatorLookupsByDocument;
+var evaluatorLookupsByDocument, headlessResolversByLookupKey, indexedEvaluatorLookupsByDocument;
 var init_evaluateInitializer = __esm({
   "../src/runtime/neoscript/evaluateInitializer.ts"() {
     "use strict";
@@ -83825,32 +84232,39 @@ var init_evaluateInitializer = __esm({
     init_virtual_instance_graph();
     init_initializer_context();
     evaluatorLookupsByDocument = /* @__PURE__ */ new WeakMap();
+    headlessResolversByLookupKey = /* @__PURE__ */ new WeakMap();
     indexedEvaluatorLookupsByDocument = /* @__PURE__ */ new WeakMap();
   }
 });
 
-// ../src/runtime/materialize-values.ts
-function materializeInitializerValue2(args) {
-  return materializeInitializerValue({
-    ...args,
-    evaluateInitializer: evaluateMemberInitializer
+// ../src/runtime/effective-value-reader.ts
+function rootReadScope(document) {
+  const cached = rootReadScopes.get(document);
+  if (cached !== void 0 && cached.members === document.members && cached.values === document.values && cached.variants === document.variants) {
+    return cached.scope;
+  }
+  const scope = withVariantOwnershipRoots(
+    expandPackedDocumentValues(document),
+    document.variants ?? []
+  );
+  const created = scope.document === document ? scope : {
+    ...scope,
+    document: { ...scope.document, evaluatorCache: void 0 }
+  };
+  rootReadScopes.set(document, {
+    members: document.members,
+    values: document.values,
+    variants: document.variants,
+    scope: created
   });
+  return created;
 }
-function materializeMemberDefaultValue2(args) {
-  return materializeMemberDefaultValue({
-    ...args,
-    evaluateInitializer: evaluateMemberInitializer
-  });
+function genericEnvironmentKey2(env) {
+  if (env === void 0 || env.size === 0) return "";
+  return canonicalJsonStringify(
+    [...env].sort(([left], [right]) => left.localeCompare(right))
+  );
 }
-var init_materialize_values = __esm({
-  "../src/runtime/materialize-values.ts"() {
-    "use strict";
-    init_evaluateInitializer();
-    init_initializer_materialization();
-  }
-});
-
-// ../src/runtime/effective-value-reader.ts
 function createTypedValueNormalizer(reader, document, childrenByContainerId, parameterTypesForRow, memberById2, memberTypeInfo, genericEnvironmentForRow, rowIdentities) {
   const visiting = /* @__PURE__ */ new Set();
   const completed = /* @__PURE__ */ new Map();
@@ -84092,7 +84506,7 @@ function isStringRecord5(value) {
 function isAggregateTypeInfo2(type) {
   return type.type === 7 /* Class */ || type.type === 22 /* Interface */ || type.type === 6 /* List */ || type.type === 5 /* Dictionary */;
 }
-var EffectiveValueReader;
+var rootReadScopes, EffectiveValueReader;
 var init_effective_value_reader = __esm({
   "../src/runtime/effective-value-reader.ts"() {
     "use strict";
@@ -84106,9 +84520,10 @@ var init_effective_value_reader = __esm({
     init_members();
     init_packed_value_encoding();
     init_read_class_member();
-    init_materialize_values();
+    init_initializer_materialization();
     init_evaluateInitializer();
     init_virtual_instance_graph();
+    rootReadScopes = /* @__PURE__ */ new WeakMap();
     EffectiveValueReader = class _EffectiveValueReader {
       constructor(document, overrides = /* @__PURE__ */ new Map(), context = {}, base) {
         this.document = document;
@@ -84120,18 +84535,12 @@ var init_effective_value_reader = __esm({
             "Effective value reads require a complete document snapshot; use initializerEvaluationSnapshot() for a live database."
           );
         }
+        this.root = base?.root ?? this;
         if (base === void 0) {
-          const expanded = expandPackedDocumentValues(document);
-          const scope = withVariantOwnershipRoots(
-            expanded,
-            document.variants ?? []
-          );
+          const scope = rootReadScope(document);
           this.document = scope.document;
           for (const [id2, member] of scope.rootMembersByValueId)
             this.placements.set(id2, member);
-        } else {
-          for (const [id2, member] of base.placements)
-            this.placements.set(id2, member);
         }
         if (overrides.size > 0) {
           const rows = [...overrides.values()];
@@ -84148,15 +84557,22 @@ var init_effective_value_reader = __esm({
       overrides;
       context;
       base;
+      root;
       schemas = /* @__PURE__ */ new Map();
       placements = /* @__PURE__ */ new Map();
       effectiveRows = /* @__PURE__ */ new Map();
-      defaultRows = /* @__PURE__ */ new WeakMap();
+      /** Declaration defaults by member identity and closed generic environment. */
+      defaultRows = /* @__PURE__ */ new Map();
+      /** Initializer-free declaration defaults, shared by every fork (root only). */
+      sharedDefaultRows = /* @__PURE__ */ new Map();
+      /** Every row a shared declaration default minted, readable from every fork. */
+      declarationRows = /* @__PURE__ */ new Map();
       effectiveChildren = /* @__PURE__ */ new Map();
       resolvedRoots = /* @__PURE__ */ new Set();
       normalizer;
       identityNormalizers = /* @__PURE__ */ new WeakMap();
       resolvedDocument;
+      indexedDocument;
       materializedIndex;
       graphCache;
       createNormalizer(rowIdentities) {
@@ -84164,33 +84580,87 @@ var init_effective_value_reader = __esm({
           this,
           this.document,
           { get: (id2) => this.children(id2) },
-          (row) => this.graph.constructorParameterTypes(row, this.placements.get(row.id)),
+          (row) => this.graph.constructorParameterTypes(row, this.placementFor(row.id)),
           (id2) => this.graph.memberForId(id2),
           (member, env) => this.graph.typeInfoForMember(member, env),
-          (row) => this.graph.genericEnvironmentForRow(row, this.placements.get(row.id)),
+          (row) => this.graph.genericEnvironmentForRow(row, this.placementFor(row.id)),
           rowIdentities
         );
       }
+      /** The base document with this context's override rows spliced in. */
       get readDocument() {
         if (this.resolvedDocument !== void 0) return this.resolvedDocument;
+        const baseDocument = this.base?.readDocument ?? this.document;
         if (this.overrides.size === 0)
-          return this.resolvedDocument = this.document;
+          return this.resolvedDocument = baseDocument;
         const values = [];
-        for (const row of this.document.values) {
-          if (this.overrides.has(row.id)) continue;
-          if (row.containerId && this.overrides.has(row.containerId)) continue;
+        const valuesById = /* @__PURE__ */ new Map();
+        const hiddenIds = /* @__PURE__ */ new Set();
+        const changedContainerIds = new Set(this.overrides.keys());
+        for (const row of baseDocument.values) {
+          if (this.overrides.has(row.id)) {
+            if (row.containerId) changedContainerIds.add(row.containerId);
+            continue;
+          }
+          if (row.containerId && this.overrides.has(row.containerId)) {
+            hiddenIds.add(row.id);
+            continue;
+          }
+          values.push(row);
+          valuesById.set(row.id, row);
+        }
+        for (const row of this.overrides.values()) {
+          if (row.containerId) changedContainerIds.add(row.containerId);
           values.push(row);
+          valuesById.set(row.id, row);
         }
-        for (const row of this.overrides.values()) values.push(row);
         this.resolvedDocument = {
-          ...this.document,
+          ...baseDocument,
           databaseVM: void 0,
-          valueById: void 0,
           evaluatorCache: void 0,
-          values
+          evaluatorOverlay: {
+            base: baseDocument,
+            rows: this.overrides,
+            hiddenIds,
+            changedContainerIds,
+            values,
+            valuesById
+          },
+          values,
+          valueById: (id2) => valuesById.get(id2) ?? null
         };
         return this.resolvedDocument;
       }
+      /**
+       * The root's read document with id indexes and the shared schema cache, so
+       * declaration-default materialization never scans the document for a row,
+       * a member, or a class schema.
+       */
+      get declarationDocument() {
+        if (this.indexedDocument !== void 0) return this.indexedDocument;
+        const document = this.readDocument;
+        this.indexedDocument = {
+          ...document,
+          // Same rows as the read document: share its evaluator indexes.
+          evaluatorCache: document.evaluatorCache ?? {
+            key: document,
+            revision: void 0
+          },
+          valueById: document.valueById ?? ((id2) => this.graph.valuesById.get(id2) ?? null),
+          memberById: document.memberById ?? ((id2) => this.memberForId(id2)),
+          storedInstanceSchema: (classId) => this.schema(classId)
+        };
+        return this.indexedDocument;
+      }
+      membersById;
+      memberForId(memberId) {
+        if (this.membersById === void 0) {
+          this.membersById = /* @__PURE__ */ new Map();
+          for (const member of this.document.members)
+            this.membersById.set(member.id, member);
+        }
+        return this.membersById.get(memberId) ?? null;
+      }
       get graph() {
         return this.base?.graph ?? (this.graphCache ??= new MaterializedValueGraphContext(
           this.document,
@@ -84198,8 +84668,25 @@ var init_effective_value_reader = __esm({
           this.placements
         ));
       }
+      schema(classId) {
+        const cached = this.root.schemas.get(classId);
+        if (cached !== void 0) return cached;
+        const schema = mergeStoredInstanceSchema(
+          classId,
+          this.document.classes,
+          this.document.members
+        );
+        this.root.schemas.set(classId, schema);
+        return schema;
+      }
       rawRow(id2) {
-        return this.overrides.get(id2) ?? this.base?.rawRow(id2) ?? this.graph.valuesById.get(id2);
+        const override = this.overrides.get(id2);
+        if (override !== void 0) return override;
+        if (this.base !== void 0) return this.base.rawRow(id2);
+        return this.declarationRows.get(id2) ?? this.graph.valuesById.get(id2);
+      }
+      placementFor(valueId) {
+        return this.placements.get(valueId) ?? this.base?.placementFor(valueId);
       }
       overrideChildren;
       rememberRows(rows) {
@@ -84252,21 +84739,13 @@ var init_effective_value_reader = __esm({
           return row;
         if (this.resolvedRoots.has(valueId)) return row;
         if (this.mode(valueId) === "partial") return row;
-        let schema = this.schemas.get(classId);
-        if (schema === void 0) {
-          schema = mergeStoredInstanceSchema(
-            classId,
-            this.document.classes,
-            this.document.members
-          );
-          this.schemas.set(classId, schema);
-        }
+        const schema = this.schema(classId);
         if (schema.every(
           (entry) => Object.prototype.hasOwnProperty.call(row.value, entry.schemaKey)
         ))
           return row;
         this.resolvedRoots.add(valueId);
-        const member = this.placements.get(valueId) ?? this.graph.ownerForValue(valueId) ?? {
+        const member = this.placementFor(valueId) ?? this.graph.ownerForValue(valueId) ?? {
           name: "Value",
           kind: 7 /* Class */,
           classId,
@@ -84318,26 +84797,52 @@ var init_effective_value_reader = __esm({
         return rows;
       }
       memberForValue(valueId) {
-        return this.placements.get(valueId) ?? this.graph.ownerForValue(valueId);
+        return this.placementFor(valueId) ?? this.graph.ownerForValue(valueId);
       }
       mode(valueId) {
         return getField(this.memberForValue(valueId), "payload") === 1 /* Partial */ ? "partial" : "runtime";
       }
+      /**
+       * The declared default graph for a member position.
+       *
+       * A default that evaluated no initializer is a clone of declaration rows,
+       * which no replay overrides, so the root reader keeps it for every fork. A
+       * default that ran an initializer read this context's document and stays
+       * with this context.
+       */
       declarationRow(member, genericEnv) {
-        const cached = this.defaultRows.get(member)?.get(genericEnv);
+        const memberId = getField(member, "id");
+        const memberKey = typeof memberId === "string" ? memberId : member;
+        const envKey = genericEnvironmentKey2(genericEnv);
+        const shared = this.root.sharedDefaultRows.get(memberKey)?.get(envKey);
+        if (shared !== void 0) return shared;
+        const cached = this.defaultRows.get(memberKey)?.get(envKey);
         if (cached !== void 0) return cached;
-        const result = materializeMemberDefaultValue2({
+        let evaluatedInitializer = false;
+        const result = materializeMemberDefaultValue({
           ...this.context,
-          document: this.readDocument,
+          evaluateInitializer: (args) => {
+            evaluatedInitializer = true;
+            return evaluateMemberInitializer(args);
+          },
+          document: this.declarationDocument,
           member,
           genericEnv,
           envelope: buildNewValue(this.document.project.id, { value: null }),
           declarationRoot: true
         });
-        this.rememberRows([result.root, ...result.createdValues]);
-        const contexts = this.defaultRows.get(member) ?? /* @__PURE__ */ new Map();
-        contexts.set(genericEnv, result.root);
-        this.defaultRows.set(member, contexts);
+        const rows = [result.root, ...result.createdValues];
+        const owner = evaluatedInitializer ? this : this.root;
+        owner.rememberRows(rows);
+        const cache = evaluatedInitializer ? owner.defaultRows : owner.sharedDefaultRows;
+        if (!evaluatedInitializer)
+          for (const row of rows) owner.declarationRows.set(row.id, row);
+        let contexts = cache.get(memberKey);
+        if (contexts === void 0) {
+          contexts = /* @__PURE__ */ new Map();
+          cache.set(memberKey, contexts);
+        }
+        contexts.set(envKey, result.root);
         return result.root;
       }
       normalizeConstructorArguments(args, root, placement) {
@@ -84360,12 +84865,7 @@ var init_effective_value_reader = __esm({
         return normalizer.normalizeTypedRow(valueId, typeInfo, placement, env);
       }
       withRowOverrides(rows) {
-        return new _EffectiveValueReader(
-          this.readDocument,
-          rows,
-          this.context,
-          this
-        );
+        return new _EffectiveValueReader(this.document, rows, this.context, this);
       }
     };
   }
@@ -84870,6 +85370,21 @@ var init_init_source = __esm({
   }
 });
 
+// ../src/runtime/materialize-values.ts
+function materializeInitializerValue2(args) {
+  return materializeInitializerValue({
+    ...args,
+    evaluateInitializer: evaluateMemberInitializer
+  });
+}
+var init_materialize_values = __esm({
+  "../src/runtime/materialize-values.ts"() {
+    "use strict";
+    init_evaluateInitializer();
+    init_initializer_materialization();
+  }
+});
+
 // ../src/database/project-read-base.ts
 import { ConvexError } from "convex/values";
 function readProjectReadBase(value) {
@@ -88884,16 +89399,26 @@ function collectStructuralDependencyRecords(document, currentDocument, changedCl
   return records2;
 }
 function classPlacementsForMember(memberId, document) {
-  const placements = /* @__PURE__ */ new Set();
-  for (const schemaClass2 of document.classes) {
-    const surface = mergeSchemas(
-      resolveInheritanceChain(schemaClass2.id, document.classes)
-    );
-    if (surface.some((entry) => entry.memberId === memberId)) {
-      placements.add(schemaClass2.id);
+  let index = classPlacementIndexes.get(document.classes);
+  if (index === void 0) {
+    const built = /* @__PURE__ */ new Map();
+    for (const schemaClass2 of document.classes) {
+      const surface = mergeSchemas(
+        resolveInheritanceChain(schemaClass2.id, document.classes)
+      );
+      for (const entry of surface) {
+        let owners = built.get(entry.memberId);
+        if (owners === void 0) {
+          owners = /* @__PURE__ */ new Set();
+          built.set(entry.memberId, owners);
+        }
+        owners.add(schemaClass2.id);
+      }
     }
+    index = built;
+    classPlacementIndexes.set(document.classes, index);
   }
-  return placements;
+  return index.get(memberId) ?? NO_PLACEMENTS;
 }
 function explicitTargetIds(changes) {
   const result = {
@@ -89149,7 +89674,7 @@ function withoutFields(value, ignored) {
     Object.entries(value).filter(([field]) => !ignored.has(field))
   );
 }
-var NON_CONTRACT_MEMBER_FIELDS, NS_PROPERTY_BODY_FIELDS, NS_FUNCTION_BODY_FIELDS;
+var NON_CONTRACT_MEMBER_FIELDS, NS_PROPERTY_BODY_FIELDS, NS_FUNCTION_BODY_FIELDS, NO_PLACEMENTS, classPlacementIndexes;
 var init_neo_script_recompile_scope = __esm({
   "../src/database/neo-script-recompile-scope.ts"() {
     "use strict";
@@ -89190,6 +89715,8 @@ var init_neo_script_recompile_scope = __esm({
       "bodyMode",
       "uiAction"
     ]);
+    NO_PLACEMENTS = /* @__PURE__ */ new Set();
+    classPlacementIndexes = /* @__PURE__ */ new WeakMap();
   }
 });
 
@@ -96782,11 +97309,8 @@ function materializePreparedInstanceInitializers(args) {
     compiledDocument,
     compiledDocument.variants ?? []
   );
-  let currentGraph = null;
-  const requireCurrentGraph = () => currentGraph ??= createVariantMaterializedValueGraphContext(
-    materializationScope.document,
-    materializationScope.document.variants ?? []
-  );
+  let currentReader = null;
+  const requireCurrentReader = () => currentReader ??= new EffectiveValueReader(materializationScope.document);
   const owners = resolveSemanticOwnerMembersForValues(
     materializationScope.document,
     new Set(sites.keys()),
@@ -96827,8 +97351,7 @@ function materializePreparedInstanceInitializers(args) {
         // scope that compiled and evaluated this initializer. Stored replay
         // closes its generic slot from the same ephemeral member id, so its
         // expansion must read that scoped document too.
-        currentDocument: materializationScope.document,
-        currentGraph: requireCurrentGraph(),
+        currentReader: requireCurrentReader(),
         currentRoot: existingRoot,
         rootMember: member,
         replayRoot: materialized.root,
@@ -96923,8 +97446,7 @@ function replayedCreationDataMatches(args) {
   if (replayArgs !== void 0 && replayArgs !== null) {
     const currentArgs = args.currentRoot.constructorArgs;
     if (currentArgs === void 0 || currentArgs === null || !constructorArgumentsSemanticallyEqual({
-      currentDocument: args.currentDocument,
-      currentGraph: args.currentGraph,
+      currentReader: args.currentReader,
       currentRoot: args.currentRoot,
       rootMember: args.rootMember,
       current: currentArgs,
@@ -97088,7 +97610,7 @@ function reconcileInitializerMaterializationTransport(args) {
   }
 }
 function constructorArgumentsSemanticallyEqual(args) {
-  const current = new EffectiveValueReader(args.currentDocument);
+  const current = args.currentReader;
   const replayRows = /* @__PURE__ */ new Map([
     [args.replayRoot.id, args.replayRoot]
   ]);
@@ -98651,7 +99173,8 @@ function materializeAuthoredSeedRow(args) {
   const literalArgs = { ...args, row: args.row };
   const rowCarriesCompleteConstructionRecipe = carriesCompleteConstructionRecipe(args.row);
   const belongsToSparseConstruction = args.sparseConstructionRoot || rowCarriesCompleteConstructionRecipe;
-  if (isMemberClassBase(resolvedStoredMember) && args.row.value !== null && !belongsToSparseConstruction) {
+  const rowIsStored = args.replaceExistingIds.has(args.row.id);
+  if (isMemberClassBase(resolvedStoredMember) && args.row.value !== null && !belongsToSparseConstruction && !rowIsStored) {
     return materializeLegacyAuthoredClassSeedRow({
       args: literalArgs,
       member: resolvedStoredMember
@@ -98983,7 +99506,8 @@ function isStringValueRecord(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value) && Object.values(value).every((entry) => typeof entry === "string");
 }
 function commitInitEvaluator(document, createdValues) {
-  return (member, init, sourceValueId) => evaluateMemberInitializer({
+  return (member, init, sourceValueId, genericEnv) => evaluateMemberInitializer({
+    genericEnv,
     init,
     member,
     document,
@@ -99002,10 +99526,19 @@ function assertConstructedGraphReferencesResolve(args) {
   const valueIds = new Set(args.document.values.map((value) => value.id));
   for (const site of sites) {
     if ((site.init.compiled?.parameters.length ?? 2) > 2) continue;
+    if (site.sourceValueId === void 0 && [
+      ...referencedGenericParams(
+        resolveMember2(site.member, args.document.members),
+        args.document.members
+      )
+    ].some((paramId) => site.genericEnv.get(paramId)?.kind !== "member"))
+      continue;
     const createdValues = [];
     const produced = evaluateMemberInitializer({
       init: site.init,
       member: site.member,
+      genericEnv: site.genericEnv,
+      sourceValueId: site.sourceValueId,
       document: args.document,
       createdValues
     });
@@ -99037,6 +99570,10 @@ function collectTouchedInitializerSites(args) {
     if (!isInitValueContent(member.defaultValue)) continue;
     if (!changedConstructor && !changedMemberIds.has(member.id)) continue;
     sites.push({
+      genericEnv: resolveDeclaringClassGenericEnv(
+        member.id,
+        args.document.classes
+      ),
       label: `Member "${member.name}" (${member.id})`,
       member,
       init: member.defaultValue.init
@@ -99064,6 +99601,8 @@ function collectTouchedInitializerSites(args) {
       );
     }
     sites.push({
+      genericEnv: envFromStamp(row.genericBindings),
+      sourceValueId: row.id,
       label: `Value "${row.id}"`,
       member,
       init: row.init
@@ -99080,11 +99619,19 @@ function assertProducedGraphLookupsResolve(args) {
     projectId: args.document.project.id,
     value: args.produced.value,
     classId: args.produced.classId,
+    ...args.produced.genericBindings === void 0 ? {} : { genericBindings: { ...args.produced.genericBindings } },
     ...args.produced.constructorArgs === void 0 ? {} : { constructorArgs: args.produced.constructorArgs },
     ...args.produced.instanceConstructorId === void 0 ? {} : { instanceConstructorId: args.produced.instanceConstructorId },
     createdAt: 0,
     updatedAt: 0
   };
+  if (args.produced.provisionalRootId !== void 0) {
+    retargetInitializerRootValueIds(
+      graphValues,
+      args.produced.provisionalRootId,
+      rootRow.id
+    );
+  }
   const ownerByValueId = resolveSemanticOwnerMembersForValues(
     { ...args.document, values: [...graphValues, rootRow] },
     new Set(args.createdValues.map((value) => value.id)),
@@ -99209,6 +99756,22 @@ function prepareServerOwnedValueInitializerBodies(args) {
   const currentValueById = new Map(
     args.document.values.map((value) => [value.id, value])
   );
+  const compilationProjects = /* @__PURE__ */ new WeakMap();
+  const compilationProjectFor = (document) => {
+    const cached = compilationProjects.get(document);
+    if (cached !== void 0) return cached;
+    const compilationProject = cachedServerCompilationProject({
+      project: document.project,
+      projectFiles: document.projectFiles,
+      members: document.members,
+      classes: document.classes,
+      enums: document.enums,
+      interfaces: document.interfaces,
+      constructors: document.constructors ?? []
+    });
+    compilationProjects.set(document, compilationProject);
+    return compilationProject;
+  };
   const compileOne = (document, row, documentValuesById) => {
     const member = ownerByValueId.get(row.id);
     if (member === void 0) {
@@ -99230,6 +99793,7 @@ function prepareServerOwnedValueInitializerBodies(args) {
       enums: document.enums,
       interfaces: document.interfaces,
       constructors: document.constructors ?? [],
+      compilationProject: compilationProjectFor(document),
       member,
       valueRow: row,
       valueId: row.id,
@@ -99413,21 +99977,29 @@ function compileInlineDelegateConstructorArguments(args) {
       env,
       document.members
     );
-    compiled[argumentKey] = compileDelegateClosureValue(argument2.code, {
-      project: document.project,
-      projectFiles: document.projectFiles,
-      members: document.members,
-      classes: document.classes,
-      enums: document.enums,
-      interfaces: document.interfaces,
-      constructors: document.constructors ?? [],
-      variants: document.variants ?? [],
-      variantFolders: document.variantFolders ?? [],
-      thisClass,
-      returnTypeInfo: substituted.returnTypeInfo,
-      argumentTypes: substituted.argumentTypes,
-      name: `${settledMember.name} argument`
-    });
+    try {
+      compiled[argumentKey] = compileDelegateClosureValue(argument2.code, {
+        project: document.project,
+        projectFiles: document.projectFiles,
+        members: document.members,
+        classes: document.classes,
+        enums: document.enums,
+        interfaces: document.interfaces,
+        constructors: document.constructors ?? [],
+        variants: document.variants ?? [],
+        variantFolders: document.variantFolders ?? [],
+        thisClass,
+        returnTypeInfo: substituted.returnTypeInfo,
+        argumentTypes: substituted.argumentTypes,
+        name: `${settledMember.name} argument`
+      });
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : String(error);
+      throw new Error(
+        `Value "${row.id}" (class "${schemaClass2.name}", root owner "${rootOwner?.name ?? "unknown"}") has a NeoDelegate closure for constructor parameter "${parameter4.name}" that does not compile: ${detail}`,
+        { cause: error }
+      );
+    }
   }
   return compiled;
 }
@@ -99470,8 +100042,9 @@ function prepareServerOwnedDelegateValueBodies(args) {
   const compileOne = (document, row) => {
     const member = ownerByValueId.get(row.id);
     if (!isMemberDelegateBase(member)) {
+      const placement = typeof row.containerId === "string" ? `container "${row.containerId}"` : `map key "${row.mapKey ?? "none"}"`;
       throw new Error(
-        `Value "${row.id}" carries a NeoDelegate closure but no NeoDelegate member in this project version stores it.`
+        `Value "${row.id}" (${placement}, owner ${member === void 0 ? "unresolved" : `"${member.name}" of kind ${member.kind}`}) carries a NeoDelegate closure but no NeoDelegate member in this project version stores it: ${row.value.code.slice(0, 120)}`
       );
     }
     const rootOwner = rootOwnerByValueId.get(row.id);
@@ -117805,9 +118378,24 @@ function prepareServerPreparationChanges(args) {
   };
   const prepareFull = (discardedScopedAttempt) => {
     if (discardedScopedAttempt) args.resetReplayIds?.();
-    return prepareServerOwnedSchemaCommit(preparationArgs);
+    const finish = startPerformanceSpan("server-preparation-full");
+    try {
+      return prepareServerOwnedSchemaCommit(preparationArgs);
+    } finally {
+      finish();
+    }
+  };
+  const validate2 = (prepared) => {
+    const finish = startPerformanceSpan("server-preparation-validate");
+    try {
+      assertProjectVersionWholeGraphWritesValid({
+        document,
+        changes: prepared
+      });
+    } finally {
+      finish();
+    }
   };
-  const validate2 = (prepared) => assertProjectVersionWholeGraphWritesValid({ document, changes: prepared });
   if (args.forceRecompile === true) {
     const prepared = prepareFull(false);
     validate2(prepared);
@@ -117865,9 +118453,15 @@ function prepareServerPreparationChanges(args) {
         document: scopedDocument,
         contentHashHeads: scopedHeads
       });
+      let lastPass = null;
       for (; ; ) {
+        const finishPass = startPerformanceSpan("server-preparation-pass", {
+          pass: lastPass === null ? COMMIT_PREPARATION_PASS_ORDER[0] : nextCommitPreparationPass(lastPass) ?? "final"
+        });
         const step = passes.next();
+        finishPass();
         if (step.done) return step.value;
+        lastPass = step.value.pass;
         const topUpRequest = planCommitPreparationInitialScope({
           pass: nextCommitPreparationPass(step.value.pass) ?? step.value.pass,
           document: scopedDocument,
@@ -118145,6 +118739,7 @@ var init_server_preparation_preflight = __esm({
     init_project_world_placement_bindings();
     init_build_default_member_value();
     init_packed_value_encoding();
+    init_performance();
     init_projection();
     init_trusted_commit_verification();
     ServerPreparationPreflightError = class extends Error {
@@ -118561,7 +119156,31 @@ function compilePulledMemberInitializerBodyV4(document, memberId, compilationPro
     ...compilationProject === void 0 ? {} : { compilationProject }
   });
 }
+function samePulledRecords(left, right) {
+  if (left === right) return true;
+  if (left.size !== right.size) return false;
+  for (const [key, record6] of left) {
+    const other = right.get(key);
+    if (other === void 0) return false;
+    if (other === record6) continue;
+    if (other.recordKind !== record6.recordKind || other.recordId !== record6.recordId || other.contentHash !== record6.contentHash || other.deleted !== record6.deleted || other.data !== record6.data) {
+      return false;
+    }
+  }
+  return true;
+}
 function readPulledProjectDocumentV4(records2) {
+  for (const recent of recentPulledDocuments) {
+    if (samePulledRecords(recent.records, records2)) return recent.document;
+  }
+  const document = readPulledProjectDocumentUncachedV4(records2);
+  recentPulledDocuments.unshift({ records: records2, document });
+  if (recentPulledDocuments.length > RECENT_PULLED_DOCUMENT_LIMIT) {
+    recentPulledDocuments.pop();
+  }
+  return document;
+}
+function readPulledProjectDocumentUncachedV4(records2) {
   const raw = structuredClone(
     pulledProjectDocumentRaw(
       replayWorkspace(completeProspectiveRecordCreateEnvelopes(records2))
@@ -118674,7 +119293,7 @@ function replayWorkspace(records2) {
     state: { records: stateRecords }
   };
 }
-var pulledBodyCompileSites, pulledInitializerCompilerStates, pulledMemberCompilationIndexes, pulledValueInitializerCompilationSites;
+var pulledBodyCompileSites, pulledInitializerCompilerStates, pulledMemberCompilationIndexes, pulledValueInitializerCompilationSites, recentPulledDocuments, RECENT_PULLED_DOCUMENT_LIMIT;
 var init_initializer_replay = __esm({
   "src/project-source/initializer-replay.ts"() {
     "use strict";
@@ -118693,6 +119312,8 @@ var init_initializer_replay = __esm({
     pulledInitializerCompilerStates = /* @__PURE__ */ new WeakMap();
     pulledMemberCompilationIndexes = /* @__PURE__ */ new WeakMap();
     pulledValueInitializerCompilationSites = /* @__PURE__ */ new WeakMap();
+    recentPulledDocuments = [];
+    RECENT_PULLED_DOCUMENT_LIMIT = 4;
   }
 });
 
@@ -129527,6 +130148,10 @@ function readProjectVersionTransactionStatus(value, transactionId) {
       value.preparationPhase ?? null,
       `Project transaction "${transactionId}" preparationPhase`
     ),
+    preparationStep: readNullableString(
+      value.preparationStep ?? null,
+      `Project transaction "${transactionId}" preparationStep`
+    ),
     preparationCompletedCount: readNullableCount(
       value.preparationCompletedCount ?? null,
       `Project transaction "${transactionId}" preparationCompletedCount`
@@ -129634,6 +130259,25 @@ function createPushProgressReporter(json) {
     }
   };
 }
+function isPreparationPass(name) {
+  return Object.hasOwn(PREPARATION_PASS_LABELS, name);
+}
+function preparationStepLabel(step) {
+  if (step.startsWith("pass:")) {
+    const pass = step.slice("pass:".length);
+    return isPreparationPass(pass) ? PREPARATION_PASS_LABELS[pass] : step;
+  }
+  switch (step) {
+    case "document-read":
+      return "reading records";
+    case "validate":
+      return "validating the graph";
+    case "plan":
+      return "planning writes";
+    default:
+      return step;
+  }
+}
 function projectTransactionProgressLabel(event) {
   if (event.type === "push-progress") {
     return `Uploading files\u2026 ${event.completedFiles.toLocaleString("en-US")}/${event.totalFiles.toLocaleString("en-US")} (${formatByteProgress(event.completedBytes)}/${formatByteProgress(event.totalBytes)})`;
@@ -129647,7 +130291,8 @@ function projectTransactionProgressLabel(event) {
       return "Verifying uploaded files on server\u2026";
     }
     if (event.preparationPhase === "compile") {
-      return "Compiling affected NeoScript on server\u2026";
+      const step = event.preparationStep ?? null;
+      return step === null ? "Compiling affected NeoScript on server\u2026" : `Compiling affected NeoScript on server\u2026 ${preparationStepLabel(step)}`;
     }
     if (typeof event.preparationCompletedCount === "number" && typeof event.preparationTotalCount === "number" && typeof event.preparationUnit === "string") {
       const remaining = Math.max(
@@ -129690,6 +130335,7 @@ function progressEventFromAccepted(accepted) {
     errorCode: null,
     errorMessage: null,
     preparationPhase: null,
+    preparationStep: null,
     preparationCompletedCount: null,
     preparationTotalCount: null,
     preparationUnit: null
@@ -129708,6 +130354,7 @@ function progressEventFromStatus(status) {
     errorCode: status.errorCode,
     errorMessage: status.errorMessage,
     preparationPhase: status.preparationPhase,
+    preparationStep: status.preparationStep,
     preparationCompletedCount: status.preparationCompletedCount,
     preparationTotalCount: status.preparationTotalCount,
     preparationUnit: status.preparationUnit
@@ -132445,7 +133092,7 @@ function compileMigrationAction(context, migrationData, locator) {
     locator
   );
 }
-var compileNSVoidBody2, compileNSFunction2, compileNSGetter2, compileNSSetter2, createNeoScriptCompilationProject2, ProjectTransactionInterruptedError, ProjectTransactionFailedError, LocalCandidateArtifactError, SERVER_MINTED_PUSH_RECORD_KINDS;
+var compileNSVoidBody2, compileNSFunction2, compileNSGetter2, compileNSSetter2, createNeoScriptCompilationProject2, ProjectTransactionInterruptedError, ProjectTransactionFailedError, PREPARATION_PASS_LABELS, LocalCandidateArtifactError, SERVER_MINTED_PUSH_RECORD_KINDS;
 var init_push = __esm({
   "src/commands/push.ts"() {
     "use strict";
@@ -132520,6 +133167,14 @@ var init_push = __esm({
       }
       status;
     };
+    PREPARATION_PASS_LABELS = {
+      "neo-script-recompile-targets": "selecting recompile targets",
+      "authored-value-seeds": "seeding authored values",
+      "variant-child-override-binding-members": "binding variant overrides",
+      "prepared-instance-initializers": "materializing initializers",
+      "delegate-value-bodies": "compiling delegate bodies",
+      "variant-constructor-args": "checking variant constructor arguments"
+    };
     LocalCandidateArtifactError = class extends Error {
       constructor(cause) {
         super(cause instanceof Error ? cause.message : String(cause));
@@ -133225,7 +133880,7 @@ import {
   rmSync as rmSync6,
   writeFileSync as writeFileSync9
 } from "node:fs";
-import { dirname as dirname9, join as join12, relative as relative7, sep as sep7 } from "node:path";
+import { dirname as dirname8, join as join12, relative as relative7, sep as sep7 } from "node:path";
 function prepareWorkspaceResetV4(workspace, document, options = {}) {
   const emissionRecords = options.regenerateSourceNames ? regenerateDialogueSourceNamesV4(document.records) : document.records;
   const layoutWorkspace = workspaceForSourceLayoutV4(workspace, document);
@@ -133265,7 +133920,7 @@ function resetWorkspaceToProjectSourcesV4(workspace, document, options = {}) {
   }
   for (const file of emitted.files) {
     const absolute = resolveSourcePath(file.path);
-    mkdirSync9(dirname9(absolute), { recursive: true });
+    mkdirSync9(dirname8(absolute), { recursive: true });
     if (existsSync10(absolute) && readFileSync14(absolute, "utf8") === file.content) {
       continue;
     }
@@ -133693,7 +134348,7 @@ import {
   existsSync as existsSync12,
   readFileSync as readFileSync15
 } from "node:fs";
-import { dirname as dirname10 } from "node:path";
+import { dirname as dirname9 } from "node:path";
 async function runPull(workspace, options, progress = spinner("Checking local workspace\u2026")) {
   if (options.reset) {
     await runResetPull(workspace, progress);
@@ -134178,7 +134833,7 @@ async function finishFormat4Pull(args) {
     if (content === void 0) continue;
     const marked = conflictPaths.has(path) && detectConflictMarkers(content) !== null;
     if (marked) markedPaths.add(path);
-    mkdirSync10(dirname10(absolute), { recursive: true });
+    mkdirSync10(dirname9(absolute), { recursive: true });
     if (existing !== null && !marked && !rewritePaths.has(path)) continue;
     if (existing !== content) {
       writeFileSync10(absolute, content, "utf8");
@@ -137722,7 +138377,7 @@ var init_registry2 = __esm({
   "schema-contract/registry.mjs"() {
     "use strict";
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
-      cliVersion: "0.52.4",
+      cliVersion: "0.53.0",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -139159,7 +139814,7 @@ import {
 } from "node:fs";
 import {
   basename as basename3,
-  dirname as dirname11,
+  dirname as dirname10,
   isAbsolute as isAbsolute3,
   join as join15,
   relative as relative8,
@@ -139451,7 +140106,7 @@ function cachedTestCandidate(workspace, inputFingerprint) {
     }
     if (typeof parsed.documentSha256 !== "string") return null;
     const documentJson = readFileSync18(
-      join15(dirname11(candidatePath), "document.json"),
+      join15(dirname10(candidatePath), "document.json"),
       "utf8"
     );
     if (createHash11("sha256").update(documentJson).digest("hex") !== parsed.documentSha256) {
@@ -139472,7 +140127,7 @@ function cacheTestCandidate(workspace, inputFingerprint, candidate) {
   const documentJson = JSON.stringify(candidate.document);
   const documentSha256 = createHash11("sha256").update(documentJson).digest("hex");
   const candidatePath = testCandidateCachePath(workspace, inputFingerprint);
-  atomicWrite(join15(dirname11(candidatePath), "document.json"), documentJson);
+  atomicWrite(join15(dirname10(candidatePath), "document.json"), documentJson);
   atomicWrite(
     candidatePath,
     JSON.stringify({
@@ -140316,7 +140971,7 @@ async function executeRegisteredSpec(registered, document, selected, timeoutMs,
   return { tests: results, failures: fileFailures, testDurationMs };
 }
 function atomicWrite(path, content) {
-  mkdirSync12(dirname11(path), { recursive: true });
+  mkdirSync12(dirname10(path), { recursive: true });
   const temporary = `${path}.tmp-${String(process.pid)}-${randomUUID6()}`;
   writeFileSync12(temporary, content, "utf8");
   renameSync7(temporary, path);
@@ -144857,7 +145512,7 @@ import {
   unlinkSync,
   writeFileSync as writeFileSync14
 } from "node:fs";
-import { dirname as dirname12, join as join18 } from "node:path";
+import { dirname as dirname11, join as join18 } from "node:path";
 function validatePath(path) {
   if (!/^Generated\/[a-zA-Z0-9_%./-]+\.g\.cs$/.test(path))
     throw new Error(`Invalid generated file path: ${path}`);
@@ -144980,7 +145635,7 @@ function writeUnityGeneratedFiles(directory, projectId, files) {
     if (content === null) {
       if (existsSync17(path)) unlinkSync(path);
     } else {
-      mkdirSync14(dirname12(path), { recursive: true });
+      mkdirSync14(dirname11(path), { recursive: true });
       writeFileSync14(path, content);
     }
   };
@@ -145595,7 +146250,7 @@ There is no --keep-current: preserving current semantic state defines flatten.
 async function main() {
   const args = parseArgs(process.argv.slice(2));
   if (args.command === "--version") {
-    console.log("0.52.4");
+    console.log("0.53.0");
     return;
   }
   if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {