@neocompose/cli 0.50.3 → 0.50.5

package/dist/neo.mjs

@@ -46293,6 +46293,41 @@ function resolveWorldSystemClassKind(classId, classes, draft) {
   }
   return null;
 }
+function indexWorldSystemClassKinds(classes, classesById = indexById2(classes)) {
+  const kinds = /* @__PURE__ */ new Map();
+  for (const schemaClass2 of classes) {
+    if (schemaClass2.system?.worldKind != null) {
+      kinds.set(schemaClass2.id, schemaClass2.system.worldKind);
+    } else if (schemaClass2.extendsClassId === void 0) {
+      kinds.set(schemaClass2.id, null);
+    }
+  }
+  const resolving = /* @__PURE__ */ new Set();
+  for (const schemaClass2 of classes) {
+    if (kinds.has(schemaClass2.id)) continue;
+    const path = [];
+    let current = schemaClass2;
+    let resolved = null;
+    while (current !== void 0) {
+      if (kinds.has(current.id)) {
+        resolved = kinds.get(current.id) ?? null;
+        break;
+      }
+      if (resolving.has(current.id)) {
+        resolved = null;
+        break;
+      }
+      resolving.add(current.id);
+      path.push(current);
+      current = current.extendsClassId === void 0 ? void 0 : classesById.get(current.extendsClassId);
+    }
+    for (const candidate of path) {
+      resolving.delete(candidate.id);
+      kinds.set(candidate.id, resolved);
+    }
+  }
+  return kinds;
+}
 function dedupeSchemaKeyOrder(order) {
   const seen = /* @__PURE__ */ new Set();
   const result = [];
@@ -70308,7 +70343,7 @@ var init_constructor_argument_ownership = __esm({
       membersById;
       constructorsById;
       contextualRootMembersByValueId;
-      parameterTypesByValueId = /* @__PURE__ */ new Map();
+      parameterTypesByRow = /* @__PURE__ */ new WeakMap();
       settleConstructorParameter;
       aggregateTypeByTargetValueId = /* @__PURE__ */ new Map();
       typedNormalizer;
@@ -70355,10 +70390,10 @@ var init_constructor_argument_ownership = __esm({
         return this.ownershipFacts().independentlyOwnedValueIds;
       }
       constructorParameterTypes(root) {
-        const cached = this.parameterTypesByValueId.get(root.id);
+        const cached = this.parameterTypesByRow.get(root);
         if (cached !== void 0) return cached;
         const result = this.resolveConstructorParameterTypes(root);
-        this.parameterTypesByValueId.set(root.id, result);
+        this.parameterTypesByRow.set(root, result);
         return result;
       }
       resolveConstructorParameterTypes(root) {
@@ -70806,6 +70841,10 @@ function validateInternalRecordRelations(args) {
   const classesById = new Map(
     args.classes.map((schemaClass2) => [schemaClass2.id, schemaClass2])
   );
+  const worldKindsByClassId = indexWorldSystemClassKinds(
+    args.classes,
+    classesById
+  );
   const relationIds = /* @__PURE__ */ new Set();
   const edgeKeys = /* @__PURE__ */ new Set();
   const orderedKeys2 = /* @__PURE__ */ new Set();
@@ -70870,7 +70909,7 @@ function validateInternalRecordRelations(args) {
       endpoint: "source",
       recordEndpoint: source,
       classesById,
-      classes: args.classes
+      worldKindsByClassId
     });
     validateWorldEndpoint({
       relation,
@@ -70878,7 +70917,7 @@ function validateInternalRecordRelations(args) {
       endpoint: "target",
       recordEndpoint: target,
       classesById,
-      classes: args.classes
+      worldKindsByClassId
     });
     const edgeKey = [
       relation.relationKind,
@@ -70937,13 +70976,6 @@ function validateInternalRecordRelations(args) {
     contracts: [...contracts.values()]
   });
 }
-function resolveEffectiveClassRelations(args) {
-  return createEffectiveClassRelationResolver({
-    classes: args.classes,
-    relations: args.relations,
-    contracts: args.contracts
-  }).resolve(args.relationKind, args.sourceClassId);
-}
 function createEffectiveClassRelationResolver(args) {
   const contracts = args.contracts ?? INTERNAL_RECORD_RELATION_KIND_CONTRACTS;
   const contractsByKind = /* @__PURE__ */ new Map();
@@ -71189,10 +71221,7 @@ function validateWorldEndpoint(args) {
       `Internal record relation "${args.relation.id}" ${args.endpoint} ${classLabel} "${classId}" does not exist.`
     );
   }
-  const actualWorldKind = resolveWorldSystemClassKind(
-    schemaClass2.id,
-    args.classes
-  );
+  const actualWorldKind = args.worldKindsByClassId.get(schemaClass2.id) ?? null;
   if (actualWorldKind !== requiredWorldKind) {
     throw new Error(
       `Internal record relation "${args.relation.id}" ${args.endpoint} ${classLabel} "${schemaClass2.id}" must extend world class kind "${requiredWorldKind}".`
@@ -71243,6 +71272,8 @@ function validateRelationCycles(relations, contracts) {
   for (const endpoint2 of outgoing.keys()) visit(endpoint2);
 }
 function validateDefaultLayerCompatibility(args) {
+  const resolver = createEffectiveClassRelationResolver(args);
+  const compatibleBySource = /* @__PURE__ */ new Map();
   const pairs = [
     {
       defaultKind: InternalRecordRelationKind.WorldTileDefaultLayer,
@@ -71256,16 +71287,15 @@ function validateDefaultLayerCompatibility(args) {
   for (const pair of pairs) {
     for (const relation of args.relations) {
       if (relation.relationKind !== pair.defaultKind) continue;
-      const compatible = resolveEffectiveClassRelations({
-        relationKind: pair.compatibleKind,
-        sourceClassId: relation.sourceRecordId,
-        relations: args.relations,
-        classes: args.classes,
-        contracts: args.contracts
-      });
-      if (compatible.some(
-        (effective) => effective.targetRecordId === relation.targetRecordId
-      )) {
+      const key = `${pair.compatibleKind}:${relation.sourceRecordId}`;
+      let compatible = compatibleBySource.get(key);
+      if (compatible === void 0) {
+        compatible = new Set(
+          resolver.resolve(pair.compatibleKind, relation.sourceRecordId).map((entry) => entry.targetRecordId)
+        );
+        compatibleBySource.set(key, compatible);
+      }
+      if (compatible.has(relation.targetRecordId)) {
         continue;
       }
       throw new Error(
@@ -71460,6 +71490,386 @@ 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) || !isStringRecord5(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 (!isStringRecord5(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 isStringRecord5(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/NeoScriptScope.ts
 var NeoScriptScope;
 var init_NeoScriptScope = __esm({
@@ -71883,6 +72293,72 @@ function makeEvaluatorLookups(members, storedValues, options = {}) {
   build.advance(Number.POSITIVE_INFINITY);
   return build.lookups;
 }
+function createInitializerBatchLookups(document) {
+  const values = [...expandPackedValueRows(document.values)];
+  const positions = new Map(values.map((row, index) => [row.id, index]));
+  const valuesById = new Map(values.map((row) => [row.id, row]));
+  const membersById = new Map(
+    document.members.map((member) => [member.id, member])
+  );
+  const membership = /* @__PURE__ */ new Map();
+  const sortedMembership = /* @__PURE__ */ new Map();
+  const indexMembership = (row, remove = false) => {
+    if (typeof row.containerId !== "string") return;
+    const entries = membership.get(row.containerId) ?? /* @__PURE__ */ new Set();
+    if (remove) entries.delete(row.id);
+    else entries.add(row.id);
+    membership.set(row.containerId, entries);
+    sortedMembership.delete(row.containerId);
+  };
+  for (const row of values) indexMembership(row);
+  const build = createEvaluatorBaseIndexBuild(
+    document.members,
+    values,
+    valuesById
+  );
+  build.advance(Number.POSITIVE_INFINITY);
+  const constructorInitializerIndexes2 = buildConstructorInitializerIndexes(document);
+  const snapshot = () => ({
+    memberById: (id2) => membersById.get(id2) ?? null,
+    valueById: (id2) => valuesById.get(id2) ?? null,
+    hasStoredValueId: (id2) => valuesById.has(id2),
+    unorderedListEntryIds: (id2) => {
+      let sorted = sortedMembership.get(id2);
+      if (sorted === void 0) {
+        sorted = [...membership.get(id2) ?? []].sort();
+        sortedMembership.set(id2, sorted);
+      }
+      return sorted;
+    },
+    rowForValueReference: (value) => build.result.rowByValueReference.get(value) ?? null,
+    virtualInstanceRowsForValue: () => [],
+    evaluatorIndexes: { ...build.result },
+    constructorInitializerIndexes: constructorInitializerIndexes2
+  });
+  return {
+    values,
+    valuesById,
+    membersById,
+    snapshot,
+    upsert(rows) {
+      for (const row of rows) {
+        const previous = valuesById.get(row.id);
+        if (previous === row) continue;
+        const membershipChanged = previous?.containerId !== row.containerId;
+        if (membershipChanged && previous !== void 0)
+          indexMembership(previous, true);
+        build.replaceRow(previous, row);
+        const position = positions.get(row.id);
+        if (position === void 0) {
+          positions.set(row.id, values.length);
+          values.push(row);
+        } else values[position] = row;
+        valuesById.set(row.id, row);
+        if (membershipChanged) indexMembership(row);
+      }
+    }
+  };
+}
 function evalMemberById(vm, id2) {
   if (vm.databaseVM?.memberById) return vm.databaseVM.memberById(id2);
   return vm.members.find((a) => a.id === id2) ?? null;
@@ -71978,6 +72454,10 @@ function createEvaluatorBaseIndexBuild(members, values, valueById) {
     get result() {
       return result;
     },
+    replaceRow(previous, row) {
+      if (previous !== void 0) unindexEvaluatorRow(indexes, previous, true);
+      indexEvaluatorRow(indexes, row);
+    },
     advance(maxRows) {
       if (result !== null) return true;
       const count = Math.max(1, Math.floor(maxRows));
@@ -72247,11 +72727,17 @@ function visitEvaluatorRecordOwnershipEdges(indexes, row, visit) {
   }
   return true;
 }
-function unindexEvaluatorRow(indexes, row) {
+function unindexEvaluatorRow(indexes, row, preserveIncomingLinks = false) {
   indexes.indexedRowIds.delete(row.id);
   indexes.ownedValueAttachmentsByValueId.delete(row.id);
   indexes.constructorOwnershipDirtyValueIds.delete(row.id);
-  indexes.parentLinksByChildId.delete(row.id);
+  if (!preserveIncomingLinks) indexes.parentLinksByChildId.delete(row.id);
+  else if (typeof row.containerId === "string") {
+    const retained = indexes.parentLinksByChildId.get(row.id)?.filter((link) => link.parentId !== row.containerId || link.key !== "");
+    if (retained === void 0 || retained.length === 0)
+      indexes.parentLinksByChildId.delete(row.id);
+    else indexes.parentLinksByChildId.set(row.id, retained);
+  }
   if (typeof row.value === "object" && row.value !== null && indexes.rowByValueReference.get(row.value) === row) {
     indexes.rowByValueReference.delete(row.value);
   }
@@ -76013,12 +76499,13 @@ function resolveRuntimeSchemaMember(receiver, schemaKey, ctx) {
   if (!runtimeClassId) return null;
   const memberId = cachedMergedSchemaMemberId(runtimeClassId, schemaKey, ctx);
   if (memberId === null) return null;
-  const member = evalMemberById(ctx.vm, memberId);
-  if (member === null) return null;
+  const rawMember = evalMemberById(ctx.vm, memberId);
+  if (rawMember === null) return null;
+  const member = cachedResolvedMember(rawMember, ctx);
   if (member.kind !== 21 /* Generic */) return member;
   const env = runtimeGenericEnvForValueRow(row, ctx, /* @__PURE__ */ new Set());
   try {
-    return substituteMember(member, env, ctx.vm.members);
+    return substituteMember(member, env, ctx.vm.members, member);
   } catch (error) {
     throw new NSGetterRuntimeError(
       `Cannot resolve runtime member '${member.name}' for Class '${runtimeClassId}': ${error instanceof Error ? error.message : String(error)}`
@@ -80932,216 +81419,6 @@ var init_evaluateNSGetter = __esm({
   }
 });
 
-// ../src/models/members/stored-value-placement-index.ts
-function buildStoredValuePlacementIndex(args) {
-  const membersById = /* @__PURE__ */ new Map();
-  for (const member of args.members) membersById.set(member.id, member);
-  const valuesById = /* @__PURE__ */ new Map();
-  const unorderedEntriesByContainerId = /* @__PURE__ */ new Map();
-  for (const value of args.values) {
-    valuesById.set(value.id, value);
-    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;
-  };
-  const queue = [];
-  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) || !isStringRecord5(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" && valuesById.has(childValueId)) {
-            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 (!isStringRecord5(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 */ ? unorderedEntriesByContainerId.get(value.id) ?? [] : 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
-      });
-    }
-  }
-  return {
-    placementByValueId,
-    placementsByClassId: mutablePlacementsByClassId,
-    placementsByKind: mutablePlacementsByKind,
-    placementsByMemberId: mutablePlacementsByMemberId
-  };
-}
-function appendPlacement(index, key, placement) {
-  const placements = index.get(key);
-  if (placements === void 0) {
-    index.set(key, [placement]);
-  } else {
-    placements.push(placement);
-  }
-}
-function isStringRecord5(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/initializer-materialization.ts
 function declarationInitializerContext(document) {
   const key = initializerEvaluatorCacheKey(document);
@@ -81392,6 +81669,22 @@ function buildVirtualInstanceMaterializedIndex(args) {
     })
   };
 }
+function createBatchVirtualInstanceMaterializedIndex(args) {
+  return {
+    rows: args.rows,
+    rowsById: args.rowsById,
+    graph: new MaterializedValueGraphContext({ ...args.document, values: [] }),
+    unorderedEntryIdsByContainerId: { get: args.unorderedListEntryIds },
+    constructorsById: new Map(
+      (args.document.constructors ?? []).map((row) => [row.id, row])
+    ),
+    resolveConstructorSettlement: createConstructorSettlementResolver({
+      classes: args.document.classes,
+      constructors: args.document.constructors ?? [],
+      members: args.document.members
+    })
+  };
+}
 function withoutInitializerConstructionFields(init) {
   if (init.compiled === void 0) return init;
   const baseline = deepClonePlainData(init);
@@ -81483,24 +81776,20 @@ function expandStoredInstance(args) {
   }
   const instanceRoot = literalRow(args.instanceRoot);
   const classId = instanceRoot.classId ?? rootMember.classId;
-  const schemaClass2 = args.document.classes.find(
-    (candidate) => candidate.id === classId
-  );
+  const schemaIndex = projectSchemaIndexFor(args.document);
+  const schemaClass2 = schemaIndex.class(classId);
   if (schemaClass2 === void 0) {
     throw new Error(
       `Virtual expansion root "${args.instanceRoot.id}" references missing class "${classId}".`
     );
   }
-  const constructors = args.document.constructors ?? [];
   if (instanceRoot.instanceConstructorId === void 0 && typeof instanceRoot.instanceVariantId !== "string") {
     throw new VirtualExpansionUnsupportedError(
       `Virtual expansion root "${args.instanceRoot.id}" carries no construction stamp for class "${classId}"; keep this historical graph materialized.`
     );
   }
   const recordedConstructorId = instanceRoot.instanceConstructorId === void 0 ? schemaClass2.requiredConstructorId ?? null : instanceRoot.instanceConstructorId;
-  const requiredConstructor = recordedConstructorId === null ? null : constructors.find(
-    (candidate) => candidate.id === recordedConstructorId
-  ) ?? null;
+  const requiredConstructor = recordedConstructorId === null ? null : schemaIndex.constructorRecord(recordedConstructorId) ?? null;
   if (recordedConstructorId !== null && requiredConstructor === null) {
     throw new Error(
       `Virtual expansion class "${classId}" references missing constructor "${recordedConstructorId}".`
@@ -83609,23 +83898,25 @@ function variantSwapDeclaredMember(document, rootValueId) {
 }
 function createHeadlessVirtualInstanceResolver(args) {
   const { document } = args;
+  const membersById = args.membersById ?? new Map(document.members.map((member) => [member.id, member]));
   let placementByValueId = null;
-  const placements = () => placementByValueId ??= buildStoredValuePlacementIndex({
+  const placements = () => placementByValueId ??= args.placementByValueId ?? buildStoredValuePlacementIndex({
     classes: document.classes,
     constructors: document.constructors ?? [],
     members: document.members,
     project: document.project,
-    resolveStaticValueId: (memberId) => document.members.find((member) => member.id === memberId)?.valueId ?? null,
+    resolveStaticValueId: (memberId) => membersById.get(memberId)?.valueId ?? null,
     values: document.values
   }).placementByValueId;
-  const rawById = new Map(document.values.map((row) => [row.id, row]));
+  const rawById = args.valuesById ?? new Map(document.values.map((row) => [row.id, row]));
   let resolverDocumentCache = null;
   const resolverDocumentOnce = () => resolverDocumentCache ??= composeResolverDocument(
     document,
     args.resolverLookups()
   );
-  let materializedIndex = null;
+  let materializedIndex = args.materializedIndex ?? null;
   const graphRowsByRootId = /* @__PURE__ */ new Map();
+  const emptyRows = [];
   const graphByValueId = /* @__PURE__ */ new Map();
   const failedRootIds = /* @__PURE__ */ new Set();
   const expandedRowById = /* @__PURE__ */ new Map();
@@ -83633,14 +83924,12 @@ function createHeadlessVirtualInstanceResolver(args) {
   const expandRoot = (rootId, memberId) => {
     const cached = graphRowsByRootId.get(rootId);
     if (cached !== void 0) return cached;
-    if (failedRootIds.has(rootId)) return /* @__PURE__ */ new Map();
+    if (failedRootIds.has(rootId)) return emptyRows;
     const instanceRoot = rawById.get(rootId);
-    const declaredMember = document.members.find(
-      (member2) => member2.id === memberId
-    );
+    const declaredMember = membersById.get(memberId);
     if (instanceRoot === void 0 || declaredMember === void 0) {
       failedRootIds.add(rootId);
-      return /* @__PURE__ */ new Map();
+      return emptyRows;
     }
     const member = storedClassResolutionMember(
       declaredMember,
@@ -83649,7 +83938,7 @@ function createHeadlessVirtualInstanceResolver(args) {
     );
     if (member === null || !isLiteralValueContent(instanceRoot)) {
       failedRootIds.add(rootId);
-      return /* @__PURE__ */ new Map();
+      return emptyRows;
     }
     try {
       const resolverDocument = resolverDocumentOnce();
@@ -83674,7 +83963,8 @@ function createHeadlessVirtualInstanceResolver(args) {
         materializedIndex,
         readRecorder: args.readRecorder
       });
-      graphRowsByRootId.set(rootId, graph.rowsById);
+      const rows = [...graph.rowsById.values()];
+      graphRowsByRootId.set(rootId, rows);
       for (const [id2, row] of graph.rowsById) {
         expandedRowById.set(id2, row);
         graphByValueId.set(id2, graph);
@@ -83686,10 +83976,10 @@ function createHeadlessVirtualInstanceResolver(args) {
         graphByValueId.set(id2, graph);
       }
       graphByValueId.set(rootId, graph);
-      return graph.rowsById;
+      return rows;
     } catch {
       failedRootIds.add(rootId);
-      return /* @__PURE__ */ new Map();
+      return emptyRows;
     }
   };
   const virtualInstanceRowsForValue = (receiverValueId) => {
@@ -83700,11 +83990,11 @@ function createHeadlessVirtualInstanceResolver(args) {
       args.readRecorder?.recordValueRead(placement.valueId);
       const raw = rawById.get(placement.valueId);
       if (raw !== void 0 && isLiteralValueContent(raw) && isStoredClassResolutionRoot(raw)) {
-        return [...expandRoot(placement.valueId, placement.memberId).values()];
+        return expandRoot(placement.valueId, placement.memberId);
       }
       placement = placement.parentValueId === null ? null : placements().get(placement.parentValueId) ?? null;
     }
-    return [];
+    return emptyRows;
   };
   return {
     virtualInstanceRowsForValue,
@@ -83724,6 +84014,7 @@ var init_virtual_instance_graph = __esm({
     "use strict";
     init_deep_clone_plain_data();
     init_inheritance();
+    init_project_schema_index();
     init_constructor_parameter_settlement();
     init_generics();
     init_classes();
@@ -83913,6 +84204,175 @@ function indexedInitializerEvaluatorLookups(document, key, revision) {
   });
   return lookups;
 }
+function createInitializerMaterializationBatch(authoredDocument) {
+  const indexed = createInitializerBatchLookups(authoredDocument);
+  const unorderedListEntryIds2 = indexed.snapshot().unorderedListEntryIds;
+  let materializedIndex;
+  let placementBatch;
+  const cachedById = /* @__PURE__ */ new Map();
+  const dependents = /* @__PURE__ */ new Map();
+  const globalReads = /* @__PURE__ */ new Set();
+  const expandedById = /* @__PURE__ */ new Map();
+  const expandedByReference = /* @__PURE__ */ new WeakMap();
+  const activeReads = [];
+  const recordRead = (id2) => {
+    for (const entry of activeReads) entry.reads.add(id2);
+  };
+  const recorder = {
+    recordValueRead: recordRead,
+    recordContainerMembershipRead: recordRead,
+    recordGlobalRead: () => {
+      for (const entry of activeReads) entry.global = true;
+    },
+    // Schema, variants and localization do not change during this batch.
+    recordLocalizedTextRead: () => {
+    },
+    recordVariantRead: () => {
+    },
+    recordStaticMemberRead: () => {
+    },
+    // Resolver placement walks record every ancestor id. Upserts below also
+    // invalidate old/new ownership targets, including newly attached rows.
+    recordValuePlacementRead: () => {
+    }
+  };
+  const invalidate = (entry) => {
+    for (const id2 of entry.aliases)
+      if (cachedById.get(id2) === entry) cachedById.delete(id2);
+    for (const id2 of entry.reads) {
+      const bucket = dependents.get(id2);
+      bucket?.delete(entry);
+      if (bucket?.size === 0) dependents.delete(id2);
+    }
+    for (const row of entry.rows) {
+      if (expandedById.get(row.id) === row) expandedById.delete(row.id);
+      if (typeof row.value === "object" && row.value !== null && expandedByReference.get(row.value) === row)
+        expandedByReference.delete(row.value);
+    }
+    globalReads.delete(entry);
+  };
+  return {
+    upsert(rows) {
+      const previousRows = [];
+      const touched = /* @__PURE__ */ new Set();
+      const visited = /* @__PURE__ */ new WeakSet();
+      const references = (value) => {
+        if (typeof value === "string") touched.add(value);
+        else if (typeof value === "object" && value !== null && !visited.has(value)) {
+          visited.add(value);
+          for (const child of Object.values(value)) references(child);
+        }
+      };
+      for (const row of rows) {
+        touched.add(row.id);
+        const previous = indexed.valuesById.get(row.id);
+        if (previous !== void 0) previousRows.push(previous);
+        for (const candidate of [previous, row]) {
+          if (candidate === void 0) continue;
+          if (typeof candidate.containerId === "string")
+            touched.add(candidate.containerId);
+          references(candidate.value);
+          if ("constructorArgs" in candidate)
+            references(candidate.constructorArgs);
+        }
+      }
+      const invalidated = new Set(globalReads);
+      for (const id2 of touched)
+        for (const entry of dependents.get(id2) ?? []) invalidated.add(entry);
+      for (const entry of invalidated) {
+        for (const alias of entry.aliases) {
+          for (const dependent of dependents.get(alias) ?? [])
+            invalidated.add(dependent);
+        }
+      }
+      for (const entry of invalidated) invalidate(entry);
+      indexed.upsert(rows);
+      placementBatch?.refresh(rows, previousRows);
+    },
+    document() {
+      const document = {
+        ...authoredDocument,
+        values: indexed.values,
+        valueById: (id2) => {
+          recordRead(id2);
+          return indexed.valuesById.get(id2) ?? null;
+        }
+      };
+      const base = indexed.snapshot();
+      let resolver;
+      const virtual = () => resolver ??= createHeadlessVirtualInstanceResolver({
+        evaluateInitializer: evaluateMemberInitializer,
+        document,
+        membersById: indexed.membersById,
+        valuesById: indexed.valuesById,
+        placementByValueId: (placementBatch ??= createStoredValuePlacementBatch({
+          ...authoredDocument,
+          values: indexed.values,
+          constructors: authoredDocument.constructors ?? [],
+          resolveStaticValueId: (id2) => indexed.membersById.get(id2)?.valueId ?? null,
+          indexedRows: {
+            valuesById: indexed.valuesById,
+            unorderedListEntryIds: unorderedListEntryIds2
+          }
+        })).placementByValueId,
+        materializedIndex: materializedIndex ??= createBatchVirtualInstanceMaterializedIndex({
+          document: authoredDocument,
+          rows: indexed.values,
+          rowsById: indexed.valuesById,
+          unorderedListEntryIds: unorderedListEntryIds2
+        }),
+        readRecorder: recorder,
+        resolverLookups: () => lookups
+      });
+      const lookups = {
+        ...base,
+        valueById: (id2) => base.valueById(id2) ?? expandedById.get(id2) ?? virtual().valueById(id2),
+        rowForValueReference: (value) => base.rowForValueReference(value) ?? expandedByReference.get(value) ?? virtual().rowForValueReference(value),
+        virtualInstanceRowsForValue: (id2) => {
+          const cached = cachedById.get(id2);
+          if (cached !== void 0) {
+            for (const read of cached.reads) recordRead(read);
+            if (cached.global) recorder.recordGlobalRead("cached-virtual-read");
+            return cached.rows;
+          }
+          const entry = {
+            rows: [],
+            reads: /* @__PURE__ */ new Set([id2]),
+            aliases: /* @__PURE__ */ new Set([id2]),
+            global: false
+          };
+          activeReads.push(entry);
+          try {
+            entry.rows = virtual().virtualInstanceRowsForValue(id2);
+          } finally {
+            activeReads.pop();
+          }
+          for (const row of entry.rows) {
+            entry.aliases.add(row.id);
+            expandedById.set(row.id, row);
+            if (typeof row.value === "object" && row.value !== null)
+              expandedByReference.set(row.value, row);
+          }
+          for (const alias of entry.aliases) cachedById.set(alias, entry);
+          for (const read of entry.reads) {
+            const bucket = dependents.get(read) ?? /* @__PURE__ */ new Set();
+            bucket.add(entry);
+            dependents.set(read, bucket);
+          }
+          if (entry.global) globalReads.add(entry);
+          return entry.rows;
+        },
+        resolveVariantInstanceGraph: (args) => resolveVariantInstanceGraphForDocument({
+          evaluateInitializer: evaluateMemberInitializer,
+          document,
+          resolverLookups: lookups,
+          ...args
+        })
+      };
+      return { ...document, databaseVM: lookups };
+    }
+  };
+}
 function buildInitializerRootValueWithLookups(document, lookups, tracking) {
   const rootValue = {};
   for (const { root, memberId } of projectRootMembersInDisplayOrder(
@@ -84086,6 +84546,7 @@ var init_evaluateInitializer = __esm({
     init_instance_provenance();
     init_members();
     init_project2();
+    init_stored_value_placement_index();
     init_evaluateNSGetter();
     init_virtual_instance_graph();
     evaluatorLookupsByDocument = /* @__PURE__ */ new WeakMap();
@@ -86238,7 +86699,13 @@ function collectNeoScriptRecompileImpact(args) {
   const dependentsById = /* @__PURE__ */ new Map();
   for (const record4 of [
     ...collectSchemaDependencyRecords(args.postDocument),
-    ...collectStructuralDependencyRecords(args.postDocument)
+    ...collectStructuralDependencyRecords(
+      args.postDocument,
+      args.currentDocument,
+      new Set(
+        args.changes.filter((change) => change.recordKind === "class").map((change) => change.recordId)
+      )
+    )
   ]) {
     for (const dependencyId of collectCompilerReferenceIds(record4.value)) {
       const dependents = dependentsById.get(dependencyId) ?? [];
@@ -86669,8 +87136,11 @@ function collectSchemaDependencyRecords(document) {
     }))
   ];
 }
-function collectStructuralDependencyRecords(document) {
+function collectStructuralDependencyRecords(document, currentDocument, changedClassIds) {
   const records2 = [];
+  const existingClassIds = new Set(
+    currentDocument.classes.map((schemaClass2) => schemaClass2.id)
+  );
   const resolver = new EffectiveStorageResolver({
     members: document.members,
     classes: document.classes,
@@ -86682,13 +87152,19 @@ function collectStructuralDependencyRecords(document) {
     }
   }
   for (const schemaClass2 of document.classes) {
-    for (const entry of mergeSchemas(
+    const memberIds = existingClassIds.has(schemaClass2.id) ? mergeSchemas(
       resolveInheritanceChain(schemaClass2.id, document.classes)
+    ).map((entry) => entry.memberId) : Object.values(schemaClass2.schema);
+    for (const memberId of memberIds) {
+      records2.push({ id: memberId, value: { classId: schemaClass2.id } });
+    }
+  }
+  for (const schemaClass2 of currentDocument.classes) {
+    if (!changedClassIds.has(schemaClass2.id)) continue;
+    for (const entry of mergeSchemas(
+      resolveInheritanceChain(schemaClass2.id, currentDocument.classes)
     )) {
-      records2.push({
-        id: entry.memberId,
-        value: { classId: schemaClass2.id }
-      });
+      records2.push({ id: entry.memberId, value: { classId: schemaClass2.id } });
     }
   }
   return records2;
@@ -94928,17 +95404,271 @@ var init_push_change_intent = __esm({
   }
 });
 
+// ../src/database/project-record-semantics.ts
+function projectRecordSemanticData(value) {
+  if (!isPlainRecord(value)) return value;
+  const semantic = {};
+  for (const [key, child] of Object.entries(value)) {
+    if (SERVER_MANAGED_PROJECT_RECORD_FIELDS.has(key)) continue;
+    semantic[key] = child;
+  }
+  return semantic;
+}
+function projectRecordDataIsSemanticallyEqual(left, right) {
+  return canonicalJsonStringify2(projectRecordSemanticData(left)) === canonicalJsonStringify2(projectRecordSemanticData(right));
+}
+function canonicalJsonStringify2(value) {
+  return JSON.stringify(toCanonicalJsonValue2(value));
+}
+function toCanonicalJsonValue2(value) {
+  if (value === null) return null;
+  if (value === void 0) return void 0;
+  if (value instanceof Date) return value.toISOString();
+  if (typeof value === "string" || typeof value === "boolean") return value;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new Error("Cannot canonicalize a non-finite number.");
+    }
+    return value;
+  }
+  if (typeof value === "bigint") {
+    throw new Error("Cannot canonicalize bigint values.");
+  }
+  if (typeof value === "symbol") {
+    throw new Error("Cannot canonicalize symbol values.");
+  }
+  if (typeof value === "function") {
+    throw new Error("Cannot canonicalize function values.");
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => toCanonicalJsonValue2(item) ?? null);
+  }
+  if (!isPlainRecord(value)) {
+    throw new Error("Cannot canonicalize a non-plain object.");
+  }
+  const canonical = {};
+  const entries = Object.entries(value).sort(
+    ([left], [right]) => left.localeCompare(right)
+  );
+  for (const [key, child] of entries) {
+    const canonicalChild = toCanonicalJsonValue2(child);
+    if (canonicalChild === void 0) continue;
+    canonical[key] = canonicalChild;
+  }
+  return canonical;
+}
+function isPlainRecord(value) {
+  if (value === null || typeof value !== "object") return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+var SERVER_MANAGED_PROJECT_RECORD_FIELDS;
+var init_project_record_semantics = __esm({
+  "../src/database/project-record-semantics.ts"() {
+    "use strict";
+    SERVER_MANAGED_PROJECT_RECORD_FIELDS = /* @__PURE__ */ new Set([
+      "_id",
+      "projectId",
+      "createdAt",
+      "updatedAt"
+    ]);
+  }
+});
+
+// ../src/database/project-version-relation-sweep-trigger.ts
+function stagedChangesAffectClassRelations(current, changes) {
+  const classesById = new Map(
+    (current.classes ?? []).map((schemaClass2) => [schemaClass2.id, schemaClass2])
+  );
+  const valuesById = new Map(
+    (current.values ?? []).map((value) => [value.id, value])
+  );
+  for (const change of changes) {
+    if (change.recordKind === "internal-record-relation") return true;
+    if (change.recordKind === "class") {
+      if (change.operation !== "update") return true;
+      if (change.deleted === true) return true;
+      const before2 = classesById.get(change.recordId);
+      if (before2 === void 0) return true;
+      const after = change.nextData;
+      if (!isPlainRecord2(after)) return true;
+      if (before2.extendsClassId !== after.extendsClassId) return true;
+      continue;
+    }
+    if (change.recordKind !== "value") continue;
+    const before = valuesById.get(change.recordId);
+    if (valueCreateCannotAffectClassRelations(change, before)) continue;
+    if (relationEndpointClassId(before) !== relationEndpointClassId(change.nextData)) {
+      return true;
+    }
+  }
+  return false;
+}
+function valueCreateCannotAffectClassRelations(change, before) {
+  if (change.operation !== "create") return false;
+  if (change.deleted === true) return false;
+  return before === void 0;
+}
+function relationEndpointClassId(record4) {
+  if (!isPlainRecord2(record4)) return void 0;
+  if (typeof record4.classId === "string") return record4.classId;
+  return void 0;
+}
+function isPlainRecord2(value) {
+  if (value === null || typeof value !== "object") return false;
+  return !Array.isArray(value);
+}
+var init_project_version_relation_sweep_trigger = __esm({
+  "../src/database/project-version-relation-sweep-trigger.ts"() {
+    "use strict";
+    init_internal_record_relations();
+    init_project_version_types();
+    init_project_record_semantics();
+  }
+});
+
+// ../src/database/project-world-placement-bindings.ts
+function hasWorldPlacementSidecar(value) {
+  if (!isPlainRecord3(value) || !isPlainRecord3(value.value)) return false;
+  const body = value.value;
+  if (typeof body.assetClassId === "string") return true;
+  if (typeof body.assetValueId === "string") return true;
+  if (isVariantRefValue(body)) return false;
+  return typeof body.variantId === "string";
+}
+function worldPlacementBindingChanged(before, after) {
+  return !projectRecordDataIsSemanticallyEqual(
+    worldPlacementBindingSlice(before),
+    worldPlacementBindingSlice(after)
+  );
+}
+function worldPlacementBindingSlice(value) {
+  if (!isPlainRecord3(value) || !isPlainRecord3(value.value)) return null;
+  return {
+    containerId: value.containerId ?? null,
+    assetClassId: value.value.assetClassId ?? null,
+    assetValueId: value.value.assetValueId ?? null,
+    rowValueId: value.value.rowValueId ?? null,
+    variantId: value.value.variantId ?? null
+  };
+}
+function ownedSparseValueBindingChanged(before, after) {
+  return !projectRecordDataIsSemanticallyEqual(
+    ownedSparseValueBindingSlice(before),
+    ownedSparseValueBindingSlice(after)
+  );
+}
+function ownedSparseValueBindingSlice(value) {
+  if (!isPlainRecord3(value)) return null;
+  return {
+    classId: value.classId ?? null,
+    containerId: value.containerId ?? null
+  };
+}
+function isPlainRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stagedChangesRequireWorldLayerBindingValidation(current, changes) {
+  const classesById = new Map(
+    current.classes.map((schemaClass2) => [schemaClass2.id, schemaClass2])
+  );
+  const valuesById = new Map(current.values.map((value) => [value.id, value]));
+  const valueChanges = [];
+  for (const change of changes) {
+    if (change.recordKind === "internal-record-relation") return true;
+    if (change.recordKind === "value") {
+      valueChanges.push(change);
+      continue;
+    }
+    if (change.recordKind !== "class") continue;
+    if (change.operation === "create" && change.deleted !== true && !classesById.has(change.recordId) && isPlainRecord3(change.nextData) && change.nextData.extendsClassId == null && change.nextData.system == null)
+      continue;
+    if (change.operation !== "update") return true;
+    if (change.deleted === true) return true;
+    const before = classesById.get(change.recordId);
+    if (before === void 0) return true;
+    const after = change.nextData;
+    if (!isPlainRecord3(after)) return true;
+    if (before.extendsClassId !== after.extendsClassId) return true;
+    if (isAbstractClass(before) !== isAbstractClass(after)) return true;
+    if (!worldClassSystemBlockIsEqual(before.system, after.system)) return true;
+  }
+  if (valueChanges.length === 0) return false;
+  const worldKinds = indexWorldSystemClassKinds(current.classes, classesById);
+  const changedValuesById = new Map(
+    valueChanges.map((change) => [change.recordId, change.nextData])
+  );
+  for (const change of valueChanges) {
+    const before = valuesById.get(change.recordId);
+    if (hasWorldLayerOverrideMetadata(before) || hasWorldLayerOverrideMetadata(change.nextData) || (hasWorldPlacementSidecar(before) || hasWorldPlacementSidecar(change.nextData)) && worldPlacementBindingChanged(
+      before,
+      change.deleted === true || change.operation === "delete" ? null : change.nextData
+    )) {
+      return true;
+    }
+    for (const row of ownedSparseValueBindingChanged(
+      before,
+      change.deleted === true || change.operation === "delete" ? null : change.nextData
+    ) ? [before, change.nextData] : []) {
+      if (!isPlainRecord3(row) || typeof row.containerId !== "string") continue;
+      for (const owner of [
+        valuesById.get(row.containerId),
+        changedValuesById.get(row.containerId)
+      ]) {
+        if (isPlainRecord3(owner) && isPlainRecord3(owner.value) && owner.value.assetValueId === change.recordId)
+          return true;
+      }
+    }
+    const classIds = [
+      relationEndpointClassId(before),
+      relationEndpointClassId(change.nextData)
+    ].filter((classId) => classId !== void 0);
+    for (const classId of classIds) {
+      const worldKind = worldKinds.get(classId);
+      if (worldKind === NeoWorldSystemClassKind.TileLayerLink) return true;
+      if (worldKind === NeoWorldSystemClassKind.ObjectLayerLink) return true;
+    }
+  }
+  return false;
+}
+function worldClassSystemBlockIsEqual(before, after) {
+  return projectRecordDataIsSemanticallyEqual(
+    { system: before },
+    { system: after }
+  );
+}
+function hasWorldLayerOverrideMetadata(record4) {
+  if (!isPlainRecord3(record4)) return false;
+  const value = record4.value;
+  if (!isPlainRecord3(value)) return false;
+  return typeof value.layerOverrideValueId === "string";
+}
+var init_project_world_placement_bindings = __esm({
+  "../src/database/project-world-placement-bindings.ts"() {
+    "use strict";
+    init_classes();
+    init_core();
+    init_project_version_relation_sweep_trigger();
+    init_members();
+    init_project_record_semantics();
+  }
+});
+
 // ../src/models/classes/world-layer-link-target.ts
 function validateWorldLayerLinkClassTargets(args) {
+  const relationResolver = createEffectiveClassRelationResolver(args);
+  const worldKindsByClassId = indexWorldSystemClassKinds(
+    args.classes,
+    relationResolver.classesById
+  );
   for (const schemaClass2 of args.classes) {
     if (args.classIds !== void 0 && !args.classIds.has(schemaClass2.id)) {
       continue;
     }
     const directWorldKind = schemaClass2.system?.worldKind;
     const isSystemLinkBase = directWorldKind === NeoWorldSystemClassKind.TileLayerLink || directWorldKind === NeoWorldSystemClassKind.ObjectLayerLink;
-    const descriptor = worldLayerLinkTargetDescriptorForClass(
-      schemaClass2.id,
-      args.classes
+    const descriptor = worldLayerLinkTargetDescriptor(
+      worldKindsByClassId.get(schemaClass2.id) ?? null
     );
     if (descriptor === null) continue;
     if (isSystemLinkBase) {
@@ -94947,10 +95677,9 @@ function validateWorldLayerLinkClassTargets(args) {
           `System layer-link base class "${schemaClass2.id}" must remain abstract.`
         );
       }
-      if (worldLayerLinkTargetRelations(
-        schemaClass2.id,
-        descriptor,
-        args.relations
+      if (relationResolver.directClassRelations(
+        descriptor.relationKind,
+        schemaClass2.id
       ).length > 0) {
         throw new Error(
           `System layer-link base class "${schemaClass2.id}" cannot declare a layer target relation.`
@@ -94963,7 +95692,9 @@ function validateWorldLayerLinkClassTargets(args) {
       classes: args.classes,
       linkLabel: `Concrete layer-link class "${schemaClass2.id}"`,
       relations: args.relations,
-      sourceClassId: schemaClass2.id
+      sourceClassId: schemaClass2.id,
+      relationResolver,
+      worldKindsByClassId
     });
   }
 }
@@ -94987,11 +95718,6 @@ function worldLayerLinkTargetDescriptor(worldKind) {
   }
   return null;
 }
-function worldLayerLinkTargetRelations(classId, descriptor, relations) {
-  return relations.filter(
-    (relation) => relation.relationKind === descriptor.relationKind && relation.sourceRecordKind === ProjectRecordKind.Class && relation.sourceRecordId === classId && relation.targetRecordKind === ProjectRecordKind.Class
-  );
-}
 function resolveWorldLayerLinkTarget(args) {
   const label = args.linkLabel ?? `Layer-link class "${args.sourceClassId}"`;
   const relationResolver = args.relationResolver ?? createEffectiveClassRelationResolver({
@@ -95077,6 +95803,34 @@ var init_world_layer_link_target = __esm({
 });
 
 // ../src/models/project/world-content-sidecar-validation.ts
+function cachedWorldLayerTarget(context, args) {
+  let target = context.linkTargetsByClassId.get(args.sourceClassId);
+  if (target === void 0) {
+    target = resolveWorldLayerLinkTarget({
+      ...args,
+      relationResolver: context.relationResolver,
+      worldKindsByClassId: context.worldKindsByClassId
+    }).targetClassId;
+    context.linkTargetsByClassId.set(args.sourceClassId, target);
+  }
+  return target;
+}
+function worldValidationContext(args) {
+  const relationResolver = createEffectiveClassRelationResolver(args);
+  return {
+    relationResolver,
+    worldKindsByClassId: indexWorldSystemClassKinds(
+      args.classes,
+      relationResolver.classesById
+    ),
+    targetIds: /* @__PURE__ */ new Map(),
+    linkTargetsByClassId: /* @__PURE__ */ new Map(),
+    variantsById: new Map(
+      args.variants.map((variant2) => [variant2.id, variant2])
+    ),
+    lookupRowSets: /* @__PURE__ */ new WeakMap()
+  };
+}
 function worldPlacementVariantBindings(args) {
   const foldersById = new Map(
     args.variantFolders.map((folder) => [folder.id, folder])
@@ -95085,12 +95839,15 @@ function worldPlacementVariantBindings(args) {
     args.members.map((member) => [member.id, member])
   );
   const valuesById = new Map(args.values.map((value) => [value.id, value]));
+  const containedRows = indexContainedRows(args.values);
+  const expandedGraphs = /* @__PURE__ */ new WeakMap();
   let cachedLookups = null;
   const expansionLookups = () => {
     return cachedLookups ??= initializerEvaluatorLookups(
       args.expansionDocument
     );
   };
+  const lookupEntriesByMember = /* @__PURE__ */ new Map();
   return args.variants.map((variant2) => {
     const folder = variant2.folderId === null ? null : foldersById.get(variant2.folderId) ?? null;
     const binding = folder?.binding ?? null;
@@ -95103,17 +95860,24 @@ function worldPlacementVariantBindings(args) {
         lookupRowValueIds: []
       };
     }
-    return {
-      id: variant2.id,
-      classId: variant2.classId,
-      lookupRowValueIds: lookupCollectionEntryIds({
+    let entriesByValue = lookupEntriesByMember.get(binding.collectionMemberId);
+    if (entriesByValue === void 0) {
+      entriesByValue = /* @__PURE__ */ new Map();
+      lookupEntriesByMember.set(binding.collectionMemberId, entriesByValue);
+    }
+    let lookupRowValueIds = entriesByValue.get(binding.collectionValueId);
+    if (lookupRowValueIds === void 0) {
+      lookupRowValueIds = lookupCollectionEntryIds({
         collection,
         collectionValueId: binding.collectionValueId,
         lookups: expansionLookups(),
-        values: args.values,
+        containedRows,
+        expandedGraphs,
         valuesById
-      })
-    };
+      });
+      entriesByValue.set(binding.collectionValueId, lookupRowValueIds);
+    }
+    return { id: variant2.id, classId: variant2.classId, lookupRowValueIds };
   });
 }
 function lookupCollectionEntryIds(args) {
@@ -95124,24 +95888,47 @@ function lookupCollectionEntryIds(args) {
   if (graphRows.length === 0) {
     const fallbackRow = storedRow ?? args.lookups.valueById(args.collectionValueId);
     if (fallbackRow === null || fallbackRow === void 0) return [];
-    return listEntryIdsForValue(args.collection, fallbackRow, args.values);
+    return listEntryIdsForValue(
+      args.collection,
+      fallbackRow,
+      args.containedRows.get(args.collectionValueId) ?? []
+    );
+  }
+  let graph = args.expandedGraphs.get(graphRows);
+  if (graph === void 0) {
+    graph = {
+      byId: new Map(graphRows.map((row) => [row.id, row])),
+      containedRows: indexContainedRows(graphRows)
+    };
+    args.expandedGraphs.set(graphRows, graph);
   }
-  const effectiveRows = [...args.values];
-  const graphRowsById = new Map(graphRows.map((row) => [row.id, row]));
-  for (const row of graphRows) {
-    if (args.valuesById.has(row.id)) continue;
-    effectiveRows.push(row);
+  const effectiveRows = [
+    ...args.containedRows.get(args.collectionValueId) ?? []
+  ];
+  for (const row of graph.containedRows.get(args.collectionValueId) ?? []) {
+    if (!args.valuesById.has(row.id)) effectiveRows.push(row);
   }
-  const collectionRow = graphRowsById.get(args.collectionValueId) ?? storedRow;
+  const collectionRow = graph.byId.get(args.collectionValueId) ?? storedRow;
   if (collectionRow === void 0) return [];
   return listEntryIdsForValue(args.collection, collectionRow, effectiveRows);
 }
+function indexContainedRows(values) {
+  const byContainer = /* @__PURE__ */ new Map();
+  for (const row of values) {
+    if (typeof row.containerId !== "string") continue;
+    const rows = byContainer.get(row.containerId) ?? [];
+    rows.push(row);
+    byContainer.set(row.containerId, rows);
+  }
+  return byContainer;
+}
 function validateWorldContentSidecars(args) {
+  const context = worldValidationContext(args);
   assertWorldLayerLinkValueBodiesCanonical({
     classes: args.classes,
-    values: args.values
+    values: args.values,
+    worldKindsByClassId: context.worldKindsByClassId
   });
-  const variants = args.variants;
   const valuesById = new Map(args.values.map((value) => [value.id, value]));
   const classesById = new Map(
     args.classes.map((schemaClass2) => [schemaClass2.id, schemaClass2])
@@ -95152,7 +95939,7 @@ function validateWorldContentSidecars(args) {
   const validatedPlacementIds = /* @__PURE__ */ new Set();
   const reachablePlacementIds = /* @__PURE__ */ new Set();
   for (const gridValue of args.values) {
-    if (worldKindForValue(gridValue, args.classes) !== NeoWorldSystemClassKind.TileGrid) {
+    if (worldKindForValue(gridValue, context.worldKindsByClassId) !== NeoWorldSystemClassKind.TileGrid) {
       continue;
     }
     const gridClassId = requiredValueClassId(gridValue, "tile-grid");
@@ -95165,27 +95952,23 @@ function validateWorldContentSidecars(args) {
     );
     if (childrenList === null) continue;
     const registeredTileLayers = effectiveTargetIds({
-      classes: args.classes,
+      context,
       relationKind: InternalRecordRelationKind.WorldGridTileLayer,
-      relations: args.relations,
       sourceClassId: gridClassId
     });
     const registeredObjectLayers = effectiveTargetIds({
-      classes: args.classes,
+      context,
       relationKind: InternalRecordRelationKind.WorldGridObjectLayer,
-      relations: args.relations,
       sourceClassId: gridClassId
     });
     const importedTiles = effectiveTargetIds({
-      classes: args.classes,
+      context,
       relationKind: InternalRecordRelationKind.WorldGridTileImport,
-      relations: args.relations,
       sourceClassId: gridClassId
     });
     const importedObjects = effectiveTargetIds({
-      classes: args.classes,
+      context,
       relationKind: InternalRecordRelationKind.WorldGridObjectImport,
-      relations: args.relations,
       sourceClassId: gridClassId
     });
     const overrideOwnerByLayerKey = /* @__PURE__ */ new Map();
@@ -95196,7 +95979,10 @@ function validateWorldContentSidecars(args) {
           `Grid value "${gridValue.id}" Children references missing value "${linkId}".`
         );
       }
-      const linkKind = worldKindForValue(linkValue, args.classes);
+      const linkKind = worldKindForValue(
+        linkValue,
+        context.worldKindsByClassId
+      );
       if (linkKind !== NeoWorldSystemClassKind.TileLayerLink && linkKind !== NeoWorldSystemClassKind.ObjectLayerLink) {
         continue;
       }
@@ -95214,12 +96000,12 @@ function validateWorldContentSidecars(args) {
         reachablePlacementIds.add(placementId);
       }
       const linkClassId = requiredValueClassId(linkValue, "layer-link");
-      const layerClassId = resolveWorldLayerLinkTarget({
+      const layerClassId = cachedWorldLayerTarget(context, {
         classes: args.classes,
         linkLabel: `Layer link value "${linkValue.id}"`,
         relations: args.relations,
         sourceClassId: linkClassId
-      }).targetClassId;
+      });
       const existingOwner = ownedLinkIds.get(linkValue.id);
       if (existingOwner !== void 0 && existingOwner !== gridValue.id) {
         throw new Error(
@@ -95231,7 +96017,7 @@ function validateWorldContentSidecars(args) {
       const expectedLayerKind = isTile ? NeoWorldSystemClassKind.TileLayer : NeoWorldSystemClassKind.ObjectLayer;
       assertConcreteWorldClass({
         classId: layerClassId,
-        classes: args.classes,
+        worldKindsByClassId: context.worldKindsByClassId,
         classesById,
         expectedKind: expectedLayerKind,
         label: `Layer link value "${linkValue.id}" target`
@@ -95271,15 +96057,13 @@ function validateWorldContentSidecars(args) {
           );
         }
         validateWorldPlacementSidecars({
-          classes: args.classes,
+          context,
           classesById,
           importedClassIds: isTile ? importedTiles : importedObjects,
           isTile,
           layerClassId,
-          variants,
           linkValueId: linkValue.id,
           placement,
-          relations: args.relations,
           valuesById
         });
         validatedPlacementIds.add(placement.id);
@@ -95288,7 +96072,7 @@ function validateWorldContentSidecars(args) {
   }
   for (const linkValue of args.values) {
     if (gridOwnedLinkIds.has(linkValue.id)) continue;
-    const linkKind = worldKindForValue(linkValue, args.classes);
+    const linkKind = worldKindForValue(linkValue, context.worldKindsByClassId);
     if (linkKind !== NeoWorldSystemClassKind.TileLayerLink && linkKind !== NeoWorldSystemClassKind.ObjectLayerLink) {
       continue;
     }
@@ -95296,15 +96080,15 @@ function validateWorldContentSidecars(args) {
     if (linkRecord === null) continue;
     const isTile = linkKind === NeoWorldSystemClassKind.TileLayerLink;
     const linkClassId = requiredValueClassId(linkValue, "layer-link");
-    const layerClassId = resolveWorldLayerLinkTarget({
+    const layerClassId = cachedWorldLayerTarget(context, {
       classes: args.classes,
       linkLabel: `Object-composition layer link value "${linkValue.id}"`,
       relations: args.relations,
       sourceClassId: linkClassId
-    }).targetClassId;
+    });
     assertConcreteWorldClass({
       classId: layerClassId,
-      classes: args.classes,
+      worldKindsByClassId: context.worldKindsByClassId,
       classesById,
       expectedKind: isTile ? NeoWorldSystemClassKind.TileLayer : NeoWorldSystemClassKind.ObjectLayer,
       label: `Object-composition layer link value "${linkValue.id}" target`
@@ -95335,15 +96119,13 @@ function validateWorldContentSidecars(args) {
         );
       }
       validateWorldPlacementSidecars({
-        classes: args.classes,
+        context,
         classesById,
         importedClassIds: null,
         isTile,
         layerClassId,
-        variants,
         linkValueId: linkValue.id,
         placement,
-        relations: args.relations,
         valuesById
       });
       reachablePlacementIds.add(placement.id);
@@ -95364,8 +96146,10 @@ function assertWorldLayerLinkValueBodiesCanonical(args) {
   const classesById = new Map(
     args.classes.map((schemaClass2) => [schemaClass2.id, schemaClass2])
   );
+  const worldKinds = args.worldKindsByClassId ?? indexWorldSystemClassKinds(args.classes, classesById);
+  const storedKeysByClassId = /* @__PURE__ */ new Map();
   for (const value of args.values) {
-    const worldKind = worldKindForValue(value, args.classes);
+    const worldKind = worldKindForValue(value, worldKinds);
     if (worldKind !== NeoWorldSystemClassKind.TileLayerLink && worldKind !== NeoWorldSystemClassKind.ObjectLayerLink) {
       continue;
     }
@@ -95375,6 +96159,7 @@ function assertWorldLayerLinkValueBodiesCanonical(args) {
     assertWorldLayerLinkBodyCanonical({
       body,
       classesById,
+      storedKeysByClassId,
       classId,
       worldKind,
       label: `Layer link value "${value.id}"`
@@ -95382,18 +96167,23 @@ function assertWorldLayerLinkValueBodiesCanonical(args) {
   }
 }
 function assertWorldLayerLinkBodyCanonical(args) {
-  const storedKeys = /* @__PURE__ */ new Set([
-    "layerOverrideValueId",
-    args.worldKind === NeoWorldSystemClassKind.TileLayerLink ? "Tiles" : "Objects"
-  ]);
-  const visited = /* @__PURE__ */ new Set();
-  let classId = args.classId;
-  while (classId !== null && !visited.has(classId)) {
-    visited.add(classId);
-    const schemaClass2 = args.classesById.get(classId);
-    if (schemaClass2 === void 0) break;
-    for (const key of Object.keys(schemaClass2.schema)) storedKeys.add(key);
-    classId = schemaClass2.extendsClassId ?? null;
+  let storedKeys = args.storedKeysByClassId.get(args.classId);
+  if (storedKeys === void 0) {
+    const keys = /* @__PURE__ */ new Set([
+      "layerOverrideValueId",
+      args.worldKind === NeoWorldSystemClassKind.TileLayerLink ? "Tiles" : "Objects"
+    ]);
+    const visited = /* @__PURE__ */ new Set();
+    let classId = args.classId;
+    while (classId !== null && !visited.has(classId)) {
+      visited.add(classId);
+      const schemaClass2 = args.classesById.get(classId);
+      if (schemaClass2 === void 0) break;
+      for (const key of Object.keys(schemaClass2.schema)) keys.add(key);
+      classId = schemaClass2.extendsClassId ?? null;
+    }
+    storedKeys = keys;
+    args.storedKeysByClassId.set(args.classId, storedKeys);
   }
   for (const key of Object.keys(args.body)) {
     if (storedKeys.has(key)) continue;
@@ -95417,7 +96207,7 @@ function validateWorldPlacementSidecars(args) {
   }
   assertConcreteWorldClass({
     classId: assetClassId,
-    classes: args.classes,
+    worldKindsByClassId: args.context.worldKindsByClassId,
     classesById: args.classesById,
     expectedKind: args.isTile ? NeoWorldSystemClassKind.Tile : NeoWorldSystemClassKind.Object,
     label: `Placement value "${args.placement.id}" assetClassId`
@@ -95428,9 +96218,8 @@ function validateWorldPlacementSidecars(args) {
     );
   }
   const compatibleLayerIds = effectiveTargetIds({
-    classes: args.classes,
+    context: args.context,
     relationKind: args.isTile ? InternalRecordRelationKind.WorldTileCompatibleLayer : InternalRecordRelationKind.WorldObjectCompatibleLayer,
-    relations: args.relations,
     sourceClassId: assetClassId
   });
   if (!compatibleLayerIds.has(args.layerClassId)) {
@@ -95451,7 +96240,7 @@ function validateWorldPlacementSidecars(args) {
     placementId: args.placement.id,
     variantId: optionalNonEmptyString(record4.variantId),
     rowValueId: optionalNonEmptyString(record4.rowValueId),
-    variants: args.variants
+    context: args.context
   });
 }
 function validatePlacementVariantBinding(args) {
@@ -95463,9 +96252,7 @@ function validatePlacementVariantBinding(args) {
     }
     return;
   }
-  const variant2 = args.variants.find(
-    (candidate) => candidate.id === args.variantId
-  );
+  const variant2 = args.context.variantsById.get(args.variantId);
   if (variant2 === void 0) {
     throw new Error(
       `Placement value "${args.placementId}" references variant "${args.variantId}", which does not resolve to a live variant record.`
@@ -95485,7 +96272,12 @@ function validatePlacementVariantBinding(args) {
     }
     return;
   }
-  if (args.rowValueId === null || !lookupRows.includes(args.rowValueId)) {
+  let rowIds = args.context.lookupRowSets.get(lookupRows);
+  if (rowIds === void 0) {
+    rowIds = new Set(lookupRows);
+    args.context.lookupRowSets.set(lookupRows, rowIds);
+  }
+  if (args.rowValueId === null || !rowIds.has(args.rowValueId)) {
     throw new Error(
       `Placement value "${args.placementId}" must bind a live row from lookup variant "${args.variantId}".`
     );
@@ -95522,7 +96314,7 @@ function assertConcreteWorldClass(args) {
       `${args.label} references missing class "${args.classId}".`
     );
   }
-  const actualKind = resolveWorldSystemClassKind(args.classId, args.classes);
+  const actualKind = args.worldKindsByClassId.get(args.classId) ?? null;
   if (actualKind !== args.expectedKind) {
     throw new Error(
       `${args.label} must reference world class kind "${args.expectedKind}", received "${String(actualKind)}".`
@@ -95533,14 +96325,18 @@ function assertConcreteWorldClass(args) {
   }
 }
 function effectiveTargetIds(args) {
-  return new Set(
-    resolveEffectiveClassRelations(args).map(
-      (relation) => relation.targetRecordId
-    )
-  );
+  const key = `${args.relationKind}:${args.sourceClassId}`;
+  let targets = args.context.targetIds.get(key);
+  if (targets === void 0) {
+    targets = new Set(
+      args.context.relationResolver.resolve(args.relationKind, args.sourceClassId).map((relation) => relation.targetRecordId)
+    );
+    args.context.targetIds.set(key, targets);
+  }
+  return targets;
 }
-function worldKindForValue(value, classes) {
-  return typeof value.classId === "string" ? resolveWorldSystemClassKind(value.classId, classes) : null;
+function worldKindForValue(value, worldKindsByClassId) {
+  return typeof value.classId === "string" ? worldKindsByClassId.get(value.classId) ?? null : null;
 }
 function requiredValueClassId(value, label) {
   if (typeof value.classId === "string" && value.classId.length > 0) {
@@ -95588,13 +96384,11 @@ function optionalNonEmptyString(value) {
   return typeof value === "string" && value.length > 0 ? value : null;
 }
 function consumeWorldPlacementSidecarKeys(args) {
-  const worldKind = resolveWorldSystemClassKind(args.classId, args.classes);
+  const worldKind = args.worldKindsByClassId === void 0 ? resolveWorldSystemClassKind(args.classId, args.classes) : args.worldKindsByClassId.get(args.classId) ?? null;
   if (worldKind === null) return /* @__PURE__ */ new Set();
   const assetKind = WORLD_PLACEMENT_ASSET_KIND.get(worldKind);
   if (assetKind === void 0) return /* @__PURE__ */ new Set();
-  const classesById = new Map(
-    args.classes.map((schemaClass2) => [schemaClass2.id, schemaClass2])
-  );
+  const classesById = args.classesById ?? new Map(args.classes.map((schemaClass2) => [schemaClass2.id, schemaClass2]));
   const present = /* @__PURE__ */ new Set();
   for (const key of WORLD_PLACEMENT_SIDECAR_KEYS) {
     if (!Object.hasOwn(args.body, key)) continue;
@@ -95609,7 +96403,7 @@ function consumeWorldPlacementSidecarKeys(args) {
   if (assetClassId !== null) {
     assertConcreteWorldClass({
       classId: assetClassId,
-      classes: args.classes,
+      worldKindsByClassId: args.worldKindsByClassId ?? indexWorldSystemClassKinds(args.classes, classesById),
       classesById,
       expectedKind: assetKind,
       label: `${args.label} assetClassId`
@@ -101089,129 +101883,6 @@ var init_general_function_call_ir_source_recompile = __esm({
   }
 });
 
-// ../src/database/project-record-semantics.ts
-function projectRecordSemanticData(value) {
-  if (!isPlainRecord(value)) return value;
-  const semantic = {};
-  for (const [key, child] of Object.entries(value)) {
-    if (SERVER_MANAGED_PROJECT_RECORD_FIELDS.has(key)) continue;
-    semantic[key] = child;
-  }
-  return semantic;
-}
-function projectRecordDataIsSemanticallyEqual(left, right) {
-  return canonicalJsonStringify2(projectRecordSemanticData(left)) === canonicalJsonStringify2(projectRecordSemanticData(right));
-}
-function canonicalJsonStringify2(value) {
-  return JSON.stringify(toCanonicalJsonValue2(value));
-}
-function toCanonicalJsonValue2(value) {
-  if (value === null) return null;
-  if (value === void 0) return void 0;
-  if (value instanceof Date) return value.toISOString();
-  if (typeof value === "string" || typeof value === "boolean") return value;
-  if (typeof value === "number") {
-    if (!Number.isFinite(value)) {
-      throw new Error("Cannot canonicalize a non-finite number.");
-    }
-    return value;
-  }
-  if (typeof value === "bigint") {
-    throw new Error("Cannot canonicalize bigint values.");
-  }
-  if (typeof value === "symbol") {
-    throw new Error("Cannot canonicalize symbol values.");
-  }
-  if (typeof value === "function") {
-    throw new Error("Cannot canonicalize function values.");
-  }
-  if (Array.isArray(value)) {
-    return value.map((item) => toCanonicalJsonValue2(item) ?? null);
-  }
-  if (!isPlainRecord(value)) {
-    throw new Error("Cannot canonicalize a non-plain object.");
-  }
-  const canonical = {};
-  const entries = Object.entries(value).sort(
-    ([left], [right]) => left.localeCompare(right)
-  );
-  for (const [key, child] of entries) {
-    const canonicalChild = toCanonicalJsonValue2(child);
-    if (canonicalChild === void 0) continue;
-    canonical[key] = canonicalChild;
-  }
-  return canonical;
-}
-function isPlainRecord(value) {
-  if (value === null || typeof value !== "object") return false;
-  const prototype = Object.getPrototypeOf(value);
-  return prototype === Object.prototype || prototype === null;
-}
-var SERVER_MANAGED_PROJECT_RECORD_FIELDS;
-var init_project_record_semantics = __esm({
-  "../src/database/project-record-semantics.ts"() {
-    "use strict";
-    SERVER_MANAGED_PROJECT_RECORD_FIELDS = /* @__PURE__ */ new Set([
-      "_id",
-      "projectId",
-      "createdAt",
-      "updatedAt"
-    ]);
-  }
-});
-
-// ../src/database/project-version-relation-sweep-trigger.ts
-function stagedChangesAffectClassRelations(current, changes) {
-  const classesById = new Map(
-    (current.classes ?? []).map((schemaClass2) => [schemaClass2.id, schemaClass2])
-  );
-  const valuesById = new Map(
-    (current.values ?? []).map((value) => [value.id, value])
-  );
-  for (const change of changes) {
-    if (change.recordKind === "internal-record-relation") return true;
-    if (change.recordKind === "class") {
-      if (change.operation !== "update") return true;
-      if (change.deleted === true) return true;
-      const before2 = classesById.get(change.recordId);
-      if (before2 === void 0) return true;
-      const after = change.nextData;
-      if (!isPlainRecord2(after)) return true;
-      if (before2.extendsClassId !== after.extendsClassId) return true;
-      continue;
-    }
-    if (change.recordKind !== "value") continue;
-    const before = valuesById.get(change.recordId);
-    if (valueCreateCannotAffectClassRelations(change, before)) continue;
-    if (relationEndpointClassId(before) !== relationEndpointClassId(change.nextData)) {
-      return true;
-    }
-  }
-  return false;
-}
-function valueCreateCannotAffectClassRelations(change, before) {
-  if (change.operation !== "create") return false;
-  if (change.deleted === true) return false;
-  return before === void 0;
-}
-function relationEndpointClassId(record4) {
-  if (!isPlainRecord2(record4)) return void 0;
-  if (typeof record4.classId === "string") return record4.classId;
-  return void 0;
-}
-function isPlainRecord2(value) {
-  if (value === null || typeof value !== "object") return false;
-  return !Array.isArray(value);
-}
-var init_project_version_relation_sweep_trigger = __esm({
-  "../src/database/project-version-relation-sweep-trigger.ts"() {
-    "use strict";
-    init_internal_record_relations();
-    init_project_version_types();
-    init_project_record_semantics();
-  }
-});
-
 // ../src/database/lookup-target-class-contract.ts
 function lookupTargetClassContractViolation(args) {
   const actualClassId = typeof args.targetClassId === "string" ? args.targetClassId : null;
@@ -101803,6 +102474,7 @@ var StaticBindingGraphValidator;
 var init_project_version_static_value_writes = __esm({
   "../src/database/project-version-static-value-writes.ts"() {
     "use strict";
+    init_classes();
     init_members();
     init_inheritance();
     init_generics();
@@ -101846,6 +102518,10 @@ var init_project_version_static_value_writes = __esm({
           enums: document.enums,
           constructors: document.constructors
         });
+        this.worldKindsByClassId = indexWorldSystemClassKinds(
+          this.schemaIndex.classes,
+          this.schemaIndex.classesById
+        );
         this.virtualValueIds = new Set(virtualValueIds);
         this.mergedView = merged ?? null;
       }
@@ -101858,6 +102534,7 @@ var init_project_version_static_value_writes = __esm({
       localizedTextIds = /* @__PURE__ */ new Set();
       dialogueIds = /* @__PURE__ */ new Set();
       schemaIndex;
+      worldKindsByClassId;
       virtualValueIds;
       declarationMaterializedIndex = null;
       stack = /* @__PURE__ */ new Set();
@@ -102068,6 +102745,8 @@ var init_project_version_static_value_writes = __esm({
           sidecarKeys: ({ body, classId, path }) => consumeWorldPlacementSidecarKeys({
             body,
             classes: this.schemaIndex.classes,
+            classesById: this.schemaIndex.classesById,
+            worldKindsByClassId: this.worldKindsByClassId,
             classId,
             label: path
           }),
@@ -102579,6 +103258,13 @@ function collectOwnedValueDeletionIds(args) {
 function createOwnedValueDeletionCollector(input, knownPlacements) {
   const scope = withVariantPlacementRoots(input);
   const document = scope.document;
+  const classesById = new Map(
+    document.classes.map((schemaClass2) => [schemaClass2.id, schemaClass2])
+  );
+  const worldKindsByClassId = indexWorldSystemClassKinds(
+    document.classes,
+    classesById
+  );
   const stored = new Map(document.values.map((row) => [row.id, row]));
   const members = new Map(
     document.members.map((member) => [member.id, member])
@@ -102827,16 +103513,15 @@ function createOwnedValueDeletionCollector(input, knownPlacements) {
             const sidecars = consumeWorldPlacementSidecarKeys({
               body: record4,
               classes: document.classes,
+              classesById,
+              worldKindsByClassId,
               classId,
               label: `Value "${body.id}"`
             });
             for (const key of ["assetValueId", "layerOverrideValueId"]) {
               if (key === "assetValueId" && !sidecars.has(key)) continue;
               if (key === "layerOverrideValueId") {
-                const worldKind = resolveWorldSystemClassKind(
-                  classId,
-                  document.classes
-                );
+                const worldKind = worldKindsByClassId.get(classId);
                 if (worldKind !== NeoWorldSystemClassKind.TileLayerLink && worldKind !== NeoWorldSystemClassKind.ObjectLayerLink)
                   continue;
               }
@@ -104721,6 +105406,7 @@ function drainConstructedGraphValidations(args) {
   }
 }
 function indexAuthoredSeedDocument(document) {
+  const classesById = indexRecordsById(document.classes);
   const declaringClassIdsByMemberId = /* @__PURE__ */ new Map();
   for (const schemaClass2 of document.classes) {
     const declared = /* @__PURE__ */ new Set();
@@ -104737,6 +105423,11 @@ function indexAuthoredSeedDocument(document) {
     }
   }
   return {
+    classesById,
+    worldKindsByClassId: indexWorldSystemClassKinds(
+      document.classes,
+      classesById
+    ),
     valuesById: indexRecordsById(document.values),
     membersById: indexRecordsById(document.members),
     localizedTextIds: new Set(
@@ -105838,6 +106529,8 @@ function materializeAuthoredClassFields(args) {
   const sidecarKeys = consumeWorldPlacementSidecarKeys({
     body: args.row.value,
     classes: args.document.classes,
+    classesById: args.documentIndex.classesById,
+    worldKindsByClassId: args.documentIndex.worldKindsByClassId,
     classId: effectiveClassId,
     label: `Placement value "${args.row.id}"`
   });
@@ -107091,6 +107784,7 @@ var SERVER_COMPILATION_PROJECT_CACHE_LIMIT, serverCompilationProjectCache, READ_
 var init_project_version_schema_commit = __esm({
   "../src/database/project-version-schema-commit.ts"() {
     "use strict";
+    init_classes();
     init_members();
     init_neo_script_derived_bodies();
     init_localized_instance_override_writes();
@@ -107262,7 +107956,7 @@ function systemProtectedWriteInheritedRecordId(write) {
   if (write.baseData !== void 0) return null;
   if (write.deleted) return null;
   if (!isSystemBearingRecordKind(write.recordKind)) return null;
-  if (!isPlainRecord3(write.nextData)) return null;
+  if (!isPlainRecord4(write.nextData)) return null;
   if (readSystemMetadata(write.nextData) === null) return null;
   const extendsMemberId = write.nextData.extendsMemberId;
   if (typeof extendsMemberId !== "string") return null;
@@ -107282,7 +107976,7 @@ function assertSystemProtectedRecordWriteValid(write) {
   assertSystemMetadataUnchanged(write, base);
 }
 function readBaseRecord(write) {
-  if (!isPlainRecord3(write.baseData)) return null;
+  if (!isPlainRecord4(write.baseData)) return null;
   return {
     recordKind: write.recordKind,
     data: write.baseData,
@@ -107295,7 +107989,7 @@ function collectSystemBearingBaseRecords(document) {
     const stored = document[collection];
     if (!Array.isArray(stored)) continue;
     for (const record4 of stored) {
-      if (!isPlainRecord3(record4)) continue;
+      if (!isPlainRecord4(record4)) continue;
       const id2 = record4.id;
       if (typeof id2 !== "string") continue;
       records2.set(baseKey(recordKind, id2), {
@@ -107309,7 +108003,7 @@ function collectSystemBearingBaseRecords(document) {
 }
 function assertCreateDeclaresNoSystemMetadata(write) {
   if (!isSystemBearingRecordKind(write.recordKind)) return;
-  if (!isPlainRecord3(write.nextData)) return;
+  if (!isPlainRecord4(write.nextData)) return;
   const system = readSystemMetadata(write.nextData);
   if (system === null) return;
   if (inheritsLegacyEmittedSystemMetadata(write, system)) return;
@@ -107335,7 +108029,7 @@ function assertProtectedRecordNotEdited(change, base) {
   )) {
     return;
   }
-  if (!isPlainRecord3(change.nextData)) return;
+  if (!isPlainRecord4(change.nextData)) return;
   if (authoredFieldsEqual(change.recordKind, base.data, change.nextData)) {
     return;
   }
@@ -107344,7 +108038,7 @@ function assertProtectedRecordNotEdited(change, base) {
   );
 }
 function assertSystemMetadataUnchanged(change, base) {
-  if (!isPlainRecord3(change.nextData)) return;
+  if (!isPlainRecord4(change.nextData)) return;
   const next = readSystemMetadata(change.nextData);
   if (systemMetadataEqual(base.system, next)) return;
   throw new Error(
@@ -107395,10 +108089,10 @@ function repointedChildValueIds(document, change) {
   );
   if (baseValue === void 0) return [];
   const before = baseValue.value;
-  if (!isPlainRecord3(before)) return [];
-  if (!isPlainRecord3(change.nextData)) return [];
+  if (!isPlainRecord4(before)) return [];
+  if (!isPlainRecord4(change.nextData)) return [];
   const after = change.nextData.value;
-  if (!isPlainRecord3(after)) return [];
+  if (!isPlainRecord4(after)) return [];
   return Object.entries(before).flatMap(([schemaKey, childValueId]) => {
     if (typeof childValueId !== "string") return [];
     if (after[schemaKey] === childValueId) return [];
@@ -107433,7 +108127,7 @@ function isSystemBearingRecordKind(recordKind) {
   );
 }
 function readSystemMetadata(record4) {
-  if (!isPlainRecord3(record4)) return null;
+  if (!isPlainRecord4(record4)) return null;
   const system = record4.system;
   if (!isSystemMetadata(system)) return null;
   return system;
@@ -107452,11 +108146,11 @@ function systemReason(system) {
   return SYSTEM_PROTECTION_RULES[system.kind].serverReason;
 }
 function describeChangedRecord(recordKind, recordId, record4) {
-  const name = isPlainRecord3(record4) ? record4.name : void 0;
+  const name = isPlainRecord4(record4) ? record4.name : void 0;
   if (typeof name !== "string") return `Record ${recordKind} "${recordId}"`;
   return `Record ${recordKind} "${name}" (${recordId})`;
 }
-function isPlainRecord3(value) {
+function isPlainRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function baseKey(recordKind, recordId) {
@@ -107587,7 +108281,7 @@ function readWorldReferenceList(args) {
     args.keyCandidates
   );
   if (schemaKey === null) return [];
-  if (!isPlainRecord4(args.ownerValue.value)) return [];
+  if (!isPlainRecord5(args.ownerValue.value)) return [];
   const listValueId = args.ownerValue.value[schemaKey];
   if (typeof listValueId !== "string") return [];
   const listValue2 = args.graph.valuesById.get(listValueId);
@@ -107653,18 +108347,18 @@ function worldReferenceClassInherits(graph, classId, ancestorClassId) {
   return false;
 }
 function toWorldReferenceClassRecord(value) {
-  if (!isPlainRecord4(value)) return null;
+  if (!isPlainRecord5(value)) return null;
   const id2 = stringField2(value, "id");
   if (id2 === null) return null;
   return {
     id: id2,
     extendsClassId: nullableStringField(value, "extendsClassId"),
     schema: isStringRecord8(value.schema) ? value.schema : void 0,
-    system: isPlainRecord4(value.system) ? value.system : null
+    system: isPlainRecord5(value.system) ? value.system : null
   };
 }
 function toWorldReferenceValueRecord(value) {
-  if (!isPlainRecord4(value)) return null;
+  if (!isPlainRecord5(value)) return null;
   const id2 = stringField2(value, "id");
   if (id2 === null) return null;
   return {
@@ -107678,10 +108372,10 @@ function worldReferenceValueClassId(value) {
   return typeof value.classId === "string" && value.classId.length > 0 ? value.classId : null;
 }
 function isStringRecord8(value) {
-  if (!isPlainRecord4(value)) return false;
+  if (!isPlainRecord5(value)) return false;
   return Object.values(value).every((entry) => typeof entry === "string");
 }
-function isPlainRecord4(value) {
+function isPlainRecord5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function stringField2(value, key) {
@@ -107887,6 +108581,7 @@ function materializeDeclarationInitializersForAnimationValidation(document) {
   const valuesById = new Map(
     document.values.map((value) => [value.id, value])
   );
+  const materializationBatch = createInitializerMaterializationBatch(document);
   let members = document.members;
   const deferred = /* @__PURE__ */ new Set();
   if (defaultInitializerMemberIds.size > 0) {
@@ -107902,7 +108597,7 @@ function materializeDeclarationInitializersForAnimationValidation(document) {
         return deferredMember;
       }
       const materialized = materializeInitializerValue2({
-        document: { ...document, values: [...valuesById.values()] },
+        document: materializationBatch.document(),
         member,
         row: {
           id: `animation-validation-default:${member.id}`,
@@ -107912,6 +108607,7 @@ function materializeDeclarationInitializersForAnimationValidation(document) {
           updatedAt: 0
         }
       });
+      materializationBatch.upsert(materialized.createdValues);
       for (const created of materialized.createdValues) {
         valuesById.set(created.id, created);
       }
@@ -107936,10 +108632,14 @@ function materializeDeclarationInitializersForAnimationValidation(document) {
       continue;
     }
     const materialized = materializeInitializerValue2({
-      document: { ...document, values: [...valuesById.values()] },
+      document: materializationBatch.document(),
       member,
       row
     });
+    materializationBatch.upsert([
+      materialized.root,
+      ...materialized.createdValues
+    ]);
     valuesById.set(materialized.root.id, materialized.root);
     for (const created of materialized.createdValues) {
       valuesById.set(created.id, created);
@@ -108088,54 +108788,6 @@ function assertStagedWorldContentLayerBindingsValid(current, projected, changes)
     })
   });
 }
-function stagedChangesRequireWorldLayerBindingValidation(current, changes) {
-  const classesById = new Map(
-    current.classes.map((schemaClass2) => [schemaClass2.id, schemaClass2])
-  );
-  const valuesById = new Map(current.values.map((value) => [value.id, value]));
-  const valueChanges = [];
-  for (const change of changes) {
-    if (change.recordKind === "internal-record-relation") return true;
-    if (change.recordKind === "value") {
-      valueChanges.push(change);
-      continue;
-    }
-    if (change.recordKind !== "class") continue;
-    if (change.operation !== "update") return true;
-    if (change.deleted === true) return true;
-    const before = classesById.get(change.recordId);
-    if (before === void 0) return true;
-    const after = change.nextData;
-    if (!isPlainRecord2(after)) return true;
-    if (before.extendsClassId !== after.extendsClassId) return true;
-    if (isAbstractClass(before) !== isAbstractClass(after)) return true;
-    if (!worldClassSystemBlockIsEqual(before.system, after.system)) return true;
-  }
-  if (valueChanges.length === 0) return false;
-  const graph = createWorldReferenceGraph({
-    classes: current.classes,
-    values: []
-  });
-  for (const change of valueChanges) {
-    const before = valuesById.get(change.recordId);
-    if (hasWorldLayerOverrideMetadata(before) || hasWorldLayerOverrideMetadata(change.nextData)) {
-      return true;
-    }
-    const classIds = [
-      relationEndpointClassId(before),
-      relationEndpointClassId(change.nextData)
-    ].filter((classId) => classId !== void 0);
-    for (const classId of classIds) {
-      const worldKind = resolveWorldKindFromClassMap(
-        classId,
-        graph.classesById
-      );
-      if (worldKind === NeoWorldSystemClassKind.TileLayerLink) return true;
-      if (worldKind === NeoWorldSystemClassKind.ObjectLayerLink) return true;
-    }
-  }
-  return false;
-}
 function stagedAffectedWorldLayerLinkClassIds(args) {
   const baseRelationsById = new Map(
     (args.current.internalRecordRelations ?? []).map((relation) => [
@@ -108173,16 +108825,20 @@ function stagedAffectedWorldLayerLinkClassIds(args) {
     if (!changedClassIds.has(relation.targetRecordId)) continue;
     roots.add(relation.sourceRecordId);
   }
+  const childrenByClassId = /* @__PURE__ */ new Map();
+  for (const schemaClass2 of args.classes) {
+    if (schemaClass2.extendsClassId === void 0) continue;
+    const children = childrenByClassId.get(schemaClass2.extendsClassId) ?? [];
+    children.push(schemaClass2.id);
+    childrenByClassId.set(schemaClass2.extendsClassId, children);
+  }
   const affected = new Set(roots);
-  let added = true;
-  while (added) {
-    added = false;
-    for (const schemaClass2 of args.classes) {
-      if (schemaClass2.extendsClassId === void 0) continue;
-      if (!affected.has(schemaClass2.extendsClassId)) continue;
-      if (affected.has(schemaClass2.id)) continue;
-      affected.add(schemaClass2.id);
-      added = true;
+  const pending = [...roots];
+  for (let index = 0; index < pending.length; index += 1) {
+    for (const childId of childrenByClassId.get(pending[index]) ?? []) {
+      if (affected.has(childId)) continue;
+      affected.add(childId);
+      pending.push(childId);
     }
   }
   return affected;
@@ -108193,18 +108849,6 @@ function isStagedWorldLayerLinkTargetRelationKind(relationKind) {
   }
   return relationKind === InternalRecordRelationKind.WorldObjectLayerLinkTarget;
 }
-function worldClassSystemBlockIsEqual(before, after) {
-  return projectRecordDataIsSemanticallyEqual(
-    { system: before },
-    { system: after }
-  );
-}
-function hasWorldLayerOverrideMetadata(record4) {
-  if (!isPlainRecord2(record4)) return false;
-  const value = record4.value;
-  if (!isPlainRecord2(value)) return false;
-  return typeof value.layerOverrideValueId === "string";
-}
 function assertStagedProjectInterfaceValid(projected, changes) {
   const relevant = changes.filter(
     (change) => INTERFACE_VALIDATED_RECORD_KINDS.has(change.recordKind)
@@ -108500,10 +109144,11 @@ function assertStagedTileGridReferencesValid(current, projected, changes) {
     classes: current.classes,
     values: []
   });
+  const currentValuesById = new Map(
+    current.values.map((value) => [value.id, value])
+  );
   if (deletedClassIds.size === 0 && [...deletedValueIds].every((valueId) => {
-    const value = current.values.find(
-      (candidate) => candidate.id === valueId
-    );
+    const value = currentValuesById.get(valueId);
     if (value?.classId == null) return true;
     return resolveWorldKindFromClassMap(
       value.classId,
@@ -108551,10 +109196,27 @@ function assertStagedVariantMemberValuesValid(projected, changes) {
   const valuesById = new Map(
     projected.values.map((value) => [value.id, value])
   );
+  const labelsByMemberId = /* @__PURE__ */ new Map();
+  const memberClasses = /* @__PURE__ */ new Map();
+  for (const schemaClass2 of projected.classes) {
+    for (const memberId of Object.values(schemaClass2.schema)) {
+      if (!memberClasses.has(memberId))
+        memberClasses.set(memberId, schemaClass2);
+    }
+  }
+  for (const member of variantMembers) {
+    const owner = memberClasses.get(member.id);
+    labelsByMemberId.set(
+      member.id,
+      owner === void 0 ? `Variant member "${member.name}"` : `Variant member "${owner.name}.${member.name}"`
+    );
+  }
+  const admittedClassesByTarget = /* @__PURE__ */ new Map();
+  const lookupRowsByCollection = /* @__PURE__ */ new Map();
   const graded = [];
   for (const member of variantMembers) {
     const declaration = substituteMemberForListenerGrading(member, projected);
-    const label = describeVariantMember(member, projected.classes);
+    const label = labelsByMemberId.get(member.id);
     assertVariantMemberTargetValid({ declaration, label, classesById });
     const authored = authoredVariantValue(member);
     if (authored !== void 0) {
@@ -108578,12 +109240,12 @@ function assertStagedVariantMemberValuesValid(projected, changes) {
       if (row.value === null || row.value === void 0) continue;
       const ownerId = getMemberId(owner);
       if (ownerId === null) continue;
-      const member = projected.members.find((item) => item.id === ownerId);
+      const member = membersById.get(ownerId);
       if (member === void 0) continue;
       graded.push({
         value: row.value,
         declaration: owner,
-        label: `${describeVariantMember(member, projected.classes)} row "${rowId}"`
+        label: `${labelsByMemberId.get(member.id)} row "${rowId}"`
       });
     }
   }
@@ -108597,7 +109259,9 @@ function assertStagedVariantMemberValuesValid(projected, changes) {
       foldersById,
       membersById,
       valuesById,
-      values: projected.values
+      values: projected.values,
+      admittedClassesByTarget,
+      lookupRowsByCollection
     });
   }
 }
@@ -108660,10 +109324,14 @@ function assertVariantReferenceValid(args) {
     );
   }
   if (target.type === 7 /* Class */ && value.classId !== target.classId) {
-    const admitted = descendantClassIds(
-      target.classId,
-      Array.from(classesById.values())
-    );
+    let admitted = args.admittedClassesByTarget.get(target.classId);
+    if (admitted === void 0) {
+      admitted = descendantClassIds(
+        target.classId,
+        Array.from(classesById.values())
+      );
+      args.admittedClassesByTarget.set(target.classId, admitted);
+    }
     if (!admitted.has(value.classId)) {
       const targetName = classesById.get(target.classId)?.name ?? target.classId;
       throw new Error(
@@ -108730,9 +109398,20 @@ function assertVariantReferenceValid(args) {
   }
   const collection = membersById.get(binding.collectionMemberId);
   const collectionValue = valuesById.get(binding.collectionValueId);
-  if (!isMemberListBase(collection) || collectionValue === void 0 || !valuesById.has(value.rowValueId) || !listEntryIdsForValue(collection, collectionValue, args.values).includes(
-    value.rowValueId
-  )) {
+  const rowIsInCollection = () => {
+    if (!isMemberListBase(collection) || collectionValue === void 0)
+      return false;
+    const key = `${binding.collectionMemberId}:${binding.collectionValueId}`;
+    let ids = args.lookupRowsByCollection.get(key);
+    if (ids === void 0) {
+      ids = new Set(
+        listEntryIdsForValue(collection, collectionValue, args.values)
+      );
+      args.lookupRowsByCollection.set(key, ids);
+    }
+    return ids.has(value.rowValueId);
+  };
+  if (!isMemberListBase(collection) || collectionValue === void 0 || !valuesById.has(value.rowValueId) || !rowIsInCollection()) {
     throw new Error(
       `${owner} binds row "${value.rowValueId}", which is not in lookup variant folder "${folder?.path ?? ""}".`
     );
@@ -108777,24 +109456,18 @@ function candidateVariantRowIds(projected, variantMembers) {
     }
     if (schemaKeys.size === 0) continue;
     if (!isPlainRecord2(row.value)) continue;
-    for (const schemaKey of schemaKeys) {
-      const childId = row.value[schemaKey];
-      if (typeof childId === "string") candidates.add(childId);
+    for (const [schemaKey, childId] of Object.entries(row.value)) {
+      if (schemaKeys.has(schemaKey) && typeof childId === "string")
+        candidates.add(childId);
     }
   }
   return candidates;
 }
-function describeVariantMember(member, classes) {
-  const owner = classes.find(
-    (schemaClass2) => Object.values(schemaClass2.schema).includes(member.id)
-  );
-  if (owner === void 0) return `Variant member "${member.name}"`;
-  return `Variant member "${owner.name}.${member.name}"`;
-}
 var KNOWN_TRANSACTION_OPERATIONS, INTERFACE_VALIDATED_RECORD_KINDS, ACTION_LISTENER_TRIGGER_RECORD_KINDS, ACTION_LISTENER_TARGET_KINDS, VARIANT_MEMBER_TRIGGER_RECORD_KINDS;
 var init_project_version_whole_graph_validation = __esm({
   "../src/database/project-version-whole-graph-validation.ts"() {
     "use strict";
+    init_project_world_placement_bindings();
     init_project_version_types();
     init_internal_record_relations();
     init_world_content_sidecar_validation();
@@ -108813,12 +109486,11 @@ var init_project_version_whole_graph_validation = __esm({
     init_neoscript();
     init_constructor_argument_ownership();
     init_materialize_values();
+    init_evaluateInitializer();
     init_world_system_classes();
     init_project_world_reference_graph();
-    init_project_record_semantics();
     init_project_version_relation_sweep_trigger();
     init_members();
-    init_classes();
     KNOWN_TRANSACTION_OPERATIONS = new Set(
       Object.values(ProjectVersionTransactionOperation)
     );
@@ -109155,6 +109827,12 @@ function computeWorkspaceStatus(workspace, options) {
       sourceSpan: source.span
     };
   });
+  const recordsByKey = new Map(
+    records2.map((record4) => [
+      recordStateKey(record4.recordKind, record4.recordId),
+      record4
+    ])
+  );
   if (projectAnalysisV4 === null) {
     throw new Error(
       "Format-4 project analysis was not produced before static value lowering."
@@ -109207,9 +109885,7 @@ function computeWorkspaceStatus(workspace, options) {
       if (document !== void 0 && isObjectRecord2(document.data)) {
         document.data.collectionValueId = resolvedId;
       }
-      const record4 = records2.find(
-        (candidate) => candidate.recordKind === "member" && candidate.recordId === memberId
-      );
+      const record4 = recordsByKey.get(recordStateKey("member", memberId));
       if (record4 !== void 0 && typeof record4.fileFields.collectionValueId === "string") {
         record4.fileFields.collectionValueId = resolvedId;
       }
@@ -109244,8 +109920,8 @@ function computeWorkspaceStatus(workspace, options) {
       if (document !== void 0 && isObjectRecord2(document.data.binding)) {
         document.data.binding.collectionValueId = resolvedId;
       }
-      const record4 = records2.find(
-        (candidate) => candidate.recordKind === "variant-folder" && candidate.recordId === folderId
+      const record4 = recordsByKey.get(
+        recordStateKey("variant-folder", folderId)
       );
       if (record4 !== void 0 && isObjectRecord2(record4.fileFields.binding)) {
         record4.fileFields.binding.collectionValueId = resolvedId;
@@ -109294,9 +109970,7 @@ function computeWorkspaceStatus(workspace, options) {
           );
         }
       }
-      const record4 = records2.find(
-        (candidate) => candidate.recordKind === "member" && candidate.recordId === memberId
-      );
+      const record4 = recordsByKey.get(recordStateKey("member", memberId));
       const authored = record4?.fileFields.defaultValue;
       if (isObjectRecord2(authored) && "value" in authored) {
         authored.value = substituteMemberDefaultKeyReferenceV4(
@@ -109412,14 +110086,15 @@ function computeWorkspaceStatus(workspace, options) {
     }
   }
   const deletedValueIds = /* @__PURE__ */ new Set();
+  const brokenFiles = new Set(conflictedFiles);
+  for (const error of parseErrors) {
+    if (isBlockingSchemaSourceError(error)) brokenFiles.add(error.file);
+  }
   for (const [key, recordState] of Object.entries(workspace.state.records)) {
     const recordFile = recordState.file ?? (orphanedStaticMemberKeys.has(key) ? STATIC_MEMBER_OWNERSHIP_RECOVERY_SOURCE : void 0);
     if (recordFile === void 0) continue;
     if (reconstructed3.has(key)) continue;
-    const fileStillBroken = parseErrors.some(
-      (error) => error.file === recordFile && isBlockingSchemaSourceError(error)
-    ) || conflictedFiles.includes(recordFile);
-    if (fileStillBroken) continue;
+    if (brokenFiles.has(recordFile)) continue;
     if (recordState.conflictServerHash === null) continue;
     if (recordState.recordKind === "localized-text" && isLocalizedText(recordState.data) && recordState.data.memberSource !== void 0)
       continue;
@@ -109801,6 +110476,15 @@ function replayAnimationDeclarationInitializersV4(records2, document, fallbackDo
     interfaces: replayDocument.interfaces,
     constructors: replayDocument.constructors ?? []
   });
+  const replayContext = createPulledConstructionReplayContext({
+    document: replayDocument
+  });
+  const constructorsById = new Map(
+    (replayDocument.constructors ?? []).map((constructor2) => [
+      constructor2.id,
+      constructor2
+    ])
+  );
   let documentBodiesCompiled = false;
   const fallbackValues = new Map(
     (fallbackDocument?.values ?? []).map((row) => [row.id, row])
@@ -109826,9 +110510,7 @@ function replayAnimationDeclarationInitializersV4(records2, document, fallbackDo
       valuesById
     );
     const initializerOwnerClass = ownerContext.ownerClass;
-    const requiredConstructor = initializerOwnerClass?.requiredConstructorId === void 0 || initializerOwnerClass.requiredConstructorId === null ? void 0 : (replayDocument.constructors ?? []).find(
-      (constructor2) => constructor2.id === initializerOwnerClass.requiredConstructorId
-    );
+    const requiredConstructor = initializerOwnerClass?.requiredConstructorId === void 0 || initializerOwnerClass.requiredConstructorId === null ? void 0 : constructorsById.get(initializerOwnerClass.requiredConstructorId);
     const requiredArgumentNames = new Set(
       requiredConstructor?.argumentTypes.map((argument2) => argument2.name) ?? []
     );
@@ -109841,6 +110523,7 @@ function replayAnimationDeclarationInitializersV4(records2, document, fallbackDo
       replay = replayStoredConstructionV4({
         records: pulled,
         document: replayDocument,
+        replayContext,
         valueId: row.id,
         code,
         member: owner,
@@ -110004,13 +110687,16 @@ function expandProspectiveAnimationInstances(document) {
     (row) => isLiteralValueContent(row) && isVirtualInstanceRootShape(row) && typeof row.classId === "string" && classBelongsToAnimationFamily(document.classesById, row.classId)
   );
   if (animationRoots.length === 0) return [...document.values];
-  const lookups = cliEvaluatorLookups({
-    project: document.project,
-    classes: document.classes,
-    constructors: document.constructors,
-    members: document.members,
-    values: document.values
-  });
+  const lookups = cliEvaluatorLookups(
+    {
+      project: document.project,
+      classes: document.classes,
+      constructors: document.constructors,
+      members: document.members,
+      values: document.values
+    },
+    { includeValueGraphIndexes: true }
+  );
   const byId = new Map(document.values.map((row) => [row.id, row]));
   for (const root of animationRoots) {
     for (const row of lookups.virtualInstanceRowsForValue(root.id)) {
@@ -111774,41 +112460,22 @@ function worldKindByClassId(document) {
   for (const classId of classes.keys()) resolve5(classId, /* @__PURE__ */ new Set());
   return result;
 }
-function valueWorldKind(kinds, value) {
-  if (value === null || typeof value !== "object") return void 0;
-  const classId = Reflect.get(value, "classId");
-  return typeof classId === "string" ? kinds.get(classId) : void 0;
-}
-function hasWorldLayerOverride(value) {
-  if (value === null || typeof value !== "object") return false;
-  const body = Reflect.get(value, "value");
-  return body !== null && typeof body === "object" && typeof Reflect.get(body, "layerOverrideValueId") === "string";
-}
 function commitPreparationWorldScopeKinds(args) {
   const allKinds = new Set(
-    args.postDocument.classes.flatMap(
+    [...args.currentDocument.classes, ...args.postDocument.classes].flatMap(
       (schemaClass2) => typeof schemaClass2.system?.worldKind === "string" ? [schemaClass2.system.worldKind] : []
     )
   );
-  if (args.changes.some(
-    (change) => change.recordKind === "class" || change.recordKind === "internal-record-relation"
-  )) {
-    return allKinds;
-  }
-  const kindsByClass = worldKindByClassId(args.postDocument);
-  const current = projectDocumentRecordsByKey(args.currentDocument);
-  const requiresWholeWorld = args.changes.some((change) => {
-    if (change.recordKind !== "value") return false;
-    const prior = current.get(commitPreparationRecordKey(change));
-    return [prior, change.nextData].some((candidate) => {
-      const worldKind = valueWorldKind(kindsByClass, candidate);
-      return hasWorldLayerOverride(candidate) || worldKind === NeoWorldSystemClassKind.TileLayerLink || worldKind === NeoWorldSystemClassKind.ObjectLayerLink;
-    });
-  });
-  return requiresWholeWorld ? allKinds : /* @__PURE__ */ new Set();
+  return stagedChangesRequireWorldLayerBindingValidation(
+    args.currentDocument,
+    args.changes
+  ) ? allKinds : /* @__PURE__ */ new Set();
 }
 function commitPreparationMemberDefaultValueScope(args) {
   let evaluatesSource = false;
+  const currentMembersById = new Map(
+    args.currentDocument.members.map((member) => [member.id, member])
+  );
   const constructorsWithSource = new Set(
     (args.postDocument.constructors ?? []).filter(containsAuthoredNeoScriptSource).map((constructor2) => constructor2.classId)
   );
@@ -111882,9 +112549,7 @@ function commitPreparationMemberDefaultValueScope(args) {
   for (const change of args.changes) {
     if (change.recordKind === "member") {
       visitMember(change.recordId);
-      const currentMember = args.currentDocument.members.find(
-        (member) => member.id === change.recordId
-      );
+      const currentMember = currentMembersById.get(change.recordId);
       if (currentMember !== void 0) {
         rememberDefaultIds(currentMember.defaultValue, true);
       }
@@ -111938,9 +112603,7 @@ function planCommitPreparationInitialScope(args) {
     }
     if (change.recordKind === "member") {
       rememberExact("value", derivedMemberValueId(change.recordId), true);
-      const current = args.document.members.find(
-        (member) => member.id === change.recordId
-      );
+      const current = previousMembers.get(change.recordId);
       for (const candidate of [current, change.nextData]) {
         if (candidate === null || typeof candidate !== "object") continue;
         const valueId = Reflect.get(candidate, "valueId");
@@ -111952,13 +112615,17 @@ function planCommitPreparationInitialScope(args) {
         rememberExact("value", valueId, true);
     }
   }
+  const currentTextsById = new Map(
+    (args.document.localizedTexts ?? []).map((text) => [text.id, text])
+  );
+  const postValuesById = new Map(
+    postDocument.values.map((row) => [row.id, row])
+  );
   const primary = postDocument.localizationConfig?.mainLocale;
   const primaryEdits = args.changes.flatMap((change) => {
     if (change.recordKind !== "localized-text" || change.operation !== "update" || !isLocalizedText(change.nextData) || primary === void 0)
       return [];
-    const old = args.document.localizedTexts?.find(
-      (text) => text.id === change.recordId
-    );
+    const old = currentTextsById.get(change.recordId);
     return old !== void 0 && memberSourcePrimaryChanged(
       old,
       primary,
@@ -111979,9 +112646,7 @@ function planCommitPreparationInitialScope(args) {
     const target = localizedTextReferenceTarget(link);
     rememberExact(target.recordKind, target.recordId, true);
     if (link.kind === "member-value") {
-      const row = postDocument.values.find(
-        (value) => value.id === link.valueId
-      );
+      const row = postValuesById.get(link.valueId);
       if (row !== void 0)
         linkedValueChanges.push({
           ...target,
@@ -112663,9 +113328,14 @@ function readCommitPreparationScopeInMemory(args) {
       key
     );
   }
+  const childKeysSeenByParent = /* @__PURE__ */ new Map();
   const rememberChild = (parentKey, childKey) => {
+    const seen = childKeysSeenByParent.get(parentKey) ?? /* @__PURE__ */ new Set();
+    if (seen.has(childKey)) return;
+    seen.add(childKey);
+    childKeysSeenByParent.set(parentKey, seen);
     const children = childKeysByParentKey.get(parentKey) ?? [];
-    if (!children.includes(childKey)) children.push(childKey);
+    children.push(childKey);
     childKeysByParentKey.set(parentKey, children);
   };
   for (const record4 of records2) {
@@ -112919,6 +113589,7 @@ var COMMIT_PREPARATION_SCOPE_RANGE_ROW_LIMIT, COMMIT_PREPARATION_SCOPE_POSTING_R
 var init_project_commit_preparation_scoped_loader = __esm({
   "../src/database/project-commit-preparation-scoped-loader.ts"() {
     "use strict";
+    init_project_world_placement_bindings();
     init_project_localization_rules();
     init_variant_value_graph();
     init_packed_value_write_fold();
@@ -113533,7 +114204,8 @@ function isPulledInitializerCompilationDocumentV4(document) {
 function createPulledConstructionReplayContext(args) {
   return {
     document: args.document,
-    constructorsValidated: false
+    constructorsValidated: false,
+    valuesById: new Map(args.document.values.map((value) => [value.id, value]))
   };
 }
 function pulledInitializerCompilerStateV4(document, compilationProject) {
@@ -113636,7 +114308,7 @@ function replayStoredConstructionV4(args) {
     }
     compilePulledProjectDocumentForEvaluationV4(document, compilationProject);
   }
-  const root = document.values.find((value) => value.id === args.valueId);
+  const root = args.replayContext === void 0 ? document.values.find((value) => value.id === args.valueId) : args.replayContext.valuesById.get(args.valueId);
   if (root === void 0) {
     throw new Error(
       `Cannot replay stored construction for missing value "${args.valueId}".`
@@ -128405,6 +129077,55 @@ var init_script = __esm({
   }
 });
 
+// src/project-source/identity-rewriter.ts
+function createIdentityRewriter(assignments) {
+  if (assignments.size === 0) return (value) => value;
+  const root = { children: /* @__PURE__ */ new Map() };
+  for (const [source, replacement] of assignments) {
+    let prefix = root;
+    for (let index = 0; index < source.length; index += 1) {
+      const character = source[index];
+      let child = prefix.children.get(character);
+      if (child === void 0) {
+        child = { children: /* @__PURE__ */ new Map() };
+        prefix.children.set(character, child);
+      }
+      prefix = child;
+    }
+    prefix.replacement = replacement;
+  }
+  return (value) => {
+    const exact = assignments.get(value);
+    if (exact !== void 0) return exact;
+    const parts = [];
+    let copiedThrough = 0;
+    for (let start = 0; start < value.length; start += 1) {
+      let prefix = root.children.get(value[start]);
+      let replacement;
+      let end = start;
+      for (let index = start; prefix !== void 0; index += 1) {
+        if (prefix.replacement !== void 0) {
+          replacement = prefix.replacement;
+          end = index + 1;
+        }
+        prefix = prefix.children.get(value[index + 1]);
+      }
+      if (replacement === void 0) continue;
+      parts.push(value.slice(copiedThrough, start), replacement);
+      copiedThrough = end;
+      start = end - 1;
+    }
+    if (copiedThrough === 0) return value;
+    parts.push(value.slice(copiedThrough));
+    return parts.join("");
+  };
+}
+var init_identity_rewriter = __esm({
+  "src/project-source/identity-rewriter.ts"() {
+    "use strict";
+  }
+});
+
 // ../src/database/project-source-identity.ts
 import { createHash as createHash8 } from "node:crypto";
 function hashProjectSourceFiles(inputFiles) {
@@ -129469,20 +130190,10 @@ function assignPendingIds(changes, authoredValueSeeds, reconstructed3, localInit
   if (localInitializerMaterialization !== void 0) {
     collect(localInitializerMaterialization);
   }
-  const replacements = [...assigned].sort(
-    ([left], [right]) => right.length - left.length
-  );
+  const rewriteString = createIdentityRewriter(assigned);
   const rewrite = (value) => {
     if (typeof value === "string") {
-      const exact = assigned.get(value);
-      if (exact !== void 0) return exact;
-      let result = value;
-      for (const [pendingId2, assignedId] of replacements) {
-        if (result.includes(pendingId2)) {
-          result = result.replaceAll(pendingId2, assignedId);
-        }
-      }
-      return result;
+      return rewriteString(value);
     }
     if (Array.isArray(value)) return value.map((item) => rewrite(item));
     if (isObjectRecord2(value)) {
@@ -131295,9 +132006,7 @@ function projectTransactionResultReplacements(candidateAssignments, resultAssign
   }
   return {
     exact: replacements,
-    embedded: [...replacements].sort(
-      ([left], [right]) => right.length - left.length
-    )
+    rewrite: createIdentityRewriter(replacements)
   };
 }
 function rewriteReconstructedRecords(records2, replacements) {
@@ -131327,13 +132036,7 @@ function rewriteReconstructedRecords(records2, replacements) {
   return rewritten;
 }
 function rewriteAssignedString(value, replacements) {
-  const exact = replacements.exact.get(value);
-  if (exact !== void 0) return exact;
-  let result = value;
-  for (const [source, target] of replacements.embedded) {
-    if (result.includes(source)) result = result.replaceAll(source, target);
-  }
-  return result;
+  return replacements.rewrite(value);
 }
 function rewriteAssignedValue(value, replacements) {
   if (typeof value === "string") {
@@ -131473,7 +132176,7 @@ function applyPushResult(workspace, result, pendingIdAssignments = /* @__PURE__
   );
   const replacements = {
     exact: pendingIdAssignments,
-    embedded: pendingIdAssignments.entries().toArray().sort(([left], [right]) => right.length - left.length)
+    rewrite: createIdentityRewriter(pendingIdAssignments)
   };
   const localRecords = rewriteReconstructedRecords(
     localStatus.reconstructed,
@@ -132153,52 +132856,49 @@ function prepareNSPropertySetterChanges(workspace, status) {
     }
     members.set(change.recordId, change.nextData);
   }
+  const inheritedSetters = /* @__PURE__ */ new Map();
   const removedDeclarations = status.changes.filter(
-    (change) => change.recordKind === "member" && change.nextData?.kind === 10 && isObjectRecord2(change.baseData) && typeof change.baseData.setterCode === "string" && typeof change.nextData.setterCode !== "string" && !ancestorDeclaresSetter(change.nextData, members)
+    (change) => change.recordKind === "member" && change.nextData?.kind === 10 && isObjectRecord2(change.baseData) && typeof change.baseData.setterCode === "string" && typeof change.nextData.setterCode !== "string" && !ancestorDeclaresSetter(change.nextData, members, inheritedSetters)
   ).map((change) => change.recordId);
-  for (const declarationId of removedDeclarations) {
-    for (const [memberId, member] of members) {
-      if (memberId === declarationId) continue;
-      if (!memberDescendsFrom(member, declarationId, members)) {
-        continue;
-      }
-      if (typeof member.setterCode !== "string" && member.setter === void 0) {
-        continue;
-      }
-      const next = { ...member };
-      delete next.setterCode;
-      delete next.setter;
-      members.set(memberId, next);
-      const key = recordStateKey("member", memberId);
-      const reconstructed3 = status.reconstructed.get(key);
-      if (reconstructed3 !== void 0) reconstructed3.fullData = next;
-      const existingChange = changesById.get(memberId);
-      if (existingChange !== void 0) {
-        existingChange.nextData = next;
-        continue;
-      }
-      const base = workspace.state.records[key];
-      if (base === void 0 || reconstructed3 === void 0) {
-        throw new Error(
-          `Cannot cascade removal of NeoScript property setter to override "${memberId}": its working-copy state is missing.`
-        );
-      }
-      const cascadeChange = recordUpsertChange({
-        base,
-        recordKind: "member",
-        recordId: memberId,
-        file: reconstructed3.file,
-        nextData: next
-      });
-      status.changes.push(cascadeChange);
-      changesById.set(memberId, cascadeChange);
+  for (const memberId of memberDescendantIds(members, removedDeclarations)) {
+    const member = members.get(memberId);
+    if (typeof member.setterCode !== "string" && member.setter === void 0) {
+      continue;
     }
+    const next = { ...member };
+    delete next.setterCode;
+    delete next.setter;
+    members.set(memberId, next);
+    const key = recordStateKey("member", memberId);
+    const reconstructed3 = status.reconstructed.get(key);
+    if (reconstructed3 !== void 0) reconstructed3.fullData = next;
+    const existingChange = changesById.get(memberId);
+    if (existingChange !== void 0) {
+      existingChange.nextData = next;
+      continue;
+    }
+    const base = workspace.state.records[key];
+    if (base === void 0 || reconstructed3 === void 0) {
+      throw new Error(
+        `Cannot cascade removal of NeoScript property setter to override "${memberId}": its working-copy state is missing.`
+      );
+    }
+    const cascadeChange = recordUpsertChange({
+      base,
+      recordKind: "member",
+      recordId: memberId,
+      file: reconstructed3.file,
+      nextData: next
+    });
+    status.changes.push(cascadeChange);
+    changesById.set(memberId, cascadeChange);
   }
+  inheritedSetters.clear();
   for (const member of members.values()) {
     if (member.kind !== 10) continue;
     if (typeof member.extendsMemberId !== "string") continue;
     if (typeof member.setterCode !== "string") continue;
-    if (ancestorDeclaresSetter(member, members)) continue;
+    if (ancestorDeclaresSetter(member, members, inheritedSetters)) continue;
     throw new Error(
       `Override NeoScript property "${String(member.name ?? member.id)}" cannot add a setter because its base chain does not declare one.`
     );
@@ -132240,14 +132940,10 @@ function prepareNSFunctionBodyChanges(workspace, status) {
       members.set(next.id, next);
     }
   }
-  for (const [memberId, member] of members) {
+  for (const memberId of memberDescendantIds(members, affectedRoots)) {
+    const member = members.get(memberId);
     if (member.kind !== 23 || typeof member.code !== "string") continue;
     if (changesById.has(memberId)) continue;
-    if (![...affectedRoots].some(
-      (rootId) => memberDescendsFrom(member, rootId, members)
-    )) {
-      continue;
-    }
     const key = recordStateKey("member", memberId);
     const base = workspace.state.records[key];
     const reconstructed3 = status.reconstructed.get(key);
@@ -132267,10 +132963,16 @@ function prepareNSFunctionBodyChanges(workspace, status) {
     changesById.set(memberId, cascadeChange);
   }
 }
-function ancestorDeclaresSetter(member, members) {
+function ancestorDeclaresSetter(member, members, cache) {
   let parentId = typeof member.extendsMemberId === "string" ? member.extendsMemberId : null;
   const visited = /* @__PURE__ */ new Set();
+  let hasSetter = false;
   while (parentId !== null) {
+    const cached = cache.get(parentId);
+    if (cached !== void 0) {
+      hasSetter = cached;
+      break;
+    }
     if (visited.has(parentId)) {
       throw new Error(
         `Cannot resolve NeoScript property setter inheritance: circular member chain at "${parentId}".`
@@ -132283,23 +132985,35 @@ function ancestorDeclaresSetter(member, members) {
         `Cannot resolve NeoScript property setter inheritance: missing parent member "${parentId}".`
       );
     }
-    if (typeof parent.setterCode === "string") return true;
+    if (typeof parent.setterCode === "string") {
+      hasSetter = true;
+      break;
+    }
     parentId = typeof parent.extendsMemberId === "string" ? parent.extendsMemberId : null;
   }
-  return false;
+  for (const id2 of visited) cache.set(id2, hasSetter);
+  return hasSetter;
 }
-function memberDescendsFrom(member, ancestorId, members) {
-  let parentId = typeof member.extendsMemberId === "string" ? member.extendsMemberId : null;
-  const visited = /* @__PURE__ */ new Set();
-  while (parentId !== null) {
-    if (parentId === ancestorId) return true;
-    if (visited.has(parentId)) return false;
-    visited.add(parentId);
-    const parent = members.get(parentId);
-    if (parent === void 0) return false;
-    parentId = typeof parent.extendsMemberId === "string" ? parent.extendsMemberId : null;
+function memberDescendantIds(members, rootIds) {
+  const roots = [...rootIds];
+  if (roots.length === 0) return /* @__PURE__ */ new Set();
+  const children = /* @__PURE__ */ new Map();
+  for (const [id2, member] of members) {
+    if (typeof member.extendsMemberId !== "string") continue;
+    const siblings = children.get(member.extendsMemberId);
+    if (siblings === void 0) children.set(member.extendsMemberId, [id2]);
+    else siblings.push(id2);
   }
-  return false;
+  const descendants = /* @__PURE__ */ new Set();
+  const pending = [...roots];
+  for (let index = 0; index < pending.length; index += 1) {
+    for (const childId of children.get(pending[index]) ?? []) {
+      if (descendants.has(childId)) continue;
+      descendants.add(childId);
+      pending.push(childId);
+    }
+  }
+  return descendants;
 }
 function resolveNSPropertyReturnTypeInfo2(member, members) {
   let current = member;
@@ -132385,6 +133099,7 @@ var compileNSVoidBody2, compileNSFunction2, compileNSGetter2, compileNSSetter2,
 var init_push = __esm({
   "src/commands/push.ts"() {
     "use strict";
+    init_identity_rewriter();
     init_source_layout();
     init_src();
     init_src2();
@@ -132478,7 +133193,7 @@ var init_registry2 = __esm({
   "schema-contract/registry.mjs"() {
     "use strict";
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
-      cliVersion: "0.50.3",
+      cliVersion: "0.50.5",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -139694,7 +140409,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.50.3");
+    console.log("0.50.5");
     return;
   }
   if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {