@neocompose/cli 0.38.4 → 0.38.5

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;
+    }
+    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;
     }
-    rootValue[root.key] = lookups.valueById(member.valueId)?.value ?? null;
+    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] : [])
   );
@@ -110306,8 +110761,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 +110941,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 +111051,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 +111109,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 +111131,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 +111150,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 +111226,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 +111292,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 +111300,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 +111335,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 +111442,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 +111514,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 +111564,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 +111583,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 +111772,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 +111815,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 +111828,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 +111838,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 +111850,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 +111870,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 +112882,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 +112890,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 +112915,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 +112953,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 +112966,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 +112981,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 +113014,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 +113023,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 +113042,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 +113189,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 +113213,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 +113296,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 +113481,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);
@@ -113161,12 +113806,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,
@@ -113205,6 +113857,7 @@ 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;
@@ -113215,9 +113868,9 @@ 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;
+    const absolute = resolveSourcePath(path);
+    mkdirSync8(dirname8(absolute), { recursive: true });
+    const existing = existsSync8(absolute) ? readFileSync9(absolute, "utf8") : null;
     if (existing !== null && !rewritePaths.has(path)) continue;
     if (existing !== content) {
       writeFileSync8(absolute, content, "utf8");
@@ -113227,9 +113880,13 @@ 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;
     }
@@ -113521,6 +114178,7 @@ 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();
@@ -113535,8 +114193,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 join11, resolve as resolve3 } from "node:path";
 async function runInit(options) {
   let projectId = options.projectId;
   let projects = [];
@@ -113632,8 +114290,8 @@ 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))) {
+  const root = resolve3(directory);
+  if (existsSync9(join11(root, NEO_CONFIG_FILE))) {
     throw new Error(`"${join11(root, NEO_CONFIG_FILE)}" already exists.`);
   }
   mkdirSync9(root, { recursive: true });
@@ -113660,7 +114318,7 @@ async function runInit(options) {
 }
 function ensurePrivateStateIgnored(root) {
   const path = join11(root, ".gitignore");
-  const existing = existsSync8(path) ? readFileSync10(path, "utf8") : "";
+  const existing = existsSync9(path) ? readFileSync10(path, "utf8") : "";
   if (existing.split(/\r?\n/u).some((line) => line.trim() === ".neo/" || line.trim() === ".neo")) {
     return;
   }
@@ -114066,7 +114724,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,7 +115723,7 @@ var init_save_overlay_resolution = __esm({
 });
 
 // src/commands/push-body-diagnostics.ts
-import { existsSync as existsSync9, readFileSync as readFileSync11 } from "node:fs";
+import { existsSync as existsSync10, readFileSync as readFileSync11 } from "node:fs";
 import { join as join12 } from "node:path";
 function createNeoScriptBodySourceLocator(workspace, status) {
   const textByFile = /* @__PURE__ */ new Map();
@@ -115089,7 +115747,7 @@ function createNeoScriptBodySourceLocator(workspace, status) {
       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 text = existsSync10(path) ? readFileSync11(path, "utf8") : null;
       textByFile.set(file, text);
       return text;
     }
@@ -116891,8 +117549,8 @@ 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 join13, relative as relative4, sep as sep4 } from "node:path";
 function fingerprintPushInputs(workspace, options = {}) {
   const paths = /* @__PURE__ */ new Set([
     join13(workspace.root, "neo.json"),
@@ -116901,7 +117559,7 @@ function fingerprintPushInputs(workspace, options = {}) {
     ...workspace.config.unityConfigPath === void 0 ? [] : [join13(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);
@@ -116913,7 +117571,7 @@ function fingerprintPushInputs(workspace, options = {}) {
   visitManaged(join13(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 {
@@ -117340,7 +117998,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 +118006,7 @@ async function waitForRetry(attempt, signal) {
     const timeout = setTimeout(
       () => {
         signal.removeEventListener("abort", abort);
-        resolve4();
+        resolve5();
       },
       200 * 2 ** (attempt - 1)
     );
@@ -117581,11 +118239,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 join15, 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 +118784,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 });
   });
@@ -118885,7 +119543,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 +119862,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 +120073,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 +120264,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) {
@@ -119615,7 +120297,7 @@ function authoredMemberFormsByFile(root, alternates) {
     let existing = contents.get(alternate.path);
     if (existing === void 0) {
       const absolute = join15(root, alternate.path);
-      existing = existsSync11(absolute) ? readFileSync15(absolute, "utf8") : null;
+      existing = existsSync12(absolute) ? readFileSync15(absolute, "utf8") : null;
       contents.set(alternate.path, existing);
     }
     if (existing === null || !existing.includes(alternate.block)) continue;
@@ -119653,14 +120335,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 +120358,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 +120390,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 +120450,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(
@@ -120467,6 +121154,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 +121241,7 @@ var init_registry2 = __esm({
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
       formatVersion: 3,
       contractVersion: "3.15",
-      cliVersion: "0.38.4",
+      cliVersion: "0.38.5",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -121876,11 +122564,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 +122576,12 @@ import {
 } from "node:fs";
 import {
   basename as basename3,
-  dirname as dirname9,
-  isAbsolute as isAbsolute2,
+  dirname as dirname10,
+  isAbsolute as isAbsolute3,
   join as join16,
-  relative as relative5,
-  resolve as resolve3,
-  sep as sep5
+  relative as relative6,
+  resolve as resolve4,
+  sep as sep6
 } from "node:path";
 import { isDeepStrictEqual } from "node:util";
 function isRecord10(value) {
@@ -122079,19 +122767,19 @@ 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."
       );
@@ -122179,7 +122867,7 @@ function cachedTestCandidate(workspace, inputFingerprint) {
     }
     if (typeof parsed.documentSha256 !== "string") return null;
     const documentJson = readFileSync16(
-      join16(dirname9(candidatePath), "document.json"),
+      join16(dirname10(candidatePath), "document.json"),
       "utf8"
     );
     if (createHash11("sha256").update(documentJson).digest("hex") !== parsed.documentSha256) {
@@ -122200,7 +122888,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(join16(dirname10(candidatePath), "document.json"), documentJson);
   atomicWrite(
     candidatePath,
     JSON.stringify({
@@ -122217,7 +122905,7 @@ 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(
@@ -122278,7 +122966,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 +122974,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 +122999,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,13 +123732,13 @@ 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 })) {
@@ -123067,16 +123755,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) {
@@ -123220,7 +123908,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(
@@ -123384,7 +124072,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 : join16(workspace.root, options.outputFile),
         serialized
       );
     } catch (error) {
@@ -123468,7 +124156,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 +124177,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 +124283,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 join17, relative as relative7, sep as sep7 } from "node:path";
 function inspectNeoDoctor(workspace) {
   const formatCompatible = workspace.config.formatVersion === CURRENT_FORMAT_VERSION;
   const compiler = inspectCompilerContract();
@@ -123715,7 +124403,7 @@ function inspectSourceContract(workspace) {
 }
 function inspectExtensionContract(root) {
   const cachePath = join17(root, PROJECT_SOURCE_ANALYSIS_V4_CACHE_PATH);
-  if (!existsSync13(cachePath)) {
+  if (!existsSync14(cachePath)) {
     return {
       id: NEO_VSCODE_EXTENSION_ID,
       contractVersion: NEO_VSCODE_EXTENSION_CONTRACT_VERSION,
@@ -123778,7 +124466,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)}.`
     );
@@ -123799,7 +124487,7 @@ function inspectTrackedBinary(root, record3, errors) {
     );
   }
   const absolute = join17(root, path);
-  if (existsSync13(absolute) && !canAccess(absolute, fsConstants.R_OK)) {
+  if (existsSync14(absolute) && !canAccess(absolute, fsConstants.R_OK)) {
     errors.push(`Tracked project file ${path} is not readable.`);
   }
 }
@@ -123824,7 +124512,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,7 +124628,7 @@ __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 { existsSync as existsSync15, mkdirSync as mkdirSync12, readdirSync as readdirSync6, writeFileSync as writeFileSync12 } from "node:fs";
 import { join as join18 } from "node:path";
 async function runMigrate(workspace, subcommand, positional, targetRef, json, dependencies = {}) {
   if (subcommand === "new") {
@@ -123953,7 +124641,7 @@ async function runMigrate(workspace, subcommand, positional, targetRef, json, de
     const migrationsDir = join18(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) {
@@ -123963,7 +124651,7 @@ async function runMigrate(workspace, subcommand, positional, targetRef, json, de
     }
     const relPath = migrationFileName(nextOrder, name);
     const absolute = join18(workspace.root, relPath);
-    if (existsSync14(absolute)) {
+    if (existsSync15(absolute)) {
       throw new Error(`"${relPath}" already exists.`);
     }
     const target = targetRef ?? "project";
@@ -125534,7 +126222,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);
   }
 }
@@ -127278,7 +127966,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.5");
     return;
   }
   if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {