@neocompose/cli 0.38.4 → 0.38.6

package/dist/neo.mjs

@@ -936,7 +936,7 @@ var init_login = __esm({
       "project:release-channel:write",
       "project:release-channel:publish"
     ];
-    sleep = (ms) => new Promise((resolve4) => setTimeout(resolve4, ms));
+    sleep = (ms) => new Promise((resolve5) => setTimeout(resolve5, ms));
   }
 });
 
@@ -44110,6 +44110,18 @@ var init_neoscript = __esm({
   }
 });
 
+// ../src/common/collections.ts
+function indexById2(records2) {
+  const indexed = /* @__PURE__ */ new Map();
+  for (const record3 of records2) indexed.set(record3.id, record3);
+  return indexed;
+}
+var init_collections = __esm({
+  "../src/common/collections.ts"() {
+    "use strict";
+  }
+});
+
 // ../src/models/classes/classes.ts
 function isGenericParamConstraint(value) {
   const v = value;
@@ -44245,6 +44257,7 @@ var RETIRED_CONSTRUCTOR_PROJECTIONS_FIELD;
 var init_classes = __esm({
   "../src/models/classes/classes.ts"() {
     "use strict";
+    init_collections();
     init_core();
     init_docs_text2();
     init_member_storage();
@@ -45432,6 +45445,9 @@ function membersById(members) {
   });
   return byId;
 }
+function classIndexFor(classes) {
+  return classesById(classes);
+}
 function createMergeMemo() {
   const byClasses = /* @__PURE__ */ new WeakMap();
   return (classId, classIndex, memberIndex, compute) => {
@@ -45574,8 +45590,9 @@ function findNearestAncestorSchemaPlacement(ownerClass, schemaKey, classesById2)
 function walkExtendsMemberChain(startId, members, pick, options) {
   const requireKind = options?.requireKind;
   const maxHops = options?.maxHops ?? 16;
-  const byId = membersById(members);
-  let cursor = byId.get(startId);
+  const byId = options?.memberById === void 0 ? membersById(members) : null;
+  const getMember = (id2) => options?.memberById?.(id2) ?? byId?.get(id2) ?? null;
+  let cursor = getMember(startId);
   for (let i = 0; cursor && i < maxHops; i++) {
     if (requireKind !== void 0 && cursor.kind !== requireKind) {
       return void 0;
@@ -45584,7 +45601,7 @@ function walkExtendsMemberChain(startId, members, pick, options) {
     if (v !== void 0) return v;
     const nextId = getOptionalString(cursor, "extendsMemberId");
     if (nextId === void 0) return void 0;
-    cursor = byId.get(nextId);
+    cursor = getMember(nextId);
   }
   return void 0;
 }
@@ -48220,6 +48237,14 @@ var init_generics = __esm({
 });
 
 // ../src/models/members/instance-provenance.ts
+function overlayLiteralValueContent(base, override) {
+  const merged = { ...base, ...override };
+  if (!("value" in override) || override.value !== null) return merged;
+  for (const field of LITERAL_INSTANCE_IDENTITY_FIELDS) {
+    if (!Object.hasOwn(override, field)) Reflect.deleteProperty(merged, field);
+  }
+  return merged;
+}
 function pickInstanceProvenance(source) {
   return {
     ...source.constructorArgs === void 0 ? {} : { constructorArgs: source.constructorArgs },
@@ -48238,10 +48263,19 @@ function carriesCompleteConstructionRecipe(value) {
   if (typeof value.instanceVariantId === "string") return true;
   return value.constructorArgs !== void 0;
 }
+var LITERAL_INSTANCE_IDENTITY_FIELDS;
 var init_instance_provenance = __esm({
   "../src/models/members/instance-provenance.ts"() {
     "use strict";
     init_member_kinds();
+    LITERAL_INSTANCE_IDENTITY_FIELDS = [
+      "classId",
+      "constructorArgs",
+      "instanceConstructorId",
+      "instanceVariantId",
+      "instanceVariantRowValueId",
+      "genericBindings"
+    ];
   }
 });
 
@@ -56740,6 +56774,7 @@ var init_common = __esm({
   "../src/common/index.ts"() {
     "use strict";
     init_benchmark();
+    init_collections();
     init_error_message();
     init_retree_input_diagnostics();
   }
@@ -67231,7 +67266,121 @@ function validateInternalRecordRelations(args) {
   });
 }
 function resolveEffectiveClassRelations(args) {
-  const contract = (args.contracts ?? INTERNAL_RECORD_RELATION_KIND_CONTRACTS).find((candidate) => candidate.relationKind === args.relationKind);
+  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();
+  for (const contract of contracts) {
+    contractsByKind.set(contract.relationKind, contract);
+  }
+  const classesById2 = args.classesById ?? classIndexFor(args.classes);
+  const classRelationsByKind = /* @__PURE__ */ new Map();
+  const relationsByIdByKind = /* @__PURE__ */ new Map();
+  const directByKindAndSource = /* @__PURE__ */ new Map();
+  for (const relation of args.relations) {
+    if (relation.sourceRecordKind !== "class" || relation.targetRecordKind !== "class") {
+      continue;
+    }
+    const relations = classRelationsByKind.get(relation.relationKind);
+    if (relations === void 0) {
+      classRelationsByKind.set(relation.relationKind, [relation]);
+    } else relations.push(relation);
+  }
+  const relationById = (relationKind, id2) => {
+    let byId = relationsByIdByKind.get(relationKind);
+    if (byId === void 0) {
+      byId = indexById2(classRelationsByKind.get(relationKind) ?? []);
+      relationsByIdByKind.set(relationKind, byId);
+    }
+    return byId.get(id2);
+  };
+  const ancestryByClassId = /* @__PURE__ */ new Map();
+  const concreteDescendantsByClassId = /* @__PURE__ */ new Map();
+  const childrenByClassId = /* @__PURE__ */ new Map();
+  for (const schemaClass2 of args.classes) {
+    if (schemaClass2.extendsClassId === void 0) continue;
+    const children = childrenByClassId.get(schemaClass2.extendsClassId);
+    if (children === void 0) {
+      childrenByClassId.set(schemaClass2.extendsClassId, [schemaClass2.id]);
+    } else {
+      children.push(schemaClass2.id);
+    }
+  }
+  const ancestry = (classId) => {
+    const cached = ancestryByClassId.get(classId);
+    if (cached !== void 0) return cached;
+    const resolved = classAncestry(classId, classesById2);
+    ancestryByClassId.set(classId, resolved);
+    return resolved;
+  };
+  const concreteDescendants = (classId) => {
+    const cached = concreteDescendantsByClassId.get(classId);
+    if (cached !== void 0) return cached;
+    if (!classesById2.has(classId)) return [];
+    const result = [];
+    const pending = [classId];
+    const visited = /* @__PURE__ */ new Set();
+    while (pending.length > 0) {
+      const candidateId = pending.pop();
+      if (visited.has(candidateId)) {
+        throw new Error(
+          `Class inheritance contains a cycle at "${candidateId}".`
+        );
+      }
+      visited.add(candidateId);
+      const candidate = classesById2.get(candidateId);
+      if (candidate !== void 0 && !candidate.isAbstract) {
+        result.push(candidate.id);
+      }
+      for (const childId of childrenByClassId.get(candidateId) ?? []) {
+        pending.push(childId);
+      }
+    }
+    result.sort((left, right) => left.localeCompare(right));
+    concreteDescendantsByClassId.set(classId, result);
+    return result;
+  };
+  const directClassRelations = (relationKind, sourceClassId) => {
+    let bySource = directByKindAndSource.get(relationKind);
+    if (bySource === void 0) {
+      bySource = /* @__PURE__ */ new Map();
+      for (const relation of classRelationsByKind.get(relationKind) ?? []) {
+        const declarations = bySource.get(relation.sourceRecordId);
+        if (declarations === void 0) {
+          bySource.set(relation.sourceRecordId, [relation]);
+        } else declarations.push(relation);
+      }
+      directByKindAndSource.set(relationKind, bySource);
+    }
+    return bySource.get(sourceClassId) ?? [];
+  };
+  const resolve5 = (relationKind, sourceClassId) => {
+    const contract = contractsByKind.get(relationKind);
+    return resolveEffectiveClassRelationsFromIndex({
+      relationKind,
+      sourceClassId,
+      contract,
+      ancestry,
+      concreteDescendants,
+      directClassRelations
+    });
+  };
+  return {
+    classesById: classesById2,
+    relationById,
+    directClassRelations,
+    classAncestry: ancestry,
+    concreteClassDescendants: concreteDescendants,
+    resolve: resolve5
+  };
+}
+function resolveEffectiveClassRelationsFromIndex(args) {
+  const contract = args.contract;
   if (contract === void 0) {
     throw new Error(`Unknown internal relation kind "${args.relationKind}".`);
   }
@@ -67243,15 +67392,12 @@ function resolveEffectiveClassRelations(args) {
       `Internal relation kind "${args.relationKind}" is not class-to-class.`
     );
   }
-  const classesById2 = new Map(
-    args.classes.map((schemaClass2) => [schemaClass2.id, schemaClass2])
-  );
-  const sourceIds = contract.sourceClassPolicy === "include-descendants" ? classAncestry(args.sourceClassId, classesById2) : [args.sourceClassId];
+  const sourceIds = contract.sourceClassPolicy === "include-descendants" ? args.ancestry(args.sourceClassId) : [args.sourceClassId];
   const sourceDepth = new Map(
     sourceIds.map((sourceId3, index) => [sourceId3, index])
   );
-  const declarations = args.relations.filter(
-    (relation) => relation.relationKind === args.relationKind && relation.sourceRecordKind === "class" && relation.targetRecordKind === "class" && sourceDepth.has(relation.sourceRecordId)
+  const declarations = sourceIds.flatMap(
+    (sourceId3) => args.directClassRelations(args.relationKind, sourceId3)
   );
   if (contract.merge === "nearest-single") {
     const sorted = declarations.sort(
@@ -67273,11 +67419,7 @@ function resolveEffectiveClassRelations(args) {
   const byTarget = /* @__PURE__ */ new Map();
   for (const declaration of declarations) {
     const declarationDepth = sourceDepth.get(declaration.sourceRecordId) ?? 0;
-    const targetIds = contract.targetClassPolicy === "include-descendants" ? concreteClassDescendants(
-      declaration.targetRecordId,
-      args.classes,
-      classesById2
-    ) : [declaration.targetRecordId];
+    const targetIds = contract.targetClassPolicy === "include-descendants" ? args.concreteDescendants(declaration.targetRecordId) : [declaration.targetRecordId];
     for (const targetId of targetIds) {
       const current = byTarget.get(targetId);
       if (current === void 0) {
@@ -67474,12 +67616,6 @@ function classAncestry(classId, classesById2) {
   }
   return result;
 }
-function concreteClassDescendants(classId, classes, classesById2) {
-  if (!classesById2.has(classId)) return [];
-  return classes.filter(
-    (candidate) => !candidate.isAbstract && classAncestry(candidate.id, classesById2).includes(classId)
-  ).map((candidate) => candidate.id).sort((left, right) => left.localeCompare(right));
-}
 function effectiveRelation(relation, targetRecordId, sourceAncestryDepth) {
   return {
     relationKind: relation.relationKind,
@@ -67511,7 +67647,9 @@ var InternalRecordRelationKind, INTERNAL_RECORD_RELATION_KIND_CONTRACTS;
 var init_internal_record_relations = __esm({
   "../src/models/project/internal-record-relations.ts"() {
     "use strict";
+    init_collections();
     init_classes();
+    init_inheritance();
     init_core();
     init_project_version_types();
     InternalRecordRelationKind = {
@@ -67667,6 +67805,7 @@ function makeEvaluatorLookups(members, values, options = {}) {
   const lookups = {
     memberById: (id2) => attrMap.get(id2) ?? null,
     valueById: (id2) => valMap.get(id2) ?? null,
+    hasStoredValueId: (id2) => valMap.has(id2),
     unorderedListEntryIds: (containerValueId) => unorderedListMembership.get(containerValueId) ?? [],
     // An index over a plain row set has no virtual expansion: every row it
     // can answer with is already in `values`.
@@ -67698,9 +67837,20 @@ function evalMemberById(vm, id2) {
 function evalValueById(ctx, id2, runtimeValues, overlayValues) {
   const vm = ctx.vm;
   const runtime = runtimeValues?.get(id2);
-  if (runtime !== void 0) return runtime;
+  if (runtime !== void 0) {
+    if (vm.databaseVM?.hasStoredValueId?.(id2) ?? true) {
+      ctx.valueDependencies?.add(id2);
+    }
+    return runtime;
+  }
   const overlay = overlayValues?.get(id2);
-  if (overlay !== void 0) return overlay;
+  if (overlay !== void 0) {
+    if (vm.databaseVM?.hasStoredValueId?.(id2) ?? true) {
+      ctx.valueDependencies?.add(id2);
+    }
+    return overlay;
+  }
+  ctx.valueDependencies?.add(id2);
   if (vm.databaseVM?.valueById) return vm.databaseVM.valueById(id2);
   return vm.values.find((v) => v.id === id2) ?? null;
 }
@@ -68110,6 +68260,9 @@ function resolveRuntimeReferenceRow(sourceValueId, ctx, withProvenance) {
   if (!withProvenance) return direct;
   const receiver = trackedRowForValueReference(ctx.thisValue, ctx);
   if (receiver === null) return direct;
+  ctx.onUnattributableValueRead?.(
+    `runtime-reference-provenance:${sourceValueId}`
+  );
   const indexes = evaluatorIndexes(ctx);
   const virtualRows = ctx.vm.databaseVM?.virtualInstanceRowsForValue(receiver.id) ?? [];
   if (virtualRows.length > 0) {
@@ -68716,6 +68869,9 @@ function finalizeConstructorAllocations(ctx, returnValue, ownsInvocationState, r
             }
           }
         }
+        ctx.onUnattributableValueRead?.(
+          `constructor-argument-list:${argumentId}`
+        );
         for (const candidate of evaluatorValues(ctx)) {
           if (candidate.containerId === argumentId) {
             scanCreationDataRow({
@@ -68773,6 +68929,7 @@ function finalizeConstructorAllocations(ctx, returnValue, ownsInvocationState, r
     if (member !== null && isMemberListBase(member)) {
       const entryMember = evalMemberById(ctx.vm, member.entryMemberId);
       if (member.listKind === "unordered") {
+        ctx.onUnattributableValueRead?.(`constructed-unordered-list:${row.id}`);
         for (const candidate of evaluatorValues(ctx)) {
           if (candidate.containerId === row.id) {
             scanOwnedRow(candidate.id, entryMember);
@@ -69067,6 +69224,11 @@ function parameterDefaultsAsFullArguments(argumentTypes, subject) {
   if (!argumentTypes.every(parameterHasDefault)) return null;
   return fillTrailingParameterDefaults([], argumentTypes, subject);
 }
+function declarationInitializerArgumentValues(argumentTypes, subject, readsConstructorParameter) {
+  const defaults = parameterDefaultsAsFullArguments(argumentTypes, subject);
+  if (defaults !== null) return defaults;
+  return readsConstructorParameter ? [] : argumentTypes.map(() => null);
+}
 function fillCallableCallSiteArguments(args, member, ctx) {
   if (member === null) return args;
   if (member.kind !== 13 /* Function */ && member.kind !== 23 /* NSFunction */) {
@@ -70219,6 +70381,7 @@ function staticBindingTargetId(member, ctx) {
       `Member '${member.name}' is not a static member.`
     );
   }
+  ctx.staticMemberDependencies?.add(member.id);
   const storage = effectiveStaticStorage(member.id, ctx);
   const bindings = storage === "save" /* Save */ ? ctx.__saveStaticBindings : storage === "session" /* Session */ ? ctx.__sessionStaticBindings : void 0;
   if (bindings?.has(member.id)) return bindings.get(member.id) ?? null;
@@ -70266,7 +70429,6 @@ function evalStaticMember(memberId, ctx) {
       `Static member '${member.name}' is bound to missing value '${targetId}'.`
     );
   }
-  ctx.valueDependencies?.add(row.id);
   return row.value;
 }
 function evalPointer(pointer, scope, ctx) {
@@ -70875,6 +71037,7 @@ function delegateClosureLexicalThis(closure, ctx) {
       "Stored NeoDelegate closure has no resolvable value row; lexical this cannot be reconstructed from ownership."
     );
   }
+  ctx.onUnattributableValueRead?.(`delegate-owner-resolution:${closureRow.id}`);
   const owners = [];
   const indexes = evaluatorIndexes(ctx);
   for (const [ancestorId, distance] of evaluatorOwnershipDistances(
@@ -71035,6 +71198,7 @@ function runtimeGenericEnvForValueRow(row, ctx, visited) {
 }
 function runtimeParentGenericEnv(row, ctx, visited) {
   const result = /* @__PURE__ */ new Map();
+  ctx.onUnattributableValueRead?.(`generic-parent-resolution:${row.id}`);
   for (const link of evaluatorParentLinks(evaluatorIndexes(ctx), row.id)) {
     const parent = evalValueById(
       ctx,
@@ -71748,7 +71912,6 @@ function resolveValueIfId(at, ctx) {
     ctx.__valueOverlay
   );
   if (!row) return at;
-  ctx.valueDependencies?.add(row.id);
   const member = memberForValueRow(row, ctx);
   if (member !== null && isMemberListBase(member) && member.listKind === "unordered" && Array.isArray(row.value)) {
     return evaluatorUnorderedListEntryIds(row.id, ctx);
@@ -71765,7 +71928,6 @@ function resolveValueIfIdForMember(at, member, ctx) {
     ctx.__valueOverlay
   );
   if (!row) return at;
-  ctx.valueDependencies?.add(row.id);
   if (isMemberListBase(member) && member.listKind === "unordered" && Array.isArray(row.value)) {
     return evaluatorUnorderedListEntryIds(row.id, ctx);
   }
@@ -71773,6 +71935,7 @@ function resolveValueIfIdForMember(at, member, ctx) {
   return shouldUnwrapSingleLookupValue(member) ? unwrapSingleLookupValue(value, ctx) : value;
 }
 function evaluatorUnorderedListEntryIds(containerValueId, ctx) {
+  ctx.containerDependencies?.add(containerValueId);
   const runtimeRows = [...ctx.__runtimeSessionValues?.values() ?? []];
   const overlayRows = [...ctx.__valueOverlay?.values() ?? []];
   const localRows = [...runtimeRows, ...overlayRows];
@@ -71798,7 +71961,6 @@ function unwrapSingleLookupValue(value, ctx) {
       ctx.__valueOverlay
     );
     if (next) {
-      ctx.valueDependencies?.add(next.id);
       return next.value;
     }
   }
@@ -71839,6 +72001,7 @@ function resolveMemberForValueRow(row, ctx, visited) {
   if (syntheticMemberId !== null) {
     return evalMemberById(ctx.vm, syntheticMemberId);
   }
+  ctx.onUnattributableValueRead?.(`member-owner-resolution:${row.id}`);
   for (const link of evaluatorParentLinks(indexes, row.id)) {
     const parent = evalValueById(
       ctx,
@@ -71903,13 +72066,11 @@ function memberIdFromSyntheticDefaultValueId(valueId) {
   return valueId.slice(prefix.length, -suffix.length);
 }
 function resolveLocalizedTextId(value, ctx) {
+  ctx.localizedTextDependencies?.add(value);
   const mainLocale = ctx.vm.localizationConfig?.mainLocale;
   if (mainLocale === void 0) return value;
-  const text = ctx.vm.localizedTexts?.find(
-    (candidate) => candidate.id === value
-  );
-  if (text === void 0) return value;
-  ctx.localizedTextDependencies?.add(text.id);
+  const text = ctx.vm.databaseVM?.localizedTextById?.(value) ?? ctx.vm.localizedTexts?.find((candidate) => candidate.id === value) ?? null;
+  if (text === null) return value;
   return text.localeValues[mainLocale]?.value ?? "";
 }
 function evalOperation(operation, scope, ctx) {
@@ -73350,6 +73511,7 @@ function bindConstructedDelegateTargets(createdValues, ctx) {
         `NeoDelegate method target '${target.name}' has no declaring Class placement.`
       );
     }
+    ctx.onUnattributableValueRead?.(`constructed-delegate-owner:${row.id}`);
     const matches = [];
     for (const [ancestorId, distance] of evaluatorOwnershipDistances(
       row.id,
@@ -74097,6 +74259,17 @@ function constructorInitializerIndexes(ctx) {
   ctx.__constructorInitializerIndexes = built;
   return built;
 }
+function constructorById(constructorId, ctx) {
+  if (ctx.__constructorById === void 0) {
+    ctx.__constructorById = new Map(
+      (ctx.vm.constructors ?? []).map((constructor2) => [
+        constructor2.id,
+        constructor2
+      ])
+    );
+  }
+  return ctx.__constructorById.get(constructorId);
+}
 function buildConstructorInitializerIndexes(vm) {
   const initializerScopeMemberIds = /* @__PURE__ */ new WeakMap();
   const initializerScopeMemberIdsByValueId = /* @__PURE__ */ new Map();
@@ -74133,6 +74306,9 @@ function buildConstructorInitializerIndexes(vm) {
       initializerScopeMemberIdsByValueId.set(valueId, rootOwnerId);
     }
   }
+  const classById = new Map(
+    vm.classes.map((schemaClass2) => [schemaClass2.id, schemaClass2])
+  );
   const declaringClassIdsByMemberId = /* @__PURE__ */ new Map();
   for (const schemaClass2 of vm.classes) {
     for (const memberId of Object.values(schemaClass2.schema)) {
@@ -74151,6 +74327,7 @@ function buildConstructorInitializerIndexes(vm) {
   return {
     initializerScopeMemberIds,
     initializerScopeMemberIdsByValueId,
+    classById,
     declaringClassIdsByMemberId,
     memberById: memberById2,
     containerMemberIdByEntryId
@@ -74527,10 +74704,9 @@ function resolveVariantGraph(selection2, ctx) {
       "Base variant selection has no variant graph."
     );
   }
-  const record3 = (ctx.vm.variants ?? []).find(
-    (candidate) => candidate.id === variantId
-  );
-  if (record3 === void 0) {
+  ctx.variantDependencies?.add(variantId);
+  const record3 = ctx.vm.databaseVM?.variantById?.(variantId) ?? (ctx.vm.variants ?? []).find((candidate) => candidate.id === variantId) ?? null;
+  if (record3 === null) {
     throw new NSGetterRuntimeError(
       `Variant '${variantId}' does not exist in this project.`
     );
@@ -75395,6 +75571,7 @@ function currentOwnedValueAttachments(valueId, ctx) {
       });
     }
   }
+  ctx.onUnattributableValueRead?.(`owned-value-parents:${valueId}`);
   const parentIds = new Set(
     evaluatorParentLinks(indexes, valueId).map((link) => link.parentId)
   );
@@ -75671,6 +75848,9 @@ function cloneConstructorArgumentGraph(args) {
       if (member.listKind === "unordered") {
         clone.value = [];
         const entryEnv2 = envFromStamp(clone.genericBindings);
+        args.ctx.onUnattributableValueRead?.(
+          `constructor-import-list:${source.id}`
+        );
         const entries = evaluatorValues(args.ctx).filter((row) => row.containerId === source.id).sort((left, right) => left.id.localeCompare(right.id));
         for (const entry of entries) {
           cloneRow2(entry, entryMember, entryEnv2, clone.id);
@@ -75801,7 +75981,19 @@ function materializeConstructorArgumentValue(args) {
       args.ctx.vm.members
     );
     const row = registerConstructorArgumentRow(args, []);
-    const sourceEntries = args.member.listKind === "unordered" && trackedValueId !== null ? evaluatorValues(args.ctx).filter((entry) => entry.containerId === trackedValueId).sort((left, right) => left.id.localeCompare(right.id)).map((entry) => entry.value) : args.value;
+    let sourceEntries = args.value;
+    if (args.member.listKind === "unordered" && trackedValueId !== null) {
+      args.ctx.onUnattributableValueRead?.(
+        `constructor-argument-list:${trackedValueId}`
+      );
+      const rows = [];
+      for (const entry of evaluatorValues(args.ctx)) {
+        if (entry.containerId === trackedValueId) rows.push(entry);
+      }
+      rows.sort((left, right) => left.id.localeCompare(right.id));
+      sourceEntries = [];
+      for (const entry of rows) sourceEntries.push(entry.value);
+    }
     const ids = [];
     for (const [index, rawEntry] of sourceEntries.entries()) {
       const entryValue = constructorCollectionEntryValue(
@@ -75998,6 +76190,7 @@ function cloneClassValueGraph(receiver, expectedClassId, ctx) {
   const active = /* @__PURE__ */ new Set();
   const clonedBySourceId = /* @__PURE__ */ new Map();
   const constructorArgumentReferenceCounts = /* @__PURE__ */ new Map();
+  ctx.onUnattributableValueRead?.(`class-clone:${sourceId3}`);
   for (const candidate of evaluatorValues(ctx)) {
     for (const argument2 of ownedConstructorArgumentValues(candidate, ctx)) {
       constructorArgumentReferenceCounts.set(
@@ -76006,7 +76199,95 @@ function cloneClassValueGraph(receiver, expectedClassId, ctx) {
       );
     }
   }
-  const cloneRow2 = (sourceRow, sourceMember, clonedContainerId, sourceTypeInfo) => {
+  function cloneInitializerRow(sourceRow, sourceMember, id2, clonedContainerId, sourceTypeInfo) {
+    if (sourceMember === null) {
+      throw new NSGetterRuntimeError(
+        `Class.Clone cannot evaluate initializer-backed value '${sourceRow.id}' because its owning member could not be resolved.`
+      );
+    }
+    const indexes = constructorInitializerIndexes(ctx);
+    const runtimeMemberId = Reflect.get(sourceMember, "id");
+    const compileMemberId = indexes.initializerScopeMemberIds.get(sourceRow.init) ?? indexes.initializerScopeMemberIdsByValueId.get(sourceRow.id) ?? (typeof runtimeMemberId === "string" ? runtimeMemberId : null);
+    const compiled = ensureInitializerCompiled({
+      init: sourceRow.init,
+      member: sourceMember,
+      initializerCompiler: ctx.vm.initializerCompiler,
+      sourceValueId: sourceRow.id,
+      compileMemberId
+    });
+    const declaringClassId = compileMemberId === null ? void 0 : indexes.declaringClassIdsByMemberId.get(compileMemberId)?.values().next().value;
+    const ownerClass = declaringClassId === void 0 ? void 0 : indexes.classById.get(declaringClassId);
+    const constructorId = ownerClass?.requiredConstructorId;
+    const constructor2 = typeof constructorId === "string" ? constructorById(constructorId, ctx) : void 0;
+    const argumentValues = constructor2 === void 0 ? [] : declarationInitializerArgumentValues(
+      constructor2.argumentTypes,
+      `Class.Clone initializer on '${ownerClass?.name ?? sourceMember.name}'`,
+      compiled.parameters.slice(2).some(
+        (parameter4) => runtimeValueReferencesVariable(
+          compiled.instructions,
+          parameter4.id
+        )
+      )
+    );
+    const initializerCreatedValues = [];
+    const evaluated = evaluateInitializerInContext(
+      sourceRow.init,
+      sourceMember,
+      ctx,
+      initializerCreatedValues,
+      argumentValues,
+      sourceRow.id,
+      compileMemberId
+    );
+    if (evaluated.existingValueRow !== void 0) {
+      const adoptedClone = cloneRow2(
+        evaluated.existingValueRow,
+        sourceMember,
+        clonedContainerId,
+        sourceTypeInfo
+      );
+      clonedBySourceId.set(sourceRow.id, adoptedClone);
+      active.delete(sourceRow.id);
+      return adoptedClone;
+    }
+    const {
+      init: _init,
+      value: _value,
+      classId: _classId,
+      ...sourceEnvelope
+    } = sourceRow;
+    void _init;
+    void _value;
+    void _classId;
+    const clone = {
+      ...sourceEnvelope,
+      id: id2,
+      value: evaluated.value,
+      ...evaluated.classId === null ? {} : { classId: evaluated.classId },
+      ...evaluated.genericBindings === void 0 ? {} : { genericBindings: { ...evaluated.genericBindings } },
+      ...deepClonePlainData(pickInstanceProvenance(evaluated)),
+      containerId: clonedContainerId ?? null
+    };
+    if (evaluated.provisionalRootId !== void 0) {
+      retargetDelegateReceiverValueIds(
+        [clone, ...initializerCreatedValues],
+        evaluated.provisionalRootId,
+        clone.id
+      );
+    }
+    registerRuntimeSessionValue(ctx, clone);
+    clonedBySourceId.set(sourceRow.id, clone);
+    if (typeof clone.value === "object" && clone.value !== null) {
+      ctx.__cloneSourceRowIds ??= /* @__PURE__ */ new WeakMap();
+      ctx.__cloneSourceRowIds.set(clone.value, sourceRow.id);
+    }
+    active.delete(sourceRow.id);
+    if (ctx.__indexes !== void 0) {
+      indexEvaluatorRow(ctx.__indexes, clone);
+    }
+    return clone;
+  }
+  function cloneRow2(sourceRow, sourceMember, clonedContainerId, sourceTypeInfo) {
     if (active.has(sourceRow.id)) {
       throw new NSGetterRuntimeError(
         `Class.Clone found a cycle through owned value '${sourceRow.id}'.`
@@ -76016,6 +76297,15 @@ function cloneClassValueGraph(receiver, expectedClassId, ctx) {
     if (prior !== void 0) return prior;
     active.add(sourceRow.id);
     const id2 = freshCloneValueId();
+    if (isInitValueContent(sourceRow)) {
+      return cloneInitializerRow(
+        sourceRow,
+        sourceMember,
+        id2,
+        clonedContainerId,
+        sourceTypeInfo
+      );
+    }
     const clone = {
       ...sourceRow,
       id: id2,
@@ -76070,6 +76360,9 @@ function cloneClassValueGraph(receiver, expectedClassId, ctx) {
             entryTypeInfo
           ).id;
         });
+        ctx.onUnattributableValueRead?.(
+          `class-clone-unordered-list:${sourceRow.id}`
+        );
         for (const child of evaluatorValues(ctx)) {
           if (child.containerId !== sourceRow.id) continue;
           cloneRow2(child, entryMember, id2, entryTypeInfo);
@@ -76116,7 +76409,7 @@ function cloneClassValueGraph(receiver, expectedClassId, ctx) {
       indexEvaluatorRow(ctx.__indexes, clone);
     }
     return clone;
-  };
+  }
   const rootMember = memberForValueRow(source, ctx);
   const typedSource = source.classId === void 0 ? { ...source, classId: runtimeClassId } : source;
   const clonedRoot = cloneRow2(typedSource, rootMember);
@@ -76368,6 +76661,12 @@ var init_evaluateNSGetter = __esm({
         if (existing !== void 0) return existing;
         const source = this.sourceRowById(id2);
         if (source === void 0) return void 0;
+        if (isInitValueContent(source)) {
+          const clone2 = { ...source, init: { ...source.init } };
+          super.set(id2, clone2);
+          this.materializedRows.push(clone2);
+          return clone2;
+        }
         let value = source.value;
         if (Array.isArray(value)) value = [...value];
         else if (typeof value === "object" && value !== null) value = { ...value };
@@ -76691,27 +76990,6 @@ function buildVirtualInstanceMaterializedIndex(args) {
     })
   };
 }
-function firstListInParameterType(typeInfo, depth = 0) {
-  if (typeof typeInfo !== "object" || typeInfo === null) return null;
-  if (depth > CONSTRUCTOR_TYPE_WALK_DEPTH_LIMIT) return "depth-limit";
-  const shape = typeInfo;
-  if (shape.type === 6 /* List */) return "list";
-  const entry = firstListInParameterType(shape.entryTypeInfo, depth + 1);
-  if (entry !== null) return entry;
-  if (Array.isArray(shape.argumentTypes)) {
-    for (const argument2 of shape.argumentTypes) {
-      const nested = firstListInParameterType(argument2, depth + 1);
-      if (nested !== null) return nested;
-    }
-  }
-  return null;
-}
-function constructorBodyIsCorpusFree(constructor2) {
-  if (constructor2.code !== null && constructor2.code.trim() !== "") return false;
-  if ((constructor2.baseArguments ?? []).length > 0) return false;
-  if ((constructor2.baseInitializerFields ?? []).length > 0) return false;
-  return true;
-}
 function withoutInitializerConstructionFields(init) {
   if (init.compiled === void 0) return init;
   const baseline = deepClonePlainData(init);
@@ -76769,6 +77047,31 @@ function claimVirtualIdentity(args) {
 }
 function expandStoredInstance(args) {
   const recorder = args.readRecorder ?? null;
+  const readTracking = recorder === null ? void 0 : new InitializerReadSet();
+  const trackMaterialization = readTracking === void 0 ? (materialize) => materialize() : (materialize) => {
+    try {
+      return materialize();
+    } finally {
+      for (const valueId of readTracking.valueIds) {
+        recorder?.recordValueRead(valueId);
+      }
+      for (const textId of readTracking.localizedTextIds) {
+        recorder?.recordLocalizedTextRead(textId);
+      }
+      for (const variantId of readTracking.variantIds) {
+        recorder?.recordVariantRead(variantId);
+      }
+      for (const memberId of readTracking.staticMemberIds) {
+        recorder?.recordStaticMemberRead(memberId);
+      }
+      for (const containerId of readTracking.containerIds) {
+        recorder?.recordContainerMembershipRead(containerId);
+      }
+      if (readTracking.hasUnattributableValueRead) {
+        recorder?.recordGlobalRead("initializer-runtime");
+      }
+    }
+  };
   recorder?.recordValueRead(args.instanceRoot.id);
   const rootMember = resolveMember2(args.rootMember, args.document.members);
   if (!isMemberClassBase(rootMember)) {
@@ -76807,25 +77110,6 @@ function expandStoredInstance(args) {
       `Virtual expansion root "${args.instanceRoot.id}" has no durable overload identity for class "${classId}"; keep this historical graph materialized.`
     );
   }
-  if (recorder !== null && requiredConstructor !== null) {
-    if (!constructorBodyIsCorpusFree(requiredConstructor)) {
-      recorder.recordGlobalRead(
-        `authored-constructor-body:${requiredConstructor.id}`
-      );
-    }
-    for (const typeInfo of requiredConstructor.argumentTypes) {
-      if (firstListInParameterType(typeInfo) === null) continue;
-      recorder.recordGlobalRead(
-        `constructor-argument-list:${requiredConstructor.id}`
-      );
-      break;
-    }
-  }
-  if (recorder !== null && typeof instanceRoot.instanceVariantId === "string") {
-    recorder.recordGlobalRead(
-      `variant-initialize:${instanceRoot.instanceVariantId}`
-    );
-  }
   const storedArgs = instanceRoot.constructorArgs ?? {};
   if (requiredConstructor !== null && instanceRoot.constructorArgs == null) {
     throw new VirtualExpansionUnsupportedError(
@@ -76923,22 +77207,32 @@ function expandStoredInstance(args) {
       code: `virtual-replay:${args.instanceRoot.id}`,
       compiled
     };
-    return materializeInitializerValue({
-      document: args.document,
-      member: replayMember,
-      row: { ...envelope, init },
-      storedConstructionReplay: true,
-      constructionBaselineReplay: fields.length === 0
-    });
+    return trackMaterialization(
+      () => materializeInitializerValue({
+        document: args.document,
+        member: replayMember,
+        row: { ...envelope, init },
+        storedConstructionReplay: true,
+        constructionBaselineReplay: fields.length === 0,
+        ...readTracking === void 0 ? {} : { readTracking },
+        saveStaticBindings: args.saveStaticBindings,
+        sessionStaticBindings: args.sessionStaticBindings
+      })
+    );
   };
   const replayDeclaredDefault = () => {
     const stampEnv = instanceRoot.genericBindings == null || Object.keys(instanceRoot.genericBindings).length === 0 ? null : envFromStamp(instanceRoot.genericBindings);
-    const built = materializeMemberDefaultValue({
-      document: args.document,
-      member: replayMember,
-      envelope,
-      ...stampEnv === null ? {} : { genericEnv: stampEnv }
-    });
+    const built = trackMaterialization(
+      () => materializeMemberDefaultValue({
+        document: args.document,
+        member: replayMember,
+        envelope,
+        ...stampEnv === null ? {} : { genericEnv: stampEnv },
+        ...readTracking === void 0 ? {} : { readTracking },
+        saveStaticBindings: args.saveStaticBindings,
+        sessionStaticBindings: args.sessionStaticBindings
+      })
+    );
     return {
       ...built,
       root: {
@@ -77049,8 +77343,7 @@ function resolveVirtualInstanceGraph(args) {
     const materialized = effectiveMaterializedId === null ? null : readMaterializedRow(effectiveMaterializedId);
     const effectiveId = materialized?.id ?? indexed.virtualId;
     const effective = {
-      ...cloneRow(indexed.expandedRow),
-      ...materialized === null ? {} : cloneRow(materialized),
+      ...mergeExpandedAndMaterializedRow(indexed.expandedRow, materialized),
       id: effectiveId,
       // Virtual rows inherit partition and timestamps from the root. Real rows
       // retain their own envelope through the spread above.
@@ -77093,7 +77386,7 @@ function resolveVirtualInstanceGraph(args) {
         const listMember = indexed.member;
         effective.value = [];
         const childPaths = expansion.childPathsByParentPath.get(pathKey) ?? [];
-        recorder?.recordGlobalRead(`unordered-list-membership:${effectiveId}`);
+        recorder?.recordContainerMembershipRead(effectiveId);
         const storedEntryIds = materializedUnorderedEntryIdsByContainerId.get(effectiveId) ?? [];
         const storedEntries = storedEntryIds.flatMap((storedEntryId) => {
           const entry = readMaterializedRow(storedEntryId);
@@ -77266,19 +77559,18 @@ function resolveVirtualInstanceGraph(args) {
     root: rootLocation
   };
 }
+function mergeExpandedAndMaterializedRow(expanded, materialized) {
+  const expandedClone = cloneRow(expanded);
+  if (materialized === null) return expandedClone;
+  const materializedClone = cloneRow(materialized);
+  return isLiteralValueContent(materialized) ? overlayLiteralValueContent(expandedClone, materializedClone) : { ...expandedClone, ...materializedClone };
+}
 function firstUnattributableExpansionMember(expansion) {
   for (const node of expansion.nodesByPath.values()) {
     const member = node.member;
-    if (isMemberListBase(member) && listKindOf(member) === "unordered") {
-      return `unordered-list-member:${node.memberId}`;
-    }
     if (CORPUS_SCANNING_MEMBER_KINDS.has(member.kind)) {
       return `corpus-scanning-member-kind:${node.memberId}`;
     }
-    const declaredDefault = member.defaultValue;
-    if (declaredDefault !== void 0 && declaredDefault !== null && "init" in declaredDefault && declaredDefault.init !== void 0 && declaredDefault.init !== null) {
-      return `authored-initializer-member:${node.memberId}`;
-    }
   }
   return null;
 }
@@ -78668,7 +78960,8 @@ function resolveVariantInstanceGraphForDocument(args) {
   const priorExpanded = expandStoredInstance({
     document,
     instanceRoot: args.priorInstanceRoot,
-    rootMember
+    rootMember,
+    readRecorder: args.readRecorder
   });
   const priorGraph = resolveVirtualInstanceGraph({
     document,
@@ -78676,7 +78969,8 @@ function resolveVariantInstanceGraphForDocument(args) {
     rootMember,
     expandedRoot: priorExpanded.root,
     expandedRows: priorExpanded.rows,
-    materializedRows: [...materializedById.values()]
+    materializedRows: [...materializedById.values()],
+    readRecorder: args.readRecorder
   });
   for (const valueId of args.answeredValueIds) {
     if (!priorGraph.locationsById.has(valueId)) {
@@ -78704,7 +78998,8 @@ function resolveVariantInstanceGraphForDocument(args) {
   const nextExpanded = expandStoredInstance({
     document,
     instanceRoot: args.nextInstanceRoot,
-    rootMember
+    rootMember,
+    readRecorder: args.readRecorder
   });
   const nextGraph = resolveVirtualInstanceGraph({
     document,
@@ -78712,7 +79007,8 @@ function resolveVariantInstanceGraphForDocument(args) {
     rootMember,
     expandedRoot: nextExpanded.root,
     expandedRows: nextExpanded.rows,
-    materializedRows: [...materializedById.values()]
+    materializedRows: [...materializedById.values()],
+    readRecorder: args.readRecorder
   });
   const root = nextGraph.rowsById.get(args.nextInstanceRoot.id);
   if (root === void 0) {
@@ -78787,7 +79083,8 @@ function createHeadlessVirtualInstanceResolver(args) {
       const expanded = expandStoredInstance({
         document: resolverDocument,
         instanceRoot,
-        rootMember: member
+        rootMember: member,
+        readRecorder: args.readRecorder
       });
       const graph = resolveVirtualInstanceGraph({
         document: resolverDocument,
@@ -78795,7 +79092,8 @@ function createHeadlessVirtualInstanceResolver(args) {
         rootMember: member,
         expandedRoot: expanded.root,
         expandedRows: expanded.rows,
-        materializedIndex
+        materializedIndex,
+        readRecorder: args.readRecorder
       });
       graphRowsByRootId.set(rootId, graph.rowsById);
       for (const [id2, row] of graph.rowsById) {
@@ -78816,8 +79114,11 @@ function createHeadlessVirtualInstanceResolver(args) {
     }
   };
   const virtualInstanceRowsForValue = (receiverValueId) => {
+    args.readRecorder?.recordValuePlacementRead();
+    args.readRecorder?.recordValueRead(receiverValueId);
     let placement = placements().get(receiverValueId) ?? null;
     while (placement !== null) {
+      args.readRecorder?.recordValueRead(placement.valueId);
       const raw = rawById.get(placement.valueId);
       if (raw !== void 0 && isLiteralValueContent(raw) && isVirtualInstanceRootShape(raw)) {
         return [...expandRoot(placement.valueId, placement.memberId).values()];
@@ -78838,7 +79139,7 @@ function createHeadlessVirtualInstanceResolver(args) {
     }
   };
 }
-var KEPT_ROW_SAMPLE_LIMIT, CORPUS_SCANNING_MEMBER_KINDS, CONSTRUCTOR_TYPE_WALK_DEPTH_LIMIT, VirtualExpansionUnsupportedError, ROOT_PATH, SYNTHETIC_LINEAGE_PREFIXES, resolverDocumentsByDocument;
+var KEPT_ROW_SAMPLE_LIMIT, CORPUS_SCANNING_MEMBER_KINDS, VirtualExpansionUnsupportedError, ROOT_PATH, SYNTHETIC_LINEAGE_PREFIXES, resolverDocumentsByDocument;
 var init_virtual_instance_values = __esm({
   "../src/database/virtual-instance-values.ts"() {
     "use strict";
@@ -78852,6 +79153,7 @@ var init_virtual_instance_values = __esm({
     init_instance_provenance();
     init_unordered_list_membership();
     init_neoscript();
+    init_evaluateInitializer();
     init_init_backed_value_materialization();
     init_constructor_argument_ownership();
     init_constructors2();
@@ -78859,15 +79161,8 @@ var init_virtual_instance_values = __esm({
     KEPT_ROW_SAMPLE_LIMIT = 12;
     CORPUS_SCANNING_MEMBER_KINDS = /* @__PURE__ */ new Set([
       9 /* Lookup */,
-      18 /* DialogueLookup */,
-      10 /* NSProperty */,
-      23 /* NSFunction */,
-      13 /* Function */,
-      24 /* FunctionRef */,
-      25 /* NSDelegate */,
-      26 /* NSAction */
+      18 /* DialogueLookup */
     ]);
-    CONSTRUCTOR_TYPE_WALK_DEPTH_LIMIT = 8;
     VirtualExpansionUnsupportedError = class extends Error {
       constructor(message) {
         super(message);
@@ -78881,24 +79176,74 @@ var init_virtual_instance_values = __esm({
 });
 
 // ../src/view-models/neoscript-evaluator/evaluateInitializer.ts
-function initializerEvaluatorLookups(document) {
-  const key = document.evaluatorCache?.key ?? document;
-  const revision = document.evaluatorCache?.revision;
-  const cached = evaluatorLookupsByDocument.get(key);
-  if (cached !== void 0 && (revision === void 0 ? cached.members === document.members && cached.values === document.values : cached.revision === revision)) {
+function initializerEvaluatorCacheKey(document) {
+  return document.evaluatorCache?.key ?? document;
+}
+function initializerEvaluatorCacheRevision(document) {
+  return document.evaluatorCache?.revision;
+}
+function initializerEvaluatorLookups(document, readTracking) {
+  const trackedHeadless = readTracking !== void 0 && document.databaseVM === void 0;
+  const indexKey = initializerEvaluatorCacheKey(document);
+  const lookupKey = document.databaseVM ?? indexKey;
+  const revision = initializerEvaluatorCacheRevision(document);
+  const cached = evaluatorLookupsByDocument.get(lookupKey);
+  if (!trackedHeadless && cached !== void 0 && (revision === void 0 ? cached.members === document.members && cached.values === document.values : cached.revision === revision)) {
     return cached.lookups;
   }
-  const indexedLookups = makeEvaluatorLookups(
-    document.members,
-    document.values,
-    {
-      includeValueGraphIndexes: true,
-      constructorInitializerDocument: document
-    }
+  if (document.databaseVM !== void 0) {
+    const databaseVM = document.databaseVM;
+    const lookups2 = {
+      memberById: (id2) => databaseVM.memberById(id2),
+      valueById: (id2) => databaseVM.valueById(id2),
+      localizedTextById: (id2) => databaseVM.localizedTextById?.(id2) ?? null,
+      ...databaseVM.hasStoredValueId === void 0 ? {} : {
+        hasStoredValueId: (id2) => databaseVM.hasStoredValueId?.(id2) ?? false
+      },
+      variantById: (id2) => databaseVM.variantById?.(id2) ?? null,
+      storedValuePlacementForValueId: (id2) => databaseVM.storedValuePlacementForValueId?.(id2) ?? null,
+      unorderedListEntryIds: (containerValueId) => {
+        const resolved = databaseVM.unorderedListEntryIds?.(containerValueId);
+        if (resolved === void 0) {
+          throw new Error(
+            `Evaluator database resolves no unordered-list membership for container "${containerValueId}".`
+          );
+        }
+        return resolved;
+      },
+      virtualInstanceRowsForValue: (receiverValueId) => databaseVM.virtualInstanceRowsForValue(receiverValueId),
+      rowForValueReference: (value) => databaseVM.rowForValueReference?.(value) ?? null,
+      resolveVariantInstanceGraph: (args) => {
+        const resolver = databaseVM.resolveVariantInstanceGraph;
+        if (resolver === void 0) {
+          throw new Error(
+            "Evaluator database has no virtual variant resolver."
+          );
+        }
+        return resolver.call(databaseVM, args);
+      },
+      ...databaseVM.evaluatorIndexes === void 0 ? {} : { evaluatorIndexes: databaseVM.evaluatorIndexes },
+      ...databaseVM.constructorInitializerIndexes === void 0 ? {} : {
+        constructorInitializerIndexes: databaseVM.constructorInitializerIndexes
+      }
+    };
+    evaluatorLookupsByDocument.set(lookupKey, {
+      members: document.members,
+      values: document.values,
+      revision,
+      lookups: lookups2
+    });
+    return lookups2;
+  }
+  const indexedLookups = indexedInitializerEvaluatorLookups(
+    document,
+    indexKey,
+    revision
   );
   const headlessVirtualResolver = document.databaseVM === void 0 ? createHeadlessVirtualInstanceResolver({
     document,
-    resolverLookups: () => lookups
+    resolverLookups: () => lookups,
+    ...readTracking === void 0 ? {} : { readRecorder: virtualReadRecorder(readTracking) }
   }) : null;
   const lookups = {
     ...indexedLookups,
@@ -78916,11 +79261,13 @@ function initializerEvaluatorLookups(document) {
       resolveVariantInstanceGraph: (args) => resolveVariantInstanceGraphForDocument({
         document,
         resolverLookups: lookups,
+        ...readTracking === void 0 ? {} : { readRecorder: virtualReadRecorder(readTracking) },
         ...args
       })
     } : {
       memberById: (id2) => document.databaseVM?.memberById(id2) ?? null,
       valueById: (id2) => document.databaseVM?.valueById(id2) ?? null,
+      variantById: (id2) => document.databaseVM?.variantById?.(id2) ?? null,
       // The VM's `valueById` answers EXPANDED-first: a collapse-stamped
       // root resolves to a record the VM minted, an object the raw value
       // index has never seen. Reference-identity dispatch (`.Id`, `is`,
@@ -78954,7 +79301,26 @@ function initializerEvaluatorLookups(document) {
       }
     }
   };
-  evaluatorLookupsByDocument.set(key, {
+  if (!trackedHeadless) {
+    evaluatorLookupsByDocument.set(lookupKey, {
+      members: document.members,
+      values: document.values,
+      revision,
+      lookups
+    });
+  }
+  return lookups;
+}
+function indexedInitializerEvaluatorLookups(document, key, revision) {
+  const cached = indexedEvaluatorLookupsByDocument.get(key);
+  if (cached !== void 0 && (revision === void 0 ? cached.members === document.members && cached.values === document.values : cached.revision === revision)) {
+    return cached.lookups;
+  }
+  const lookups = makeEvaluatorLookups(document.members, document.values, {
+    includeValueGraphIndexes: true,
+    constructorInitializerDocument: document
+  });
+  indexedEvaluatorLookupsByDocument.set(key, {
     members: document.members,
     values: document.values,
     revision,
@@ -78962,22 +79328,61 @@ function initializerEvaluatorLookups(document) {
   });
   return lookups;
 }
-function buildInitializerRootValueWithLookups(document, lookups) {
+function buildInitializerRootValueWithLookups(document, lookups, tracking) {
   const rootValue = {};
   for (const { root, memberId } of projectRootMembersInDisplayOrder(
     document.project
   )) {
     const member = lookups.memberById(memberId);
-    if (member === null || typeof member.valueId !== "string") {
+    if (member === null) {
       rootValue[root.key] = null;
       continue;
     }
-    rootValue[root.key] = lookups.valueById(member.valueId)?.value ?? null;
+    tracking?.staticMemberDependencies?.add(member.id);
+    const bindings = root.storage === "save" /* Save */ ? tracking?.saveStaticBindings : root.storage === "session" /* Session */ ? tracking?.sessionStaticBindings : void 0;
+    const boundTarget = staticBindingEntry(bindings, member.id);
+    const targetId = boundTarget.present ? boundTarget.value : member.valueId;
+    if (typeof targetId !== "string") {
+      rootValue[root.key] = null;
+      continue;
+    }
+    tracking?.valueDependencies?.add(targetId);
+    rootValue[root.key] = lookups.valueById(targetId)?.value ?? null;
   }
   return rootValue;
 }
+function staticBindingEntry(bindings, memberId) {
+  if (bindings === void 0) return { present: false, value: null };
+  if (isStaticBindingMap(bindings)) {
+    return {
+      present: bindings.has(memberId),
+      value: bindings.get(memberId) ?? null
+    };
+  }
+  return {
+    present: Object.hasOwn(bindings, memberId),
+    value: bindings[memberId] ?? null
+  };
+}
+function isStaticBindingMap(bindings) {
+  return "get" in bindings && typeof bindings.get === "function" && "has" in bindings && typeof bindings.has === "function";
+}
+function virtualReadRecorder(reads) {
+  return {
+    recordValueRead: (id2) => reads.valueIds.add(id2),
+    recordLocalizedTextRead: (id2) => reads.localizedTextIds.add(id2),
+    recordVariantRead: (id2) => reads.variantIds.add(id2),
+    recordStaticMemberRead: (id2) => reads.staticMemberIds.add(id2),
+    recordContainerMembershipRead: (id2) => reads.containerIds.add(id2),
+    recordValuePlacementRead: reads.recordValuePlacementRead,
+    recordGlobalRead: reads.recordUnattributableValueRead
+  };
+}
 function evaluateMemberInitializer(args) {
-  const databaseVM = initializerEvaluatorLookups(args.document);
+  const databaseVM = initializerEvaluatorLookups(
+    args.document,
+    args.readTracking
+  );
   const initializerIndexes = databaseVM.constructorInitializerIndexes;
   const compileMemberId = initializerIndexes?.initializerScopeMemberIds.get(args.init) ?? (args.sourceValueId === null || args.sourceValueId === void 0 ? void 0 : initializerIndexes?.initializerScopeMemberIdsByValueId.get(
     args.sourceValueId
@@ -79013,7 +79418,18 @@ function evaluateMemberInitializer(args) {
       initializerCompiler: args.document.initializerCompiler
     },
     thisValue: null,
-    rootValue: buildInitializerRootValueWithLookups(args.document, databaseVM),
+    rootValue: buildInitializerRootValueWithLookups(args.document, databaseVM, {
+      valueDependencies: args.readTracking?.valueIds,
+      staticMemberDependencies: args.readTracking?.staticMemberIds,
+      saveStaticBindings: args.saveStaticBindings,
+      sessionStaticBindings: args.sessionStaticBindings
+    }),
+    valueDependencies: args.readTracking?.valueIds,
+    localizedTextDependencies: args.readTracking?.localizedTextIds,
+    variantDependencies: args.readTracking?.variantIds,
+    containerDependencies: args.readTracking?.containerIds,
+    staticMemberDependencies: args.readTracking?.staticMemberIds,
+    onUnattributableValueRead: args.readTracking?.recordUnattributableValueRead,
     saveStaticBindings: args.saveStaticBindings,
     sessionStaticBindings: args.sessionStaticBindings,
     ...args.storedConstructionReplay === true ? {
@@ -79076,7 +79492,7 @@ function evaluateMemberInitializer(args) {
     }
   };
 }
-var evaluatorLookupsByDocument;
+var evaluatorLookupsByDocument, indexedEvaluatorLookupsByDocument, InitializerReadSet;
 var init_evaluateInitializer = __esm({
   "../src/view-models/neoscript-evaluator/evaluateInitializer.ts"() {
     "use strict";
@@ -79087,6 +79503,23 @@ var init_evaluateInitializer = __esm({
     init_evaluateNSGetter();
     init_virtual_instance_values();
     evaluatorLookupsByDocument = /* @__PURE__ */ new WeakMap();
+    indexedEvaluatorLookupsByDocument = /* @__PURE__ */ new WeakMap();
+    InitializerReadSet = class {
+      valueIds = /* @__PURE__ */ new Set();
+      localizedTextIds = /* @__PURE__ */ new Set();
+      variantIds = /* @__PURE__ */ new Set();
+      containerIds = /* @__PURE__ */ new Set();
+      staticMemberIds = /* @__PURE__ */ new Set();
+      hasValuePlacementRead = false;
+      hasUnattributableValueRead = false;
+      recordUnattributableValueRead = (_reason) => {
+        void _reason;
+        this.hasUnattributableValueRead = true;
+      };
+      recordValuePlacementRead = () => {
+        this.hasValuePlacementRead = true;
+      };
+    };
   }
 });
 
@@ -79102,8 +79535,12 @@ var init_neoscript_evaluator = __esm({
 
 // ../src/database/init-backed-value-materialization.ts
 function declarationInitializerContext(document) {
-  const cached = declarationInitializerContextByDocument.get(document);
-  if (cached !== void 0) return cached;
+  const key = initializerEvaluatorCacheKey(document);
+  const revision = initializerEvaluatorCacheRevision(document);
+  const cached = declarationInitializerContextByDocument.get(key);
+  if (cached !== void 0 && (revision === void 0 ? cached.members === document.members && cached.values === document.values : cached.revision === revision)) {
+    return cached.context;
+  }
   const initializerValueIds = new Set(
     document.values.filter(isInitValueContent).map((value) => value.id)
   );
@@ -79118,7 +79555,12 @@ function declarationInitializerContext(document) {
     rootOwners
   );
   const created = { valuesById, rootOwners };
-  declarationInitializerContextByDocument.set(document, created);
+  declarationInitializerContextByDocument.set(key, {
+    members: document.members,
+    values: document.values,
+    revision,
+    context: created
+  });
   return created;
 }
 function evaluateInitializerMaterialization(args) {
@@ -79133,7 +79575,10 @@ function evaluateInitializerMaterialization(args) {
     ...args.storedConstructionReplay === true ? { storedConstructionReplay: true } : {},
     ...args.constructionBaselineReplay === true ? { constructionBaselineReplay: true } : {},
     ...args.argumentValues === void 0 ? {} : { argumentValues: args.argumentValues },
-    sourceValueId: args.sourceValueId ?? null
+    sourceValueId: args.sourceValueId ?? null,
+    readTracking: args.readTracking,
+    saveStaticBindings: args.saveStaticBindings,
+    sessionStaticBindings: args.sessionStaticBindings
   });
   return { evaluated, createdValues, storageKeyDeclarations };
 }
@@ -79169,7 +79614,10 @@ function materializeInitializerValue(args) {
     ...args.storedConstructionReplay === true ? { storedConstructionReplay: true } : {},
     ...args.constructionBaselineReplay === true ? { constructionBaselineReplay: true } : {},
     ...args.argumentValues === void 0 ? {} : { argumentValues: args.argumentValues },
-    sourceValueId: args.row.id
+    sourceValueId: args.row.id,
+    readTracking: args.readTracking,
+    saveStaticBindings: args.saveStaticBindings,
+    sessionStaticBindings: args.sessionStaticBindings
   });
   const {
     init: _init,
@@ -79177,6 +79625,9 @@ function materializeInitializerValue(args) {
     classId: _classId,
     ...envelope
   } = args.row;
+  void _init;
+  void _value;
+  void _classId;
   const root = {
     ...envelope,
     value: evaluated.value,
@@ -79212,6 +79663,9 @@ function materializeInitializerValue(args) {
 function materializeMemberDefaultValue(args) {
   const createdValues = [];
   const storageKeyDeclarations = /* @__PURE__ */ new Map();
+  args.readTracking?.recordUnattributableValueRead(
+    `declaration-owner-resolution:${args.envelope.id}`
+  );
   const { valuesById, rootOwners } = declarationInitializerContext(
     args.document
   );
@@ -79232,15 +79686,14 @@ function materializeMemberDefaultValue(args) {
       (candidate) => candidate.id === constructorId
     );
     if (constructor2 === void 0) return [];
-    const defaults = parameterDefaultsAsFullArguments(
-      constructor2.argumentTypes,
-      `Declaration template on '${ownerClass.name}'`
-    );
-    if (defaults !== null) return defaults;
     const parameterNames = new Set(
       constructor2.argumentTypes.map((argument2) => argument2.name)
     );
-    return initializerReferencesAnyIdentifier(init.code, parameterNames) ? [] : constructor2.argumentTypes.map(() => null);
+    return declarationInitializerArgumentValues(
+      constructor2.argumentTypes,
+      `Declaration template on '${ownerClass.name}'`,
+      initializerReferencesAnyIdentifier(init.code, parameterNames)
+    );
   };
   const built = buildDefaultMemberValue({
     document: args.document,
@@ -79262,7 +79715,10 @@ function materializeMemberDefaultValue(args) {
         init,
         sourceValueId ?? null
       ),
-      sourceValueId: sourceValueId ?? null
+      sourceValueId: sourceValueId ?? null,
+      readTracking: args.readTracking,
+      saveStaticBindings: args.saveStaticBindings,
+      sessionStaticBindings: args.sessionStaticBindings
     })
   });
   const interior = createdValues.filter((created) => created.id !== built.id);
@@ -79292,6 +79748,7 @@ var init_init_backed_value_materialization = __esm({
     init_inheritance();
     init_neoscript_evaluator();
     init_evaluateNSGetter();
+    init_evaluateInitializer();
     init_value_row_owner_members();
     init_compile_ns_property();
     declarationInitializerContextByDocument = /* @__PURE__ */ new WeakMap();
@@ -87811,7 +88268,11 @@ function validateWorldLayerLinkClassTargets(args) {
   }
 }
 function worldLayerLinkTargetDescriptorForClass(classId, classes) {
-  const worldKind = resolveWorldSystemClassKind(classId, classes);
+  return worldLayerLinkTargetDescriptor(
+    resolveWorldSystemClassKind(classId, classes)
+  );
+}
+function worldLayerLinkTargetDescriptor(worldKind) {
   if (worldKind === NeoWorldSystemClassKind.TileLayerLink) {
     return {
       relationKind: InternalRecordRelationKind.WorldTileLayerLinkTarget,
@@ -87833,9 +88294,11 @@ function worldLayerLinkTargetRelations(classId, descriptor, relations) {
 }
 function resolveWorldLayerLinkTarget(args) {
   const label = args.linkLabel ?? `Layer-link class "${args.sourceClassId}"`;
-  const sourceClass = args.classes.find(
-    (candidate) => candidate.id === args.sourceClassId
-  );
+  const relationResolver = args.relationResolver ?? createEffectiveClassRelationResolver({
+    classes: args.classes,
+    relations: args.relations
+  });
+  const sourceClass = relationResolver.classesById.get(args.sourceClassId);
   if (sourceClass === void 0) {
     throw new Error(
       `${label} references missing class "${args.sourceClassId}".`
@@ -87846,21 +88309,18 @@ function resolveWorldLayerLinkTarget(args) {
       `${label} cannot instantiate abstract class "${args.sourceClassId}".`
     );
   }
-  const descriptor = worldLayerLinkTargetDescriptorForClass(
-    args.sourceClassId,
-    args.classes
+  const descriptor = args.worldKindsByClassId === void 0 ? worldLayerLinkTargetDescriptorForClass(args.sourceClassId, args.classes) : worldLayerLinkTargetDescriptor(
+    args.worldKindsByClassId.get(args.sourceClassId) ?? null
   );
   if (descriptor === null) {
     throw new Error(
       `${label} class "${args.sourceClassId}" is not a tile/object layer-link class.`
     );
   }
-  const effective = resolveEffectiveClassRelations({
-    relationKind: descriptor.relationKind,
-    sourceClassId: args.sourceClassId,
-    relations: args.relations,
-    classes: args.classes
-  });
+  const effective = relationResolver.resolve(
+    descriptor.relationKind,
+    args.sourceClassId
+  );
   if (effective.length > 1) {
     throw new Error(
       `${label} class "${args.sourceClassId}" resolves more than one effective target for relation kind "${descriptor.relationKind}".`
@@ -87868,8 +88328,8 @@ function resolveWorldLayerLinkTarget(args) {
   }
   const relationTarget = effective[0] ?? null;
   if (relationTarget !== null) {
-    const declarationClass = args.classes.find(
-      (candidate) => candidate.id === relationTarget.declaredSourceRecordId
+    const declarationClass = relationResolver.classesById.get(
+      relationTarget.declaredSourceRecordId
     );
     if (declarationClass?.system?.worldKind === NeoWorldSystemClassKind.TileLayerLink || declarationClass?.system?.worldKind === NeoWorldSystemClassKind.ObjectLayerLink) {
       throw new Error(
@@ -87883,9 +88343,7 @@ function resolveWorldLayerLinkTarget(args) {
     );
   }
   const targetClassId = relationTarget.targetRecordId;
-  const targetClass = args.classes.find(
-    (candidate) => candidate.id === targetClassId
-  );
+  const targetClass = relationResolver.classesById.get(targetClassId);
   if (targetClass === void 0) {
     throw new Error(`${label} targets missing layer class "${targetClassId}".`);
   }
@@ -87894,10 +88352,7 @@ function resolveWorldLayerLinkTarget(args) {
       `${label} targets abstract layer class "${targetClassId}".`
     );
   }
-  const targetWorldKind = resolveWorldSystemClassKind(
-    targetClass.id,
-    args.classes
-  );
+  const targetWorldKind = args.worldKindsByClassId?.get(targetClass.id) ?? resolveWorldSystemClassKind(targetClass.id, args.classes);
   if (targetWorldKind !== descriptor.targetWorldKind) {
     throw new Error(
       `${label} targets class "${targetClassId}" of world kind "${String(targetWorldKind)}"; expected "${descriptor.targetWorldKind}".`
@@ -98277,7 +98732,7 @@ function reconcileVariantConstructorArgs(args) {
   const valueById = indexRecordsById(postDocument.values);
   const classById = indexRecordsById(postDocument.classes);
   const memberById2 = indexRecordsById(postDocument.members);
-  const constructorById = indexRecordsById(postDocument.constructors ?? []);
+  const constructorById2 = indexRecordsById(postDocument.constructors ?? []);
   let baseHashByValueId = null;
   for (const variant of variants) {
     const root = valueById.get(variant.valueId);
@@ -98290,7 +98745,7 @@ function reconcileVariantConstructorArgs(args) {
     if (schemaClass2 === void 0) continue;
     const constructorId = schemaClass2.requiredConstructorId;
     if (typeof constructorId !== "string") continue;
-    const constructorRecord = constructorById.get(constructorId);
+    const constructorRecord = constructorById2.get(constructorId);
     if (constructorRecord === void 0) continue;
     if (typeof root.value !== "object" || root.value === null) continue;
     if (Array.isArray(root.value)) continue;
@@ -99463,7 +99918,7 @@ function animationFamilyClasses(document) {
   const classes = new Map(document.classes.map((entry) => [entry.id, entry]));
   const animationKinds = new Set(WORLD_SYSTEM_ANIMATION_KINDS);
   const result = /* @__PURE__ */ new Map();
-  const resolve4 = (classId, visiting) => {
+  const resolve5 = (classId, visiting) => {
     const cached = result.get(classId);
     if (cached !== void 0) return cached;
     if (visiting.has(classId)) return false;
@@ -99475,11 +99930,11 @@ function animationFamilyClasses(document) {
       return true;
     }
     const nextVisiting = new Set(visiting).add(classId);
-    const belongs = typeof schemaClass2.extendsClassId === "string" && resolve4(schemaClass2.extendsClassId, nextVisiting);
+    const belongs = typeof schemaClass2.extendsClassId === "string" && resolve5(schemaClass2.extendsClassId, nextVisiting);
     result.set(classId, belongs);
     return belongs;
   };
-  for (const classId of classes.keys()) resolve4(classId, /* @__PURE__ */ new Set());
+  for (const classId of classes.keys()) resolve5(classId, /* @__PURE__ */ new Set());
   return new Set(
     [...result].flatMap(([classId, belongs]) => belongs ? [classId] : [])
   );
@@ -100331,6 +100786,28 @@ var init_value_base_desync = __esm({
 });
 
 // src/project-source/workspace-status-core.ts
+function recordUpsertChange(args) {
+  if (args.base.conflictServerHash === null) {
+    return {
+      kind: "create",
+      recordKind: args.recordKind,
+      recordId: args.recordId,
+      file: args.file,
+      nextData: args.nextData
+    };
+  }
+  const inConflictState = typeof args.base.conflictServerHash === "string";
+  return {
+    kind: "update",
+    recordKind: args.recordKind,
+    recordId: args.recordId,
+    file: args.file,
+    nextData: args.nextData,
+    baseData: inConflictState ? args.base.conflictServerData : args.base.data,
+    baseContentHash: args.base.contentHash,
+    casBaseHash: inConflictState ? args.base.conflictServerHash : args.base.contentHash
+  };
+}
 function listVirtualProjectSourceFilesV4(files) {
   const selected = files.filter((file) => {
     const kind = neoProjectSourceKind(file.path);
@@ -100814,16 +101291,15 @@ function computeWorkspaceStatus(workspace, options) {
     }
     const inConflictState = baseState.conflictServerHash !== void 0;
     if (!recordsSemanticallyEqual(record3.recordKind, fullData, baseState.data) || inConflictState) {
-      changes.push({
-        kind: "update",
-        recordKind: record3.recordKind,
-        recordId: record3.recordId,
-        file: record3.file,
-        nextData: fullData,
-        baseData: inConflictState ? baseState.conflictServerData : baseState.data,
-        baseContentHash: baseState.contentHash,
-        casBaseHash: inConflictState ? baseState.conflictServerHash : baseState.contentHash
-      });
+      changes.push(
+        recordUpsertChange({
+          base: baseState,
+          recordKind: record3.recordKind,
+          recordId: record3.recordId,
+          file: record3.file,
+          nextData: fullData
+        })
+      );
     }
   }
   const deletedValueIds = /* @__PURE__ */ new Set();
@@ -100835,6 +101311,7 @@ function computeWorkspaceStatus(workspace, options) {
       (error) => error.file === recordFile && isBlockingSchemaSourceError(error)
     ) || conflictedFiles.includes(recordFile);
     if (fileStillBroken) continue;
+    if (recordState.conflictServerHash === null) continue;
     if (recordState.recordKind === "value") {
       deletedValueIds.add(recordState.recordId);
     }
@@ -100995,16 +101472,15 @@ function computeWorkspaceStatus(workspace, options) {
     )) {
       continue;
     }
-    changes.push({
-      kind: "update",
-      recordKind: "project-file",
-      recordId: fileId,
-      file: record3.file,
-      nextData: record3.fullData,
-      baseData: base.data,
-      baseContentHash: base.contentHash,
-      casBaseHash: base.contentHash
-    });
+    changes.push(
+      recordUpsertChange({
+        base,
+        recordKind: "project-file",
+        recordId: fileId,
+        file: record3.file,
+        nextData: record3.fullData
+      })
+    );
   }
   let binaryFiles = [];
   let binaryChanges = [];
@@ -110306,8 +110782,157 @@ var init_value_sources = __esm({
   }
 });
 
+// src/project-source/workspace-source-path.ts
+import { existsSync as existsSync3, lstatSync, realpathSync } from "node:fs";
+import { dirname as dirname4, isAbsolute as isAbsolute2, relative, resolve as resolve2, sep } from "node:path";
+function normalizeWorkspaceSourcePath(path) {
+  const normalized = path.replaceAll("\\", "/");
+  if (normalized.length === 0) {
+    throw new Error("Project source path is empty.");
+  }
+  if (normalized.includes("\0")) {
+    throw new Error(
+      `Project source path ${JSON.stringify(path)} contains a null byte.`
+    );
+  }
+  if (isAbsolute2(normalized)) {
+    throw new Error(`Project source path ${JSON.stringify(path)} is absolute.`);
+  }
+  if (/^[A-Za-z]:\//u.test(normalized)) {
+    throw new Error(
+      `Project source path ${JSON.stringify(path)} is a Windows absolute path.`
+    );
+  }
+  const parts = normalized.split("/");
+  for (const part of parts) {
+    if (part === "") {
+      throw new Error(
+        `Project source path ${JSON.stringify(path)} contains an empty segment.`
+      );
+    }
+    if (part === ".") {
+      throw new Error(
+        `Project source path ${JSON.stringify(path)} contains a current-directory segment.`
+      );
+    }
+    if (part === "..") {
+      throw new Error(
+        `Project source path ${JSON.stringify(path)} contains a parent-directory segment.`
+      );
+    }
+  }
+  return normalized;
+}
+function createWorkspaceSourcePathResolver(root) {
+  const rootAbsolute = resolve2(root);
+  const rootReal = realpathSync(rootAbsolute);
+  return (path) => {
+    const normalized = normalizeWorkspaceSourcePath(path);
+    const absolute = resolve2(rootAbsolute, normalized);
+    if (!containsPath(rootAbsolute, absolute)) {
+      throw new Error(
+        `Project source path ${JSON.stringify(path)} escapes the workspace.`
+      );
+    }
+    const target = lstatSync(absolute, { throwIfNoEntry: false });
+    if (target?.isSymbolicLink()) {
+      throw new Error(
+        `Project source path ${JSON.stringify(path)} targets a symbolic link.`
+      );
+    }
+    let existing = target === void 0 ? dirname4(absolute) : absolute;
+    while (!existsSync3(existing)) existing = dirname4(existing);
+    if (!containsPath(rootReal, realpathSync(existing))) {
+      throw new Error(
+        `Project source path ${JSON.stringify(path)} traverses outside the workspace.`
+      );
+    }
+    return absolute;
+  };
+}
+function containsPath(parent, candidate) {
+  const fromParent = relative(parent, candidate);
+  return fromParent === "" || !isAbsolute2(fromParent) && fromParent !== ".." && !fromParent.startsWith(`..${sep}`);
+}
+var init_workspace_source_path = __esm({
+  "src/project-source/workspace-source-path.ts"() {
+    "use strict";
+  }
+});
+
 // src/project-source/project-documents.ts
-function emitProjectDocumentFilesV4(records2) {
+function projectRecordFilesV4(...collections) {
+  const files = /* @__PURE__ */ new Map();
+  for (const records2 of collections) {
+    for (const record3 of records2) {
+      if (record3.file === void 0 || record3.file === null) continue;
+      files.set(`${record3.recordKind}:${record3.recordId}`, record3.file);
+    }
+  }
+  return files;
+}
+function authoredDefinitionPathV4(file, recordFiles) {
+  let path = null;
+  for (const key of file.recordKeys) {
+    const candidate = recordFiles.get(key);
+    if (candidate === void 0) continue;
+    const normalizedCandidate = normalizeWorkspaceSourcePath(candidate);
+    if (neoProjectSourceKind(normalizedCandidate) !== "definition") continue;
+    if (path !== null && path !== normalizedCandidate) return null;
+    path = normalizedCandidate;
+  }
+  return path;
+}
+function retainAuthoredDefinitionGroupingV4(files, recordFiles) {
+  const grouped = /* @__PURE__ */ new Map();
+  const paths = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const authoredPath = authoredDefinitionPathV4(file, recordFiles);
+    const path = authoredPath ?? file.path;
+    const folded = invariantCaseKey(path);
+    const prior = grouped.get(folded);
+    paths.set(file.path, path);
+    if (prior === void 0) {
+      grouped.set(folded, {
+        path,
+        content: [file.content],
+        recordKeys: file.recordKeys.slice(),
+        authored: authoredPath !== null
+      });
+      continue;
+    }
+    if (prior.path !== path) {
+      if (prior.authored && authoredPath !== null) {
+        throw new Error(
+          `Authored record placements have a case-insensitive project source path collision between ${JSON.stringify(prior.path)} and ${JSON.stringify(path)}.`
+        );
+      }
+      if (authoredPath !== null) prior.path = path;
+      else if (!prior.authored) {
+        throw new Error(
+          `Canonical emission has a case-insensitive project source path collision between ${JSON.stringify(prior.path)} and ${JSON.stringify(path)}.`
+        );
+      }
+    }
+    prior.content.push(file.content);
+    for (const key of file.recordKeys) prior.recordKeys.push(key);
+    prior.authored ||= authoredPath !== null;
+    paths.set(file.path, prior.path);
+  }
+  for (const [canonicalPath2, targetPath] of paths) {
+    const finalPath = grouped.get(invariantCaseKey(targetPath))?.path;
+    if (finalPath !== void 0) paths.set(canonicalPath2, finalPath);
+  }
+  return {
+    files: grouped.values().map((file) => ({
+      path: file.path,
+      content: file.content.join("\n"),
+      recordKeys: file.recordKeys
+    })).toArray().sort((left, right) => compareCodePoints(left.path, right.path)),
+    paths
+  };
+}
+function emitProjectDocumentFilesV4(records2, options = {}) {
   const schemaRecords = [];
   for (const record3 of records2.values()) {
     if (record3.deleted || !isSchemaRecordKindV4(record3.recordKind)) continue;
@@ -110337,69 +110962,79 @@ function emitProjectDocumentFilesV4(records2) {
     collectionValuePaths: rootValuePathsByValueId(records2.values()),
     variantInitializers: variantValues.initializers
   });
+  const sourceFiles = baseSource.files.map((file) => {
+    const ownedKeys = [];
+    for (const key of file.recordKeys) {
+      if (key.startsWith("variant:")) {
+        for (const ownedKey of variantValues.recordKeysByVariant.get(
+          key.slice(8)
+        ) ?? []) {
+          ownedKeys.push(ownedKey);
+        }
+        continue;
+      }
+      if (!key.startsWith("member:")) continue;
+      const memberId = key.slice(7);
+      for (const ownedKey of staticValues.recordKeysByMember.get(memberId) ?? []) {
+        ownedKeys.push(ownedKey);
+      }
+      for (const ownedKey of memberDefaults.recordKeysByMember.get(memberId) ?? []) {
+        ownedKeys.push(ownedKey);
+      }
+    }
+    return ownedKeys.length === 0 ? file : { ...file, recordKeys: file.recordKeys.concat(ownedKeys) };
+  });
   const source = {
     ...baseSource,
-    files: baseSource.files.map((file) => {
-      const ownedKeys = file.recordKeys.flatMap((key) => {
-        if (key.startsWith("variant:")) {
-          return [
-            ...variantValues.recordKeysByVariant.get(key.slice(8)) ?? []
-          ];
-        }
-        if (!key.startsWith("member:")) return [];
-        const memberId = key.slice(7);
-        return [
-          ...staticValues.recordKeysByMember.get(memberId) ?? [],
-          ...memberDefaults.recordKeysByMember.get(memberId) ?? []
-        ];
-      });
-      return ownedKeys.length === 0 ? file : { ...file, recordKeys: [...file.recordKeys, ...ownedKeys] };
-    })
+    files: sourceFiles
   };
   const classNames = new IdentifierTable();
   for (const schemaClass2 of manifest.classes) {
     classNames.assign(schemaClass2.id, schemaClass2.name);
   }
-  const migrationFiles = [...records2.values()].filter((record3) => !record3.deleted && record3.recordKind === "migration").map((record3) => {
+  const migrationFiles = records2.values().filter((record3) => !record3.deleted && record3.recordKind === "migration").map((record3) => {
     const emitted = emitMigrationFile(record3, classNames);
     return {
       path: emitted.path,
       content: emitted.content,
       recordKeys: emitted.recordKeys
     };
-  });
+  }).toArray();
   const supplementalFiles = emitSupplementalProjectSourcesV4(records2);
-  const materializedConstructors = new Map([
-    ...staticValues.materializedConstructors,
-    ...memberDefaults.materializedConstructors
-  ]);
-  const materializedConstructorOverrideKeys = new Map([
-    ...staticValues.materializedConstructorOverrideKeys,
-    ...memberDefaults.materializedConstructorOverrideKeys
-  ]);
+  const materializedConstructors = new Map(
+    staticValues.materializedConstructors
+  );
+  for (const [key, value] of memberDefaults.materializedConstructors) {
+    materializedConstructors.set(key, value);
+  }
+  const materializedConstructorOverrideKeys = new Map(
+    staticValues.materializedConstructorOverrideKeys
+  );
+  for (const [
+    key,
+    value
+  ] of memberDefaults.materializedConstructorOverrideKeys) {
+    materializedConstructorOverrideKeys.set(key, value);
+  }
   const rootFile = emitProjectRootSourceV4(
     records2,
     manifest,
     materializedConstructors
   );
   const dialogueFiles = emitDialogueProjectSourcesV4(records2);
-  const files = [
-    ...source.files,
-    ...rootFile ? [rootFile] : [],
-    ...supplementalFiles,
-    ...dialogueFiles,
-    ...migrationFiles
-  ].sort((left, right) => compareCodePoints(left.path, right.path));
-  const recordFiles = new Map(source.recordFiles);
-  for (const file of source.files) {
-    for (const key of file.recordKeys) recordFiles.set(key, file.path);
-  }
-  for (const file of [
-    ...rootFile ? [rootFile] : [],
-    ...supplementalFiles,
-    ...dialogueFiles,
-    ...migrationFiles
-  ]) {
+  const grouped = retainAuthoredDefinitionGroupingV4(
+    [
+      source.files,
+      rootFile === null ? [] : [rootFile],
+      supplementalFiles,
+      dialogueFiles,
+      migrationFiles
+    ].values().flatMap((files2) => files2.values()),
+    options.recordFiles ?? /* @__PURE__ */ new Map()
+  );
+  const files = grouped.files;
+  const recordFiles = /* @__PURE__ */ new Map();
+  for (const file of files) {
     for (const key of file.recordKeys) recordFiles.set(key, file.path);
   }
   for (const recovery of staticMemberOwnershipRecoveries) {
@@ -110437,7 +111072,10 @@ ${errors.map(
     analysis,
     materializedConstructors,
     materializedConstructorOverrideKeys,
-    formAlternates: source.formAlternates,
+    formAlternates: source.formAlternates.map((alternate) => ({
+      ...alternate,
+      path: grouped.paths.get(alternate.path) ?? alternate.path
+    })),
     staticMemberOwnershipRecoveries
   };
 }
@@ -110492,6 +111130,7 @@ var init_project_documents = __esm({
     init_source_diagnostics();
     init_source_format();
     init_static_member_ownership_recovery();
+    init_workspace_source_path();
     PROJECT_SOURCE_ANALYSIS_V4_CACHE_PATH = ".neo/project-source-analysis-v4.json";
     SCHEMA_RECORD_KINDS2 = /* @__PURE__ */ new Set([
       "class",
@@ -110513,7 +111152,7 @@ var init_project_documents = __esm({
 // src/project-source/project-document-cache.ts
 import { mkdirSync as mkdirSync5, readFileSync as readFileSync5, renameSync as renameSync3, writeFileSync as writeFileSync5 } from "node:fs";
 import { createHash as createHash6 } from "node:crypto";
-import { dirname as dirname4, join as join5 } from "node:path";
+import { dirname as dirname5, join as join5 } from "node:path";
 function readProjectSourceAnalysisBuildCacheV4(root, sources) {
   try {
     const parsed = JSON.parse(
@@ -110532,12 +111171,12 @@ function readProjectSourceAnalysisBuildCacheV4(root, sources) {
 }
 function writeProjectSourceAnalysisCacheV4(root, analysis, sources) {
   const file = join5(root, PROJECT_SOURCE_ANALYSIS_V4_CACHE_PATH);
-  mkdirSync5(dirname4(file), { recursive: true });
+  mkdirSync5(dirname5(file), { recursive: true });
   writeFileSync5(file, `${JSON.stringify(analysis, null, 2)}
 `, "utf8");
   if (sources === void 0) return;
   const buildFile = join5(root, PROJECT_SOURCE_BUILD_CACHE_PATH);
-  mkdirSync5(dirname4(buildFile), { recursive: true });
+  mkdirSync5(dirname5(buildFile), { recursive: true });
   const temporary = `${buildFile}.${process.pid}.tmp`;
   writeFileSync5(
     temporary,
@@ -110608,7 +111247,7 @@ function readProjectSourceDocumentBuildCacheV1(root, sources) {
 }
 function writeProjectSourceDocumentBuildCacheV1(root, sources, documents) {
   const file = join5(root, PROJECT_SOURCE_DOCUMENT_BUILD_CACHE_PATH);
-  mkdirSync5(dirname4(file), { recursive: true });
+  mkdirSync5(dirname5(file), { recursive: true });
   const temporary = `${file}.${process.pid}.tmp`;
   writeFileSync5(
     temporary,
@@ -110674,7 +111313,7 @@ var init_project_document_cache = __esm({
 // src/project-source/project-files.ts
 import { createHash as createHash7 } from "node:crypto";
 import {
-  existsSync as existsSync3,
+  existsSync as existsSync4,
   mkdirSync as mkdirSync6,
   readFileSync as readFileSync6,
   readdirSync,
@@ -110682,7 +111321,7 @@ import {
   rmSync as rmSync2,
   writeFileSync as writeFileSync6
 } from "node:fs";
-import { basename, dirname as dirname5, extname, join as join6, relative, sep } from "node:path";
+import { basename, dirname as dirname6, extname, join as join6, relative as relative2, sep as sep2 } from "node:path";
 function lowerProjectFileRegistrySourcesV4(root, state, analysis, options = {}) {
   const templateIds = fileTemplateIdsByName2(analysis);
   const declarations = analysis.files.registries.flatMap(
@@ -110717,12 +111356,12 @@ function lowerProjectFileRegistrySourcesV4(root, state, analysis, options = {})
     const trustedPending = options.trustedPendingFiles?.get(
       declaration.recordId
     );
-    if (base === null && !existsSync3(absolute) && trustedPending === void 0) {
+    if (base === null && !existsSync4(absolute) && trustedPending === void 0) {
       throw new Error(
         `Pending project file ${declaration.symbol} is missing bytes at ${normalizedPath}.`
       );
     }
-    const binary = existsSync3(absolute) ? inspectBinaryFile(absolute, normalizedPath) : trustedPending === void 0 ? null : {
+    const binary = existsSync4(absolute) ? inspectBinaryFile(absolute, normalizedPath) : trustedPending === void 0 ? null : {
       path: normalizedPath,
       kind: declaration.kind,
       mimeType: trustedPending.mimeType,
@@ -110824,7 +111463,7 @@ function inspectProjectBinaryStatusV4(root, state, analysis) {
     const baseState = state[`project-file:${declaration.recordId}`];
     const data = isObjectRecord2(baseState?.data) ? baseState.data : {};
     const absolute = join6(root, declaration.path);
-    const local = existsSync3(absolute) ? inspectBinaryFile(absolute, declaration.path) : null;
+    const local = existsSync4(absolute) ? inspectBinaryFile(absolute, declaration.path) : null;
     const baseSha256 = baseState?.projectBinary?.sha256 ?? normalizeSha256V4(
       data.contentSha256,
       `project-file:${declaration.recordId} metadata`
@@ -110896,9 +111535,9 @@ function discoverProjectBinariesV4(root, explicit, ignoredPaths = []) {
   const candidates = [];
   for (const directory of ["Files/Images", "Files/AudioClips"]) {
     const absoluteDirectory = join6(root, directory);
-    if (!existsSync3(absoluteDirectory)) continue;
+    if (!existsSync4(absoluteDirectory)) continue;
     visitBinaryFiles(absoluteDirectory, (absolute) => {
-      const path = normalizeSlash2(relative(root, absolute));
+      const path = normalizeSlash2(relative2(root, absolute));
       if (!explicitPaths.has(path.toLowerCase())) {
         candidates.push({ stableId: path, path, absolute });
       }
@@ -110946,7 +111585,7 @@ function writeVerifiedBinaryDownloadV4(destination, bytes, expectedSha256) {
       `Downloaded project file checksum ${actual} did not match expected SHA-256 ${expectedSha256}.`
     );
   }
-  mkdirSync6(dirname5(destination), { recursive: true });
+  mkdirSync6(dirname6(destination), { recursive: true });
   const temporary = `${destination}.neo-download-${process.pid}`;
   try {
     writeFileSync6(temporary, bytes);
@@ -110965,7 +111604,7 @@ function writeBinaryConflictArtifactV4(root, fileId, fileName2, bytes, expectedS
     safeFileName2(fileName2)
   );
   writeVerifiedBinaryDownloadV4(destination, bytes, expectedSha256);
-  return normalizeSlash2(relative(root, destination));
+  return normalizeSlash2(relative2(root, destination));
 }
 function fileTemplateIdsByName2(analysis) {
   const templateIds = /* @__PURE__ */ new Map();
@@ -111154,7 +111793,7 @@ function safePathSegment2(value) {
   return value.replace(/[^A-Za-z0-9._-]/g, "_") || "file";
 }
 function normalizeSlash2(value) {
-  return value.split(sep).join("/").replaceAll("\\", "/");
+  return value.split(sep2).join("/").replaceAll("\\", "/");
 }
 var SUPPORTED_BINARY_TYPES, REGISTRY_ENTRY2, assignDeterministicFileSymbols2;
 var init_project_files = __esm({
@@ -111197,12 +111836,12 @@ var init_supplemental_records_file_system = __esm({
 });
 
 // src/project-source/workspace-status.ts
-import { existsSync as existsSync4, readFileSync as readFileSync7, readdirSync as readdirSync2 } from "node:fs";
-import { join as join7, relative as relative2, sep as sep2 } from "node:path";
+import { existsSync as existsSync5, readFileSync as readFileSync7, readdirSync as readdirSync2 } from "node:fs";
+import { join as join7, relative as relative3, sep as sep3 } from "node:path";
 function isGitIgnored(scopes, absolutePath, directory) {
   return isNeoGitIgnored(
     scopes.map((scope) => ({
-      relativePath: relative2(scope.root, absolutePath),
+      relativePath: relative3(scope.root, absolutePath),
       matcher: scope.matcher
     })),
     directory
@@ -111210,7 +111849,7 @@ function isGitIgnored(scopes, absolutePath, directory) {
 }
 function addGitIgnoreScope(directory, inherited) {
   const path = join7(directory, ".gitignore");
-  if (!existsSync4(path)) return inherited;
+  if (!existsSync5(path)) return inherited;
   return [
     ...inherited,
     { root: directory, matcher: (0, import_ignore.default)().add(readFileSync7(path, "utf8")) }
@@ -111220,7 +111859,7 @@ function listNeoWorkspaceFilesV1(root) {
   const production = [];
   const specs = [];
   const visit = (directory, inheritedScopes) => {
-    if (!existsSync4(directory)) return;
+    if (!existsSync5(directory)) return;
     const scopes = addGitIgnoreScope(directory, inheritedScopes);
     for (const entry of readdirSync2(directory, { withFileTypes: true })) {
       if (entry.isSymbolicLink()) continue;
@@ -111232,7 +111871,7 @@ function listNeoWorkspaceFilesV1(root) {
         continue;
       }
       if (!entry.isFile() || isGitIgnored(scopes, path, false)) continue;
-      const relativePath = relative2(root, path).split(sep2).join("/");
+      const relativePath = relative3(root, path).split(sep3).join("/");
       const kind = neoProjectSourceKind(relativePath);
       if (kind === null) continue;
       if (kind === "spec") specs.push(path);
@@ -111252,7 +111891,7 @@ function listProjectTestFilesV1(root) {
 }
 function computeWorkspaceStatus2(workspace, options = {}) {
   const virtualSourceFiles = options.virtualSourceFiles ?? listProjectSourceFilesV4(workspace.root).map((path) => ({
-    path: relative2(workspace.root, path).split(sep2).join("/"),
+    path: relative3(workspace.root, path).split(sep3).join("/"),
     content: readFileSync7(path, "utf8")
   }));
   return computeWorkspaceStatus(workspace, {
@@ -112264,7 +112903,7 @@ var init_source_record_comparison = __esm({
 
 // src/project-source/reset.ts
 import {
-  existsSync as existsSync5,
+  existsSync as existsSync6,
   mkdirSync as mkdirSync7,
   readFileSync as readFileSync8,
   readdirSync as readdirSync3,
@@ -112272,12 +112911,20 @@ import {
   writeFileSync as writeFileSync7,
   statSync
 } from "node:fs";
-import { dirname as dirname6, join as join8 } from "node:path";
+import { dirname as dirname7, join as join8 } from "node:path";
 function resetWorkspaceToProjectSourcesV4(workspace, document, options = {}) {
   const emissionRecords = options.regenerateSourceNames ? regenerateDialogueSourceNamesV4(document.records) : document.records;
-  const emitted = emitProjectDocumentFilesV4(emissionRecords);
+  const emitted = emitProjectDocumentFilesV4(emissionRecords, {
+    recordFiles: projectRecordFilesV4(Object.values(workspace.state.records))
+  });
   assertUniqueEmittedPaths2(emitted.files);
-  const previous = managedFilesBeforeReset(workspace.root);
+  const resolveSourcePath = createWorkspaceSourcePathResolver(workspace.root);
+  const trackedSources = trackedProductionSourcesBeforeReset(
+    workspace,
+    resolveSourcePath
+  );
+  const previous = new Set(managedFilesBeforeReset(workspace.root));
+  for (const path of trackedSources) previous.add(path);
   const preservedSpecs = preserveManagedSpecs(workspace.root);
   for (const directory of FORMAT_4_MANAGED_DIRECTORIES) {
     rmSync3(join8(workspace.root, directory), { recursive: true, force: true });
@@ -112289,15 +112936,18 @@ function resetWorkspaceToProjectSourcesV4(workspace, document, options = {}) {
   for (const privatePath of LEGACY_PRIVATE_PATHS) {
     rmSync3(join8(workspace.root, privatePath), { recursive: true, force: true });
   }
+  for (const path of trackedSources) {
+    rmSync3(resolveSourcePath(path), { force: true });
+  }
   for (const [path, bytes] of preservedSpecs) {
     const absolute = join8(workspace.root, path);
-    mkdirSync7(dirname6(absolute), { recursive: true });
+    mkdirSync7(dirname7(absolute), { recursive: true });
     writeFileSync7(absolute, bytes);
   }
   for (const file of emitted.files) {
-    const absolute = join8(workspace.root, file.path);
-    mkdirSync7(dirname6(absolute), { recursive: true });
-    if (existsSync5(absolute) && readFileSync8(absolute, "utf8") === file.content) {
+    const absolute = resolveSourcePath(file.path);
+    mkdirSync7(dirname7(absolute), { recursive: true });
+    if (existsSync6(absolute) && readFileSync8(absolute, "utf8") === file.content) {
       continue;
     }
     writeFileSync7(absolute, file.content, "utf8");
@@ -112324,7 +112974,7 @@ function resetWorkspaceToProjectSourcesV4(workspace, document, options = {}) {
   workspace.config = { ...workspace.config, formatVersion: 4 };
   writeWorkspaceConfig(workspace.root, workspace.config);
   const removed = [...previous].filter(
-    (file) => !existsSync5(join8(workspace.root, file))
+    (file) => !existsSync6(join8(workspace.root, file))
   ).length;
   return {
     written: emitted.files.length,
@@ -112337,7 +112987,7 @@ function preserveManagedSpecs(root) {
   const specs = /* @__PURE__ */ new Map();
   const visit = (path) => {
     const absolute = join8(root, path);
-    if (!existsSync5(absolute)) return;
+    if (!existsSync6(absolute)) return;
     const entries = readdirSync3(absolute, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isSymbolicLink()) continue;
@@ -112352,6 +113002,20 @@ function preserveManagedSpecs(root) {
   for (const directory of FORMAT_4_MANAGED_DIRECTORIES) visit(directory);
   return specs;
 }
+function trackedProductionSourcesBeforeReset(workspace, resolveSourcePath) {
+  const paths = /* @__PURE__ */ new Set();
+  for (const record3 of Object.values(workspace.state.records)) {
+    if (record3.file === void 0) continue;
+    const path = normalizeWorkspaceSourcePath(record3.file);
+    const kind = neoProjectSourceKind(path);
+    if (kind === null || !isNeoProjectProductionSourceKind(kind)) {
+      continue;
+    }
+    const absolute = resolveSourcePath(path);
+    if (existsSync6(absolute)) paths.add(path);
+  }
+  return paths;
+}
 function assertUniqueEmittedPaths2(files) {
   const seen = /* @__PURE__ */ new Map();
   for (const file of files) {
@@ -112371,7 +113035,7 @@ function managedFilesBeforeReset(root) {
     collectFiles(root, directory, files);
   }
   for (const file of LEGACY_ROOT_FILES) {
-    if (existsSync5(join8(root, file))) files.add(file);
+    if (existsSync6(join8(root, file))) files.add(file);
   }
   for (const privatePath of LEGACY_PRIVATE_PATHS) {
     collectFiles(root, privatePath, files);
@@ -112380,7 +113044,7 @@ function managedFilesBeforeReset(root) {
 }
 function collectFiles(root, path, files) {
   const absolute = join8(root, path);
-  if (!existsSync5(absolute)) return;
+  if (!existsSync6(absolute)) return;
   if (statSync(absolute).isFile()) {
     files.add(path);
     return;
@@ -112399,11 +113063,13 @@ var FORMAT_4_MANAGED_DIRECTORIES, LEGACY_ROOT_FILES, LEGACY_PRIVATE_PATHS;
 var init_reset = __esm({
   "src/project-source/reset.ts"() {
     "use strict";
+    init_src();
     init_workspace();
     init_project_documents();
     init_project_document_cache();
     init_materialized_construction_cache();
     init_dialogue_sources();
+    init_workspace_source_path();
     FORMAT_4_MANAGED_DIRECTORIES = [
       "Classes",
       "Interfaces",
@@ -112544,7 +113210,7 @@ var init_http = __esm({
 });
 
 // src/project-source/project-file-pull.ts
-import { existsSync as existsSync6, rmSync as rmSync4 } from "node:fs";
+import { existsSync as existsSync7, rmSync as rmSync4 } from "node:fs";
 import { join as join9 } from "node:path";
 async function pullProjectBinariesV4(args) {
   let client = args.client ?? null;
@@ -112568,7 +113234,7 @@ async function pullProjectBinariesV4(args) {
     const declarationPresent = args.destructive === true || args.localBinaries === void 0 || previous === void 0 || localStatus !== void 0;
     const path = localStatus?.path ?? previous?.projectBinary?.path ?? canonicalProjectBinaryPathV42(record3.data);
     const absolute = join9(args.workspace.root, path);
-    const localDigest = existsSync6(absolute) ? sha256File(absolute) : null;
+    const localDigest = existsSync7(absolute) ? sha256File(absolute) : null;
     const baseDigest = previous?.projectBinary?.sha256 ?? readSha256(previous?.data) ?? null;
     const remoteDigest = requiredSha256(
       record3.data,
@@ -112651,7 +113317,7 @@ async function pullProjectBinariesV4(args) {
     const localStatus = localById.get(previous.recordId);
     const path = localStatus?.path ?? previous.projectBinary?.path ?? canonicalProjectBinaryPathV42(previous.data);
     const absolute = join9(args.workspace.root, path);
-    const localDigest = existsSync6(absolute) ? sha256File(absolute) : null;
+    const localDigest = existsSync7(absolute) ? sha256File(absolute) : null;
     const baseDigest = previous.projectBinary?.sha256 ?? readSha256(previous.data) ?? null;
     const action = planBinaryMergeV4({
       baseDigest,
@@ -112836,10 +113502,10 @@ import {
   mkdirSync as mkdirSync8,
   writeFileSync as writeFileSync8,
   rmSync as rmSync5,
-  existsSync as existsSync7,
+  existsSync as existsSync8,
   readFileSync as readFileSync9
 } from "node:fs";
-import { dirname as dirname7, join as join10 } from "node:path";
+import { dirname as dirname8 } from "node:path";
 async function runPull(workspace, options) {
   if (options.reset) {
     await runResetPull(workspace);
@@ -112942,7 +113608,8 @@ ${blockingErrors.map((error) => `  ${error.message}`).join("\n")}`
     if (serverRecord.deleted) continue;
     const baseState = workspace.state.records[key];
     const local = localByKey.get(key);
-    if (destructive || baseState === void 0) {
+    const acceptedServerDeletionRecreated = baseState?.conflictServerHash === null && local === void 0;
+    if (destructive || baseState === void 0 || acceptedServerDeletionRecreated) {
       plans.set(key, {
         emitData: serverRecord.data,
         serverHash: serverRecord.contentHash,
@@ -113161,12 +113828,19 @@ async function finishFormat4Pull(args) {
       ([key, record3]) => localRecords.get(key) === record3 ? [] : [key]
     )
   );
-  const localResult = emitProjectDocumentFilesV4(localRecords);
+  const recordFiles = projectRecordFilesV4(
+    Object.values(workspace.state.records),
+    localStatus?.reconstructed.values() ?? []
+  );
+  const localResult = emitProjectDocumentFilesV4(localRecords, {
+    recordFiles
+  });
   for (const recovery of localResult.staticMemberOwnershipRecoveries ?? []) {
     warn(staticMemberOwnershipRecoveryMessage(recovery));
   }
   const serverResult = conflictCount === 0 ? null : emitProjectDocumentFilesV4(
-    buildEmitRecordSet(document, plans, "server")
+    buildEmitRecordSet(document, plans, "server"),
+    { recordFiles }
   );
   const binaries = await pullProjectBinariesV4({
     workspace,
@@ -113182,13 +113856,23 @@ async function finishFormat4Pull(args) {
     (serverResult?.files ?? []).map((file) => [file.path, file])
   );
   const conflictPaths = /* @__PURE__ */ new Set();
+  const authoredLocalConflictKeysByPath = /* @__PURE__ */ new Map();
   for (const key of conflictKeys) {
-    const path = localResult.recordFiles.get(key) ?? serverResult?.recordFiles.get(key);
+    const localPath = localResult.recordFiles.get(key);
+    const serverPath = serverResult?.recordFiles.get(key);
+    const path = localPath ?? serverPath ?? workspace.state.records[key]?.file;
     if (path) conflictPaths.add(path);
+    if (path === void 0 || localPath !== void 0 || serverPath !== void 0) {
+      continue;
+    }
+    const keys = authoredLocalConflictKeysByPath.get(path) ?? [];
+    keys.push(key);
+    authoredLocalConflictKeysByPath.set(path, keys);
   }
   const emittedPaths = /* @__PURE__ */ new Set([
     ...localByPath.keys(),
-    ...[...conflictPaths].filter((path) => serverByPath.has(path))
+    ...[...conflictPaths].filter((path) => serverByPath.has(path)),
+    ...authoredLocalConflictKeysByPath.keys()
   ]);
   const rewritePaths = projectSourcePathsRequiringRewriteV4({
     destructive,
@@ -113205,9 +113889,20 @@ async function finishFormat4Pull(args) {
     const path = localResult.recordFiles.get(key);
     if (path !== void 0) rewritePaths.add(path);
   }
+  const resolveSourcePath = createWorkspaceSourcePathResolver(workspace.root);
   let written = 0;
   for (const path of emittedPaths) {
-    const local = localByPath.get(path)?.content;
+    const absolute = resolveSourcePath(path);
+    const existing = existsSync8(absolute) ? readFileSync9(absolute, "utf8") : null;
+    const unprojectedConflictKeys = authoredLocalConflictKeysByPath.get(path) ?? [];
+    if (unprojectedConflictKeys.length > 0 && existing === null) {
+      throw new Error(
+        `Cannot preserve deleted-server conflict ${unprojectedConflictKeys.join(
+          ", "
+        )}: its prior source file ${JSON.stringify(path)} no longer exists.`
+      );
+    }
+    const local = unprojectedConflictKeys.length > 0 ? existing ?? void 0 : localByPath.get(path)?.content;
     const server = serverByPath.get(path)?.content;
     const content = conflictPaths.has(path) ? renderConflictFileV4({
       localContent: local,
@@ -113215,9 +113910,7 @@ async function finishFormat4Pull(args) {
       versionId: workspace.config.versionId
     }) : local;
     if (content === void 0) continue;
-    const absolute = join10(workspace.root, path);
-    mkdirSync8(dirname7(absolute), { recursive: true });
-    const existing = existsSync7(absolute) ? readFileSync9(absolute, "utf8") : null;
+    mkdirSync8(dirname8(absolute), { recursive: true });
     if (existing !== null && !rewritePaths.has(path)) continue;
     if (existing !== content) {
       writeFileSync8(absolute, content, "utf8");
@@ -113227,14 +113920,19 @@ async function finishFormat4Pull(args) {
   let removed = 0;
   for (const recordState of Object.values(workspace.state.records)) {
     const previousPath = recordState.file;
-    if (previousPath === void 0 || emittedPaths.has(previousPath)) continue;
-    const absolute = join10(workspace.root, previousPath);
-    if (existsSync7(absolute)) {
+    if (previousPath === void 0) continue;
+    const normalizedPreviousPath = normalizeWorkspaceSourcePath(previousPath);
+    if (emittedPaths.has(normalizedPreviousPath)) {
+      continue;
+    }
+    const absolute = resolveSourcePath(previousPath);
+    if (existsSync8(absolute)) {
       rmSync5(absolute);
       removed += 1;
     }
   }
   const records2 = {};
+  const previousRecords = workspace.state.records;
   for (const [key, plan] of plans) {
     const baseState = workspace.state.records[key];
     const serverRecord = document.records.get(key);
@@ -113277,6 +113975,10 @@ async function finishFormat4Pull(args) {
     const record3 = records2[key];
     if (record3) record3.projectBinary = state;
   }
+  const staleConflictTears = conflictCount === 0 ? [] : findNewlyUnanchoredConflictValues({
+    previousRecords,
+    records: records2
+  });
   workspace.state.records = records2;
   if (nextCursor !== null) {
     workspace.state.documentRevisionCursor = mutableCursor(nextCursor);
@@ -113328,6 +114030,12 @@ async function finishFormat4Pull(args) {
       'Conflict markers were written into the affected files. Edit them to the desired final state and push \u2014 the push is the resolution. To keep one side everywhere, use "neo resolve --mine" or "neo resolve --theirs".'
     );
     for (const key of conflictKeys) console.log(`  ${sym.fail} ${key}`);
+    for (const tear of staleConflictTears) {
+      const rowLabel = tear.unanchoredValueCount === 1 ? "row" : "rows";
+      warn(
+        `Conflict ${tear.recordKind} "${tear.recordId}" retained a local base that does not anchor ${tear.unanchoredValueCount} newly pulled descendant value ${rowLabel}. Resolve it with "neo resolve --mine" or "neo resolve --theirs" before pushing.`
+      );
+    }
   }
   if (binaries.conflicted > 0) {
     warn(
@@ -113336,6 +114044,65 @@ async function finishFormat4Pull(args) {
     for (const path of binaries.conflicts) console.log(`  ${sym.fail} ${path}`);
   }
 }
+function findNewlyUnanchoredConflictValues(args) {
+  const newlyLandedValueIds = /* @__PURE__ */ new Set();
+  for (const [key, record3] of Object.entries(args.records)) {
+    if (args.previousRecords[key] !== void 0) continue;
+    if (record3.recordKind !== "value") continue;
+    if (record3.file === void 0) continue;
+    if (record3.conflictServerHash !== void 0) continue;
+    newlyLandedValueIds.add(record3.recordId);
+  }
+  if (newlyLandedValueIds.size === 0) return [];
+  const unanchored = new Set(
+    unanchoredValueDeleteIds({
+      records: args.records,
+      deletedValueIds: newlyLandedValueIds
+    })
+  );
+  if (unanchored.size === 0) return [];
+  const tears = [];
+  for (const conflict2 of Object.values(args.records)) {
+    if (typeof conflict2.conflictServerHash !== "string") continue;
+    if (conflict2.file === void 0) continue;
+    const serverAnchored = /* @__PURE__ */ new Set();
+    collectNamedCandidateValues(
+      conflict2.conflictServerData,
+      newlyLandedValueIds,
+      serverAnchored
+    );
+    let unanchoredValueCount = 0;
+    for (const valueId of serverAnchored) {
+      if (!unanchored.has(valueId)) continue;
+      const value = args.records[`value:${valueId}`];
+      if (value?.file !== conflict2.file) continue;
+      unanchoredValueCount += 1;
+    }
+    if (unanchoredValueCount === 0) continue;
+    tears.push({
+      recordKind: conflict2.recordKind,
+      recordId: conflict2.recordId,
+      unanchoredValueCount
+    });
+  }
+  return tears;
+}
+function collectNamedCandidateValues(value, candidates, found) {
+  if (typeof value === "string") {
+    if (candidates.has(value)) found.add(value);
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const element of value) {
+      collectNamedCandidateValues(element, candidates, found);
+    }
+    return;
+  }
+  if (!isObjectRecord2(value)) return;
+  for (const nested of Object.values(value)) {
+    collectNamedCandidateValues(nested, candidates, found);
+  }
+}
 function deltaRequiresSourceProjectionV4(args) {
   const mainLocale = workspaceMainLocale(args.workspace.state.records);
   for (const key of args.changedRecordKeys) {
@@ -113521,12 +114288,14 @@ var init_pull = __esm({
     init_project_documents();
     init_project_document_cache();
     init_materialized_construction_cache();
+    init_workspace_source_path();
     init_project_manifest();
     init_project_documents();
     init_project_file_pull();
     init_dialogue_sources();
     init_static_value_seed_records();
     init_static_member_ownership_recovery();
+    init_value_base_desync();
   }
 });
 
@@ -113535,8 +114304,8 @@ var init_exports = {};
 __export(init_exports, {
   runInit: () => runInit
 });
-import { existsSync as existsSync8, mkdirSync as mkdirSync9, readFileSync as readFileSync10, writeFileSync as writeFileSync9 } from "node:fs";
-import { join as join11, resolve as resolve2 } from "node:path";
+import { existsSync as existsSync9, mkdirSync as mkdirSync9, readFileSync as readFileSync10, writeFileSync as writeFileSync9 } from "node:fs";
+import { join as join10, resolve as resolve3 } from "node:path";
 async function runInit(options) {
   let projectId = options.projectId;
   let projects = [];
@@ -113632,9 +114401,9 @@ async function runInit(options) {
       validate: (value) => value.trim().length > 0 ? true : "Directory must not be empty."
     }) : "neo";
   }
-  const root = resolve2(directory);
-  if (existsSync8(join11(root, NEO_CONFIG_FILE))) {
-    throw new Error(`"${join11(root, NEO_CONFIG_FILE)}" already exists.`);
+  const root = resolve3(directory);
+  if (existsSync9(join10(root, NEO_CONFIG_FILE))) {
+    throw new Error(`"${join10(root, NEO_CONFIG_FILE)}" already exists.`);
   }
   mkdirSync9(root, { recursive: true });
   ensurePrivateStateIgnored(root);
@@ -113659,8 +114428,8 @@ async function runInit(options) {
   });
 }
 function ensurePrivateStateIgnored(root) {
-  const path = join11(root, ".gitignore");
-  const existing = existsSync8(path) ? readFileSync10(path, "utf8") : "";
+  const path = join10(root, ".gitignore");
+  const existing = existsSync9(path) ? readFileSync10(path, "utf8") : "";
   if (existing.split(/\r?\n/u).some((line) => line.trim() === ".neo/" || line.trim() === ".neo")) {
     return;
   }
@@ -114066,7 +114835,7 @@ async function waitForPlan(convex, planId) {
         `History plan "${plan.id}" failed: ${plan.error ?? "unknown error"}`
       );
     }
-    await new Promise((resolve4) => setTimeout(resolve4, 500));
+    await new Promise((resolve5) => setTimeout(resolve5, 500));
   }
 }
 async function printVersionLog(convex, scope) {
@@ -115065,8 +115834,8 @@ var init_save_overlay_resolution = __esm({
 });
 
 // src/commands/push-body-diagnostics.ts
-import { existsSync as existsSync9, readFileSync as readFileSync11 } from "node:fs";
-import { join as join12 } from "node:path";
+import { existsSync as existsSync10, readFileSync as readFileSync11 } from "node:fs";
+import { join as join11 } from "node:path";
 function createNeoScriptBodySourceLocator(workspace, status) {
   const textByFile = /* @__PURE__ */ new Map();
   return {
@@ -115088,8 +115857,8 @@ function createNeoScriptBodySourceLocator(workspace, status) {
     textOf(file) {
       const cached = textByFile.get(file);
       if (cached !== void 0) return cached;
-      const path = join12(workspace.root, file);
-      const text = existsSync9(path) ? readFileSync11(path, "utf8") : null;
+      const path = join11(workspace.root, file);
+      const text = existsSync10(path) ? readFileSync11(path, "utf8") : null;
       textByFile.set(file, text);
       return text;
     }
@@ -116891,29 +117660,29 @@ var init_project_source_identity = __esm({
 // src/push-hook.ts
 import { spawn } from "node:child_process";
 import { createHash as createHash9 } from "node:crypto";
-import { existsSync as existsSync10, readFileSync as readFileSync13, readdirSync as readdirSync4 } from "node:fs";
-import { join as join13, relative as relative3, sep as sep3 } from "node:path";
+import { existsSync as existsSync11, readFileSync as readFileSync13, readdirSync as readdirSync4 } from "node:fs";
+import { join as join12, relative as relative4, sep as sep4 } from "node:path";
 function fingerprintPushInputs(workspace, options = {}) {
   const paths = /* @__PURE__ */ new Set([
-    join13(workspace.root, "neo.json"),
+    join12(workspace.root, "neo.json"),
     ...listProjectSourceFilesV4(workspace.root),
     ...options.includeTests === false ? [] : listProjectTestFilesV1(workspace.root),
-    ...workspace.config.unityConfigPath === void 0 ? [] : [join13(workspace.root, workspace.config.unityConfigPath)]
+    ...workspace.config.unityConfigPath === void 0 ? [] : [join12(workspace.root, workspace.config.unityConfigPath)]
   ]);
   const visitManaged = (directory) => {
-    if (!existsSync10(directory)) return;
+    if (!existsSync11(directory)) return;
     for (const entry of readdirSync4(directory, { withFileTypes: true })) {
       if (entry.isSymbolicLink()) continue;
-      const path = join13(directory, entry.name);
+      const path = join12(directory, entry.name);
       if (entry.isDirectory()) visitManaged(path);
       else if (entry.isFile()) paths.add(path);
     }
   };
-  visitManaged(join13(workspace.root, "Files", "Images"));
-  visitManaged(join13(workspace.root, "Files", "AudioClips"));
+  visitManaged(join12(workspace.root, "Files", "Images"));
+  visitManaged(join12(workspace.root, "Files", "AudioClips"));
   const hash = createHash9("sha256");
   for (const path of [...paths].sort()) {
-    const name = relative3(workspace.root, path).split(sep3).join("/");
+    const name = relative4(workspace.root, path).split(sep4).join("/");
     hash.update(name);
     hash.update("\0");
     try {
@@ -117055,7 +117824,7 @@ var init_push_hook = __esm({
 });
 
 // src/project-source/project-file-push.ts
-import { basename as basename2, join as join14 } from "node:path";
+import { basename as basename2, join as join13 } from "node:path";
 import { readFileSync as readFileSync14 } from "node:fs";
 function ensureProjectFileBinaryChangesV4(args) {
   for (const binary of args.binaryChanges) {
@@ -117101,7 +117870,7 @@ function prepareProjectFilePushesV4(args) {
         `Project file ${recordId} has upload bytes but its source change has no record data.`
       );
     }
-    const absolute = join14(args.workspace.root, binary.path);
+    const absolute = join13(args.workspace.root, binary.path);
     const bytes = new Uint8Array(readFileSync14(absolute));
     const digest = sha256Bytes(bytes);
     if (binary.localSha256 !== null && digest !== binary.localSha256) {
@@ -117340,7 +118109,7 @@ function isRetryableRequestError(error) {
   return RETRYABLE_NETWORK_ERROR_CODES.has(error.cause.code);
 }
 async function waitForRetry(attempt, signal) {
-  await new Promise((resolve4, reject) => {
+  await new Promise((resolve5, reject) => {
     const abort = () => {
       clearTimeout(timeout);
       reject(signal.reason);
@@ -117348,7 +118117,7 @@ async function waitForRetry(attempt, signal) {
     const timeout = setTimeout(
       () => {
         signal.removeEventListener("abort", abort);
-        resolve4();
+        resolve5();
       },
       200 * 2 ** (attempt - 1)
     );
@@ -117581,11 +118350,11 @@ import {
   mkdirSync as mkdirSync10,
   writeFileSync as writeFileSync10,
   rmSync as rmSync6,
-  existsSync as existsSync11,
+  existsSync as existsSync12,
   readFileSync as readFileSync15,
   statSync as statSync2
 } from "node:fs";
-import { dirname as dirname8, join as join15, relative as relative4, sep as sep4 } from "node:path";
+import { dirname as dirname9, join as join14, relative as relative5, sep as sep5 } from "node:path";
 function assignPendingIds(changes, authoredValueSeeds, reconstructed3, localInitializerMaterialization) {
   const assigned = /* @__PURE__ */ new Map();
   const assign = (pendingId2) => {
@@ -118126,14 +118895,14 @@ async function waitForPollDelay(delayMs, signal) {
   if (signal.aborted) {
     throw new Error("Project transaction polling was interrupted.");
   }
-  await new Promise((resolve4, reject) => {
+  await new Promise((resolve5, reject) => {
     const aborted = () => {
       clearTimeout(timer);
       reject(new Error("Project transaction polling was interrupted."));
     };
     const timer = setTimeout(() => {
       signal.removeEventListener("abort", aborted);
-      resolve4();
+      resolve5();
     }, delayMs);
     signal.addEventListener("abort", aborted, { once: true });
   });
@@ -118362,7 +119131,7 @@ async function runPush(workspace, options, preparationOverride) {
     );
   }
   if (options.noVerify !== true) {
-    const preparedBuildDir = configuredHook === void 0 ? void 0 : join15(
+    const preparedBuildDir = configuredHook === void 0 ? void 0 : join14(
       workspace.root,
       ".neo",
       "test-build",
@@ -118379,7 +119148,7 @@ async function runPush(workspace, options, preparationOverride) {
       const documentJson = JSON.stringify(candidate.document);
       mkdirSync10(preparedBuildDir, { recursive: true });
       writeFileSync10(
-        join15(preparedBuildDir, "candidate.json"),
+        join14(preparedBuildDir, "candidate.json"),
         `${JSON.stringify({
           version: 1,
           projectFingerprint: `sha256:${preparedLocal.source.sourceHash}`,
@@ -118885,7 +119654,7 @@ async function prepareLocalCandidateV4(workspace, options = {}) {
   } else {
     const files = listProjectSourceFilesV4(workspace.root).map(
       (absolutePath) => {
-        const path = relative4(workspace.root, absolutePath).split(sep4).join("/");
+        const path = relative5(workspace.root, absolutePath).split(sep5).join("/");
         const kind = neoProjectSourceKind(path);
         if (kind === null || !isNeoProjectProductionSourceKind(kind)) {
           throw new Error(
@@ -119204,7 +119973,12 @@ function createPendingProjectSourceIdentityV4(workspace, status, authoredValueSe
       });
     }
   }
-  const emission = emitProjectDocumentFilesV4(records2);
+  const emission = emitProjectDocumentFilesV4(records2, {
+    recordFiles: projectRecordFilesV4(
+      Object.values(workspace.state.records),
+      status.reconstructed.values()
+    )
+  });
   const files = emission.files.map((file) => {
     const kind = neoProjectSourceKind(file.path);
     if (kind === null || !isNeoProjectProductionSourceKind(kind)) {
@@ -119410,7 +120184,12 @@ ${blockingErrors.map((error) => `  ${error.message}`).join("\n")}`
   const previousState = workspace.state;
   workspace.state = { ...previousState, records: nextRecords };
   try {
-    rewriteFilesFromState(workspace, emitRecords, preservedSourceFiles);
+    rewriteFilesFromState(
+      workspace,
+      emitRecords,
+      preservedSourceFiles,
+      projectRecordFilesV4(localRecords.values())
+    );
     writeWorkspaceState(workspace.root, workspace.state);
   } catch (error) {
     workspace.state = previousState;
@@ -119596,16 +120375,30 @@ function applyPushResult(workspace, result, pendingIdAssignments = /* @__PURE__
   if (!isObjectRecord2(result) || !Array.isArray(result.changedRecords)) {
     throw new Error("Transaction response is missing changedRecords.");
   }
+  const localStatus = computeWorkspaceStatus2(workspace);
   const preservedSourceFiles = materializeAssignedSchemaIdsInAuthoredSource(
     workspace,
     pendingIdAssignments,
-    computeWorkspaceStatus2(workspace).pendingValueIdentitySites
+    localStatus.pendingValueIdentitySites
+  );
+  const replacements = {
+    exact: pendingIdAssignments,
+    embedded: pendingIdAssignments.entries().toArray().sort(([left], [right]) => right.length - left.length)
+  };
+  const localRecords = rewriteReconstructedRecords(
+    localStatus.reconstructed,
+    replacements
   );
   workspace.state.records = foldChangedRecords(
     workspace.state.records,
     result.changedRecords
   );
-  rewriteFilesFromState(workspace, void 0, preservedSourceFiles);
+  rewriteFilesFromState(
+    workspace,
+    void 0,
+    preservedSourceFiles,
+    projectRecordFilesV4(localRecords.values())
+  );
   writeWorkspaceState(workspace.root, workspace.state);
 }
 function authoredMemberFormsByFile(root, alternates) {
@@ -119614,8 +120407,8 @@ function authoredMemberFormsByFile(root, alternates) {
   for (const alternate of alternates) {
     let existing = contents.get(alternate.path);
     if (existing === void 0) {
-      const absolute = join15(root, alternate.path);
-      existing = existsSync11(absolute) ? readFileSync15(absolute, "utf8") : null;
+      const absolute = join14(root, alternate.path);
+      existing = existsSync12(absolute) ? readFileSync15(absolute, "utf8") : null;
       contents.set(alternate.path, existing);
     }
     if (existing === null || !existing.includes(alternate.block)) continue;
@@ -119653,14 +120446,14 @@ function fileSystemEntryKey(absolute) {
   if (!hasInode) return `path:${absolute.toLowerCase()}`;
   return `inode:${stats.dev}:${stats.ino}`;
 }
-function deleteSupersededAuthoredFiles(root, authoredPaths, emitted) {
+function deleteSupersededAuthoredFiles(resolveSourcePath, authoredPaths, emitted) {
   const emittedEntries = /* @__PURE__ */ new Set();
   for (const file of emitted) {
-    emittedEntries.add(fileSystemEntryKey(join15(root, file.path)));
+    emittedEntries.add(fileSystemEntryKey(resolveSourcePath(file.path)));
   }
   for (const authoredPath of authoredPaths) {
-    const absolute = join15(root, authoredPath);
-    if (!existsSync11(absolute)) continue;
+    const absolute = resolveSourcePath(authoredPath);
+    if (!existsSync12(absolute)) continue;
     if (emittedEntries.has(fileSystemEntryKey(absolute))) continue;
     rmSync6(absolute);
   }
@@ -119676,8 +120469,8 @@ function rewriteFilesFromState(workspace, records2 = new Map(
       data: recordState.data
     }
   ])
-), preservedSourceFiles = /* @__PURE__ */ new Map()) {
-  const result = emitProjectDocumentFilesV4(records2);
+), preservedSourceFiles = /* @__PURE__ */ new Map(), recordFiles = /* @__PURE__ */ new Map()) {
+  const result = emitProjectDocumentFilesV4(records2, { recordFiles });
   const authoredForms = authoredMemberFormsByFile(
     workspace.root,
     result.formAlternates
@@ -119708,22 +120501,27 @@ function rewriteFilesFromState(workspace, records2 = new Map(
   );
   assertAssignedIdSourceRewriteValid(finalAnalysis);
   writeProjectSourceAnalysisCacheV4(workspace.root, finalAnalysis);
+  const resolveSourcePath = createWorkspaceSourcePathResolver(workspace.root);
   const emittedPaths = new Set(files.map((file) => file.path));
   for (const recordState of Object.values(workspace.state.records)) {
     const previousPath = recordState.file;
-    if (previousPath === void 0 || emittedPaths.has(previousPath)) continue;
-    const absolute = join15(workspace.root, previousPath);
-    if (existsSync11(absolute)) rmSync6(absolute);
+    if (previousPath === void 0) continue;
+    const normalizedPreviousPath = normalizeWorkspaceSourcePath(previousPath);
+    if (emittedPaths.has(normalizedPreviousPath)) {
+      continue;
+    }
+    const absolute = resolveSourcePath(previousPath);
+    if (existsSync12(absolute)) rmSync6(absolute);
   }
   for (const file of files) {
-    const absolute = join15(workspace.root, file.path);
-    mkdirSync10(dirname8(absolute), { recursive: true });
-    const existing = existsSync11(absolute) ? readFileSync15(absolute, "utf8") : null;
+    const absolute = resolveSourcePath(file.path);
+    mkdirSync10(dirname9(absolute), { recursive: true });
+    const existing = existsSync12(absolute) ? readFileSync15(absolute, "utf8") : null;
     if (existing !== file.content)
       writeFileSync10(absolute, file.content, "utf8");
   }
   deleteSupersededAuthoredFiles(
-    workspace.root,
+    resolveSourcePath,
     preservedSourceFiles.keys(),
     files
   );
@@ -119763,7 +120561,7 @@ function materializeAssignedSchemaIdsInAuthoredSource(workspace, replacements, p
   if (pendingIdsByUri.size === 0) return /* @__PURE__ */ new Map();
   const inputs = listProjectSourceFilesV4(workspace.root).map(
     (absolutePath) => {
-      const uri = relative4(workspace.root, absolutePath).split(sep4).join("/");
+      const uri = relative5(workspace.root, absolutePath).split(sep5).join("/");
       const kind = neoProjectSourceKind(uri);
       if (kind === null || !isNeoProjectProductionSourceKind(kind)) {
         throw new Error(
@@ -120180,16 +120978,13 @@ function prepareCompleteNeoScriptBodyChanges(workspace, status, schema, options
         `Cannot include server-derived NeoScript refresh for member "${compiled.id}": its reconstructed working-copy row is missing.`
       );
     }
-    const cascadeChange = {
-      kind: "update",
+    const cascadeChange = recordUpsertChange({
+      base,
       recordKind: "member",
       recordId: compiled.id,
       file: reconstructed3.file,
-      nextData,
-      baseData: base.data,
-      baseContentHash: base.contentHash,
-      casBaseHash: base.conflictServerHash ?? base.contentHash
-    };
+      nextData
+    });
     status.changes.push(cascadeChange);
     changesById.set(compiled.id, cascadeChange);
   }
@@ -120258,16 +121053,13 @@ function prepareNSPropertySetterChanges(workspace, status) {
           `Cannot cascade removal of NeoScript property setter to override "${memberId}": its working-copy state is missing.`
         );
       }
-      const cascadeChange = {
-        kind: "update",
+      const cascadeChange = recordUpsertChange({
+        base,
         recordKind: "member",
         recordId: memberId,
         file: reconstructed3.file,
-        nextData: next,
-        baseData: base.data,
-        baseContentHash: base.contentHash,
-        casBaseHash: base.conflictServerHash ?? base.contentHash
-      };
+        nextData: next
+      });
       status.changes.push(cascadeChange);
       changesById.set(memberId, cascadeChange);
     }
@@ -120334,16 +121126,13 @@ function prepareNSFunctionBodyChanges(workspace, status) {
         `Cannot recompile NeoScript function override "${memberId}": its working-copy state is missing.`
       );
     }
-    const cascadeChange = {
-      kind: "update",
+    const cascadeChange = recordUpsertChange({
+      base,
       recordKind: "member",
       recordId: memberId,
       file: reconstructed3.file,
-      nextData: member,
-      baseData: base.data,
-      baseContentHash: base.contentHash,
-      casBaseHash: base.conflictServerHash ?? base.contentHash
-    };
+      nextData: member
+    });
     status.changes.push(cascadeChange);
     changesById.set(memberId, cascadeChange);
   }
@@ -120467,6 +121256,7 @@ var init_push = __esm({
     init_src();
     init_compiler_adapter();
     init_project_source_identity();
+    init_workspace_source_path();
     init_convex();
     init_http();
     init_ui();
@@ -120553,7 +121343,7 @@ var init_registry2 = __esm({
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
       formatVersion: 3,
       contractVersion: "3.15",
-      cliVersion: "0.38.4",
+      cliVersion: "0.38.6",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -121876,11 +122666,11 @@ __export(test_exports, {
 });
 import { createHash as createHash11, randomUUID as randomUUID3 } from "node:crypto";
 import {
-  existsSync as existsSync12,
+  existsSync as existsSync13,
   mkdirSync as mkdirSync11,
   readdirSync as readdirSync5,
   readFileSync as readFileSync16,
-  realpathSync,
+  realpathSync as realpathSync2,
   renameSync as renameSync5,
   rmSync as rmSync7,
   statSync as statSync3,
@@ -121888,12 +122678,12 @@ import {
 } from "node:fs";
 import {
   basename as basename3,
-  dirname as dirname9,
-  isAbsolute as isAbsolute2,
-  join as join16,
-  relative as relative5,
-  resolve as resolve3,
-  sep as sep5
+  dirname as dirname10,
+  isAbsolute as isAbsolute3,
+  join as join15,
+  relative as relative6,
+  resolve as resolve4,
+  sep as sep6
 } from "node:path";
 import { isDeepStrictEqual } from "node:util";
 function isRecord10(value) {
@@ -122079,25 +122869,25 @@ function preparedHookCandidate(workspace) {
     return null;
   }
   try {
-    const directory = realpathSync(configuredDirectory);
-    const cacheRoot = resolve3(
-      realpathSync(workspace.root),
+    const directory = realpathSync2(configuredDirectory);
+    const cacheRoot = resolve4(
+      realpathSync2(workspace.root),
       ".neo",
       "test-build"
     );
-    const pathFromRoot = relative5(cacheRoot, directory);
-    if (isAbsolute2(pathFromRoot)) {
+    const pathFromRoot = relative6(cacheRoot, directory);
+    if (isAbsolute3(pathFromRoot)) {
       throw new NeoTestPreparedCandidateError(
         "NEO_PREPARED_BUILD_DIR must not resolve to an absolute path outside this workspace's .neo/test-build directory."
       );
     }
-    if (pathFromRoot === ".." || pathFromRoot.startsWith(`..${sep5}`)) {
+    if (pathFromRoot === ".." || pathFromRoot.startsWith(`..${sep6}`)) {
       throw new NeoTestPreparedCandidateError(
         "NEO_PREPARED_BUILD_DIR must resolve inside this workspace's .neo/test-build directory."
       );
     }
     const parsed = JSON.parse(
-      readFileSync16(join16(directory, "candidate.json"), "utf8")
+      readFileSync16(join15(directory, "candidate.json"), "utf8")
     );
     if (!isRecord10(parsed)) {
       throw new NeoTestPreparedCandidateError(
@@ -122154,7 +122944,7 @@ function fingerprintTestCandidateInputs(workspace) {
 }
 function testCandidateCachePath(workspace, inputFingerprint) {
   const cacheKey = createHash11("sha256").update(inputFingerprint).digest("hex");
-  return join16(
+  return join15(
     workspace.root,
     ".neo",
     "test-build",
@@ -122179,7 +122969,7 @@ function cachedTestCandidate(workspace, inputFingerprint) {
     }
     if (typeof parsed.documentSha256 !== "string") return null;
     const documentJson = readFileSync16(
-      join16(dirname9(candidatePath), "document.json"),
+      join15(dirname10(candidatePath), "document.json"),
       "utf8"
     );
     if (createHash11("sha256").update(documentJson).digest("hex") !== parsed.documentSha256) {
@@ -122200,7 +122990,7 @@ function cacheTestCandidate(workspace, inputFingerprint, candidate) {
   const documentJson = JSON.stringify(candidate.document);
   const documentSha256 = createHash11("sha256").update(documentJson).digest("hex");
   const candidatePath = testCandidateCachePath(workspace, inputFingerprint);
-  atomicWrite(join16(dirname9(candidatePath), "document.json"), documentJson);
+  atomicWrite(join15(dirname10(candidatePath), "document.json"), documentJson);
   atomicWrite(
     candidatePath,
     JSON.stringify({
@@ -122217,10 +123007,10 @@ function cacheTestCandidate(workspace, inputFingerprint, candidate) {
 }
 function compileSpec(workspace, document, absolutePath, projectCompilationHash2) {
   const scriptDocument = readDocumentArrays(document);
-  const path = relative5(workspace.root, absolutePath).split(sep5).join("/");
+  const path = relative6(workspace.root, absolutePath).split(sep6).join("/");
   const source = readFileSync16(absolutePath, "utf8");
   const sourceHash = createHash11("sha256").update(source).digest("hex");
-  const artifactPath = join16(
+  const artifactPath = join15(
     workspace.root,
     ".neo",
     "test-build",
@@ -122278,7 +123068,7 @@ function selectedSpecPaths(workspace, selectors) {
   const relativePaths = new Map(
     all.map((absolutePath) => [
       absolutePath,
-      relative5(workspace.root, absolutePath).split(sep5).join("/")
+      relative6(workspace.root, absolutePath).split(sep6).join("/")
     ])
   );
   const normalizedSelectors = selectors.map(
@@ -122286,22 +123076,22 @@ function selectedSpecPaths(workspace, selectors) {
   );
   for (const selector of normalizedSelectors) {
     if (/[*?]/u.test(selector)) continue;
-    if (isAbsolute2(selector)) {
+    if (isAbsolute3(selector)) {
       throw new Error(
         `Spec selector ${JSON.stringify(selector)} must be workspace-relative.`
       );
     }
-    const absolute = resolve3(workspace.root, selector);
-    const workspaceRelative = relative5(workspace.root, absolute);
-    if (workspaceRelative === ".." || workspaceRelative.startsWith(`..${sep5}`)) {
+    const absolute = resolve4(workspace.root, selector);
+    const workspaceRelative = relative6(workspace.root, absolute);
+    if (workspaceRelative === ".." || workspaceRelative.startsWith(`..${sep6}`)) {
       throw new Error(
         `Spec selector ${JSON.stringify(selector)} is outside the workspace.`
       );
     }
-    if (!existsSync12(absolute)) continue;
-    const real = realpathSync(absolute);
-    const realRelative = relative5(workspace.root, real);
-    if (realRelative === ".." || realRelative.startsWith(`..${sep5}`)) {
+    if (!existsSync13(absolute)) continue;
+    const real = realpathSync2(absolute);
+    const realRelative = relative6(workspace.root, real);
+    if (realRelative === ".." || realRelative.startsWith(`..${sep6}`)) {
       throw new Error(
         `Spec selector ${JSON.stringify(selector)} resolves outside the workspace through a symlink.`
       );
@@ -122311,7 +123101,7 @@ function selectedSpecPaths(workspace, selectors) {
         `Spec selector ${JSON.stringify(selector)} is ignored, private, symlinked, or is not a .spec.neo file.`
       );
     }
-    if (statSync3(absolute).isDirectory() && !all.some((path) => path.startsWith(`${absolute}${sep5}`))) {
+    if (statSync3(absolute).isDirectory() && !all.some((path) => path.startsWith(`${absolute}${sep6}`))) {
       throw new Error(
         `Spec selector ${JSON.stringify(selector)} is ignored, private, or contains no eligible .spec.neo files.`
       );
@@ -123044,18 +123834,18 @@ async function executeRegisteredSpec(registered, document, selected, timeoutMs,
   return { tests: results, failures: fileFailures, testDurationMs };
 }
 function atomicWrite(path, content) {
-  mkdirSync11(dirname9(path), { recursive: true });
+  mkdirSync11(dirname10(path), { recursive: true });
   const temporary = `${path}.tmp-${String(process.pid)}-${randomUUID3()}`;
   writeFileSync11(temporary, content, "utf8");
   renameSync5(temporary, path);
 }
 function testBuildFiles(root) {
-  if (!existsSync12(root)) return [];
+  if (!existsSync13(root)) return [];
   const files = [];
   const visit = (directory) => {
     for (const entry of readdirSync5(directory, { withFileTypes: true })) {
       if (entry.isSymbolicLink()) continue;
-      const path = join16(directory, entry.name);
+      const path = join15(directory, entry.name);
       if (entry.isDirectory()) visit(path);
       else if (entry.isFile()) {
         const stats = statSync3(path);
@@ -123067,16 +123857,16 @@ function testBuildFiles(root) {
   return files;
 }
 function maintainNeoTestBuildCache(root, maxBytes = TEST_BUILD_CACHE_LIMIT_BYTES, now = Date.now(), protectedDirectory = process.env.NEO_PREPARED_BUILD_DIR) {
-  const resolvedRoot = resolve3(root);
-  const resolvedProtected = protectedDirectory === void 0 ? null : resolve3(protectedDirectory);
+  const resolvedRoot = resolve4(root);
+  const resolvedProtected = protectedDirectory === void 0 ? null : resolve4(protectedDirectory);
   const protectedInsideRoot = resolvedProtected !== null && (() => {
-    const fromRoot = relative5(resolvedRoot, resolvedProtected);
-    return fromRoot === "" || !fromRoot.startsWith(`..${sep5}`) && fromRoot !== ".." && !isAbsolute2(fromRoot);
+    const fromRoot = relative6(resolvedRoot, resolvedProtected);
+    return fromRoot === "" || !fromRoot.startsWith(`..${sep6}`) && fromRoot !== ".." && !isAbsolute3(fromRoot);
   })();
   const isProtected = (path) => {
     if (!protectedInsideRoot || resolvedProtected === null) return false;
-    const fromProtected = relative5(resolvedProtected, resolve3(path));
-    return fromProtected === "" || !fromProtected.startsWith(`..${sep5}`) && fromProtected !== ".." && !isAbsolute2(fromProtected);
+    const fromProtected = relative6(resolvedProtected, resolve4(path));
+    return fromProtected === "" || !fromProtected.startsWith(`..${sep6}`) && fromProtected !== ".." && !isAbsolute3(fromProtected);
   };
   for (const file of testBuildFiles(root)) {
     if (!isProtected(file.path) && basename3(file.path).includes(".tmp-") && now - file.modifiedMs >= ABANDONED_TEMP_MAX_AGE_MS) {
@@ -123116,7 +123906,7 @@ function formatStatusCounts(passed, failed, total, skipped = 0) {
 async function runTest(workspace, options, dependencies = {}) {
   const started = Date.now();
   const performanceStarted = performance.now();
-  const testBuildRoot = join16(workspace.root, ".neo", "test-build");
+  const testBuildRoot = join15(workspace.root, ".neo", "test-build");
   maintainNeoTestBuildCache(testBuildRoot);
   const startedAt = new Date(started).toISOString();
   let projectFingerprint = null;
@@ -123220,7 +124010,7 @@ async function runTest(workspace, options, dependencies = {}) {
       throw new NeoTestUsageError(errorMessage2(error));
     }
     selectedFiles = selectedPaths.map(
-      (path) => relative5(workspace.root, path).split(sep5).join("/")
+      (path) => relative6(workspace.root, path).split(sep6).join("/")
     );
     if (selectedPaths.length === 0 && options.passWithNoTests !== true) {
       throw new NeoTestNoTestsError(
@@ -123295,7 +124085,7 @@ async function runTest(workspace, options, dependencies = {}) {
       }))
     };
     atomicWrite(
-      join16(workspace.root, ".neo", "test-build", "v1", "manifest.json"),
+      join15(workspace.root, ".neo", "test-build", "v1", "manifest.json"),
       `${JSON.stringify(buildManifest, null, 2)}
 `
     );
@@ -123384,7 +124174,7 @@ async function runTest(workspace, options, dependencies = {}) {
   if (options.outputFile !== null) {
     try {
       atomicWrite(
-        isAbsolute2(options.outputFile) ? options.outputFile : join16(workspace.root, options.outputFile),
+        isAbsolute3(options.outputFile) ? options.outputFile : join15(workspace.root, options.outputFile),
         serialized
       );
     } catch (error) {
@@ -123468,7 +124258,7 @@ async function inspectNeoTestCompilation(workspace, dependencies = {}) {
   if (candidate.document === null) {
     return {
       files: selectedPaths.map(
-        (path) => relative5(workspace.root, path).split(sep5).join("/")
+        (path) => relative6(workspace.root, path).split(sep6).join("/")
       ),
       errors: [
         {
@@ -123489,14 +124279,14 @@ async function inspectNeoTestCompilation(workspace, dependencies = {}) {
       compileSpec(workspace, document, path, compilationHash);
     } catch (error) {
       errors.push({
-        file: relative5(workspace.root, path).split(sep5).join("/"),
+        file: relative6(workspace.root, path).split(sep6).join("/"),
         message: errorMessage2(error)
       });
     }
   }
   return {
     files: selectedPaths.map(
-      (path) => relative5(workspace.root, path).split(sep5).join("/")
+      (path) => relative6(workspace.root, path).split(sep6).join("/")
     ),
     errors
   };
@@ -123595,10 +124385,10 @@ __export(doctor_exports, {
 import {
   constants as fsConstants,
   accessSync,
-  existsSync as existsSync13,
+  existsSync as existsSync14,
   readFileSync as readFileSync17
 } from "node:fs";
-import { extname as extname2, isAbsolute as isAbsolute3, join as join17, relative as relative6, sep as sep6 } from "node:path";
+import { extname as extname2, isAbsolute as isAbsolute4, join as join16, relative as relative7, sep as sep7 } from "node:path";
 function inspectNeoDoctor(workspace) {
   const formatCompatible = workspace.config.formatVersion === CURRENT_FORMAT_VERSION;
   const compiler = inspectCompilerContract();
@@ -123714,8 +124504,8 @@ function inspectSourceContract(workspace) {
   }
 }
 function inspectExtensionContract(root) {
-  const cachePath = join17(root, PROJECT_SOURCE_ANALYSIS_V4_CACHE_PATH);
-  if (!existsSync13(cachePath)) {
+  const cachePath = join16(root, PROJECT_SOURCE_ANALYSIS_V4_CACHE_PATH);
+  if (!existsSync14(cachePath)) {
     return {
       id: NEO_VSCODE_EXTENSION_ID,
       contractVersion: NEO_VSCODE_EXTENSION_CONTRACT_VERSION,
@@ -123778,7 +124568,7 @@ function inspectTrackedBinary(root, record3, errors) {
   const binary = record3.projectBinary;
   if (!binary) return;
   const path = binary.path.replaceAll("\\", "/");
-  if (isAbsolute3(path) || path.split("/").includes("..")) {
+  if (isAbsolute4(path) || path.split("/").includes("..")) {
     errors.push(
       `Project file ${record3.recordId} has unsafe tracked path ${JSON.stringify(binary.path)}.`
     );
@@ -123798,8 +124588,8 @@ function inspectTrackedBinary(root, record3, errors) {
       `Project file ${record3.recordId} has an invalid SHA-256 base digest.`
     );
   }
-  const absolute = join17(root, path);
-  if (existsSync13(absolute) && !canAccess(absolute, fsConstants.R_OK)) {
+  const absolute = join16(root, path);
+  if (existsSync14(absolute) && !canAccess(absolute, fsConstants.R_OK)) {
     errors.push(`Tracked project file ${path} is not readable.`);
   }
 }
@@ -123824,7 +124614,7 @@ function canAccess(path, mode) {
   }
 }
 function workspacePath(root, path) {
-  return relative6(root, path).split(sep6).join("/");
+  return relative7(root, path).split(sep7).join("/");
 }
 function errorMessage3(error) {
   return error instanceof Error ? error.message : String(error);
@@ -123940,8 +124730,8 @@ __export(migrate_exports, {
   runMigrate: () => runMigrate
 });
 import { randomUUID as randomUUID4 } from "node:crypto";
-import { existsSync as existsSync14, mkdirSync as mkdirSync12, readdirSync as readdirSync6, writeFileSync as writeFileSync12 } from "node:fs";
-import { join as join18 } from "node:path";
+import { existsSync as existsSync15, mkdirSync as mkdirSync12, readdirSync as readdirSync6, writeFileSync as writeFileSync12 } from "node:fs";
+import { join as join17 } from "node:path";
 async function runMigrate(workspace, subcommand, positional, targetRef, json, dependencies = {}) {
   if (subcommand === "new") {
     const name = positional[0];
@@ -123950,10 +124740,10 @@ async function runMigrate(workspace, subcommand, positional, targetRef, json, de
         "Usage: neo migrate new <name> [--target <ClassName|project>]"
       );
     }
-    const migrationsDir = join18(workspace.root, "Migrations");
+    const migrationsDir = join17(workspace.root, "Migrations");
     mkdirSync12(migrationsDir, { recursive: true });
     let nextOrder = 1;
-    if (existsSync14(migrationsDir)) {
+    if (existsSync15(migrationsDir)) {
       for (const entry of readdirSync6(migrationsDir)) {
         const match = /^(\d+)-/.exec(entry);
         if (match !== null) {
@@ -123962,8 +124752,8 @@ async function runMigrate(workspace, subcommand, positional, targetRef, json, de
       }
     }
     const relPath = migrationFileName(nextOrder, name);
-    const absolute = join18(workspace.root, relPath);
-    if (existsSync14(absolute)) {
+    const absolute = join17(workspace.root, relPath);
+    if (existsSync15(absolute)) {
       throw new Error(`"${relPath}" already exists.`);
     }
     const target = targetRef ?? "project";
@@ -125534,7 +126324,7 @@ async function waitForMergeTransaction(args) {
     status = readMergeTransactionStatus(response, status.transactionId);
     if (status.commitStatus === "committed") continue;
     if (status.commitStatus === "failed") continue;
-    await new Promise((resolve4) => setTimeout(resolve4, delayMs));
+    await new Promise((resolve5) => setTimeout(resolve5, delayMs));
     delayMs = Math.min(delayMs * 2, 5e3);
   }
 }
@@ -126756,7 +127546,7 @@ __export(export_exports, {
   runExportUnity: () => runExportUnity
 });
 import { mkdirSync as mkdirSync13, writeFileSync as writeFileSync13 } from "node:fs";
-import { join as join19 } from "node:path";
+import { join as join18 } from "node:path";
 async function runExportUnity(workspace, outDir) {
   if (outDir === null) {
     throw new Error(
@@ -126768,23 +127558,23 @@ async function runExportUnity(workspace, outDir) {
     `/api/projects/${workspace.config.projectId}/export`,
     { versionId: workspace.config.versionId }
   );
-  const resourcesDir = join19(outDir, "Resources", "Neo");
-  const localizationDir = join19(resourcesDir, "Localization");
-  const scriptsDir = join19(outDir, "Scripts", "Neo");
+  const resourcesDir = join18(outDir, "Resources", "Neo");
+  const localizationDir = join18(resourcesDir, "Localization");
+  const scriptsDir = join18(outDir, "Scripts", "Neo");
   mkdirSync13(localizationDir, { recursive: true });
   mkdirSync13(scriptsDir, { recursive: true });
-  writeFileSync13(join19(resourcesDir, "project.json"), response.projectJson);
+  writeFileSync13(join18(resourcesDir, "project.json"), response.projectJson);
   writeFileSync13(
-    join19(scriptsDir, "NeoGeneratedTypes.cs"),
+    join18(scriptsDir, "NeoGeneratedTypes.cs"),
     response.generatedTypes
   );
   for (const file of response.localizationFiles ?? []) {
-    writeFileSync13(join19(localizationDir, file.fileName), file.content);
+    writeFileSync13(join18(localizationDir, file.fileName), file.content);
   }
-  console.log(`wrote ${join19(resourcesDir, "project.json")}`);
-  console.log(`wrote ${join19(scriptsDir, "NeoGeneratedTypes.cs")}`);
+  console.log(`wrote ${join18(resourcesDir, "project.json")}`);
+  console.log(`wrote ${join18(scriptsDir, "NeoGeneratedTypes.cs")}`);
   for (const file of response.localizationFiles ?? []) {
-    console.log(`wrote ${join19(localizationDir, file.fileName)}`);
+    console.log(`wrote ${join18(localizationDir, file.fileName)}`);
   }
   const diagnostics = response.diagnostics ?? [];
   for (const diagnostic of diagnostics) {
@@ -126807,7 +127597,7 @@ __export(dev_exports, {
   runDev: () => runDev
 });
 import { watch } from "node:fs";
-import { join as join20 } from "node:path";
+import { join as join19 } from "node:path";
 import { emitKeypressEvents } from "node:readline";
 import { ConvexClient } from "convex/browser";
 function isSchemaSignal(value) {
@@ -126917,7 +127707,7 @@ async function runDev(workspace, options) {
   };
   for (const dir of ["Classes", "Enums"]) {
     try {
-      watch(join20(workspace.root, dir), { persistent: true }, onFileChange);
+      watch(join19(workspace.root, dir), { persistent: true }, onFileChange);
     } catch {
     }
   }
@@ -126973,7 +127763,7 @@ __export(resolve_exports, {
   workspaceFilePath: () => workspaceFilePath
 });
 import { readFileSync as readFileSync19, rmSync as rmSync8, writeFileSync as writeFileSync14 } from "node:fs";
-import { join as join21 } from "node:path";
+import { join as join20 } from "node:path";
 function runResolve(workspace, side) {
   const resolvedRecords = adoptServerConflictBases(workspace);
   let resolvedFiles = 0;
@@ -126989,12 +127779,12 @@ function runResolve(workspace, side) {
     const binary = state.projectBinary;
     const conflict2 = binary?.conflict;
     if (binary === void 0 || conflict2 === void 0) continue;
-    const destination = join21(workspace.root, binary.path);
+    const destination = join20(workspace.root, binary.path);
     if (side === "theirs") {
       if (conflict2.remoteSha256 !== null && conflict2.artifactPath !== void 0) {
         writeVerifiedBinaryDownloadV4(
           destination,
-          readFileSync19(join21(workspace.root, conflict2.artifactPath)),
+          readFileSync19(join20(workspace.root, conflict2.artifactPath)),
           conflict2.remoteSha256
         );
         binary.sha256 = conflict2.remoteSha256;
@@ -127004,7 +127794,7 @@ function runResolve(workspace, side) {
       }
     }
     if (conflict2.artifactPath !== void 0) {
-      rmSync8(join21(workspace.root, conflict2.artifactPath), { force: true });
+      rmSync8(join20(workspace.root, conflict2.artifactPath), { force: true });
     }
     delete binary.conflict;
     resolvedBinaries += 1;
@@ -127073,7 +127863,7 @@ function resolveMarkers(source, side) {
   return output.join("\n");
 }
 function workspaceFilePath(workspace, file) {
-  return join21(workspace.root, file);
+  return join20(workspace.root, file);
 }
 var init_resolve = __esm({
   "src/commands/resolve.ts"() {
@@ -127278,7 +128068,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.38.4");
+    console.log("0.38.6");
     return;
   }
   if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {