@neocompose/cli 0.53.1 → 0.53.3

package/dist/neo.mjs

@@ -7456,7 +7456,7 @@ var init_strict_resolver = __esm({
         }
         return resolved.pointer.value;
       }
-      resolveAssignment(statement, scope) {
+      resolveAssignment(statement, scope, assignmentContext = "ordinary") {
         if (!isAssignmentTarget(statement.target)) {
           throw new CompileError(
             "Assignment target must be a variable, member, or indexed value.",
@@ -7494,9 +7494,27 @@ var init_strict_resolver = __esm({
             statement.pos
           );
         }
-        if (!writability || writability === "readOnly" /* ReadOnly */ || writability === "immutable" /* Immutable */) {
+        if (target.symbol?.readonlyDeclaration === true) {
           throw new CompileError(
-            target.symbol?.readonlyDeclaration === true ? `Member '${target.symbol.name}' is readonly and can only be changed through its class default.` : writability === "immutable" /* Immutable */ ? "Cannot assign because the target's effective storage is immutable." : `Cannot assign to a read-only ${this.describe(target.type)} value.`,
+            `Member '${target.symbol.name}' is readonly and can only be changed through its class default.`,
+            statement.pos
+          );
+        }
+        if (writability === void 0) {
+          throw new CompileError(
+            `Cannot assign to a read-only ${this.describe(target.type)} value.`,
+            statement.pos
+          );
+        }
+        if (writability === "readOnly" /* ReadOnly */) {
+          throw new CompileError(
+            `Cannot assign to a read-only ${this.describe(target.type)} value.`,
+            statement.pos
+          );
+        }
+        if (writability === "immutable" /* Immutable */ && assignmentContext !== "initializer") {
+          throw new CompileError(
+            "Cannot assign because the target's effective storage is immutable.",
             statement.pos
           );
         }
@@ -9281,16 +9299,22 @@ var init_strict_resolver = __esm({
         const registryEntry = this.resolveRegistryEntry(receiver, name, pos);
         if (registryEntry) return registryEntry;
         if (receiver.indexSurface) {
-          const index = (this.context.project.listIndexes ?? []).find(
-            (candidate) => candidate.listMemberId === receiver.indexSurface?.listMemberId && candidate.name === name
+          const surface = receiver.indexSurface;
+          const declared = this.indexesFor(surface).find(
+            (candidate) => candidate.name === name
           );
-          if (!index) {
+          if (!declared) {
             throw new CompileError(
               `List index surface has no declared index '${name}'.`,
               pos
             );
           }
-          const viewValueType = index.unique ? index.valueType : {
+          const index = {
+            ...declared,
+            keyType: this.boundIndexKeyType(declared, surface.elementType),
+            valueType: surface.elementType
+          };
+          const viewValueType = index.unique ? { ...index.valueType, nullable: true } : {
             kind: "list",
             elementType: { ...index.valueType, nullable: false },
             readOnly: true
@@ -9309,10 +9333,7 @@ var init_strict_resolver = __esm({
             indexCollectionPointer: receiver.pointer
           };
         }
-        const receiverListMemberId = receiver.type.kind === "list" ? receiver.type.listMemberId : void 0;
-        if (receiver.type.kind === "list" && name === "Index" && receiverListMemberId && (this.context.project.listIndexes ?? []).some(
-          (candidate) => candidate.listMemberId === receiverListMemberId
-        )) {
+        if (receiver.type.kind === "list" && name === "Index" && this.indexesFor(receiver.type).length > 0) {
           return {
             pointer: receiver.pointer,
             type: { kind: "primitive", name: "unknown" },
@@ -9462,6 +9483,23 @@ var init_strict_resolver = __esm({
           pos
         );
       }
+      boundIndexKeyType(index, entryType) {
+        const entry = neoScriptMemberLookupType(entryType);
+        if (entry.kind !== "named") return index.keyType;
+        const declaring = this.project.typeById.get(entry.typeId);
+        if (!declaring) return index.keyType;
+        const key = declaring.members.find((member) => member.name === index.name);
+        return substituteTypeParameters(
+          key?.type ?? index.keyType,
+          entry,
+          declaring
+        );
+      }
+      /** The indexes declared on a schema-backed List, keyed by its member. */
+      indexesFor(type) {
+        if (type.listMemberId === void 0) return [];
+        return this.project.indexesByListMemberId.get(type.listMemberId) ?? [];
+      }
       /**
        * P42 §2.3. `Images.<Name>` / `AudioClips.<Name>`.
        *
@@ -10341,7 +10379,8 @@ var init_strict_resolver = __esm({
                 receiver: { kind: "ident", name, pos: entry.pos }
               }
             },
-            initializerScope
+            initializerScope,
+            "initializer"
           );
           if (assignment.type !== "assign" /* Assign */) {
             throw new CompileError(
@@ -16354,6 +16393,28 @@ function effectiveSourceAccessModifier(modifiers, ownerKind) {
   if (explicit !== void 0) return explicit;
   return ownerKind === "interface" ? "public" : "private";
 }
+function sourceMemberKeyArgument(annotation2) {
+  const positional = annotation2.arguments[0];
+  const argument2 = annotation2.arguments.find((entry) => entry.name === "member") ?? (positional !== void 0 && positional.name === void 0 ? positional : void 0);
+  if (argument2 === void 0) return null;
+  const text = argument2.text.trim();
+  return {
+    key: /^[A-Za-z_][A-Za-z0-9_]*$/.test(text) ? text : null,
+    range: argument2.range
+  };
+}
+function* sourceListIndexAnnotations(annotations) {
+  for (const annotation2 of annotations) {
+    if (annotation2.name !== "index") continue;
+    const key = sourceMemberKeyArgument(annotation2)?.key;
+    if (!key) continue;
+    yield {
+      key,
+      unique: annotation2.arguments.find((argument2) => argument2.name === "kind")?.text.trim() === ".Unique",
+      annotation: annotation2
+    };
+  }
+}
 var init_project_source_ast = __esm({
   "../packages/neoscript-language/src/project-source-ast.ts"() {
     "use strict";
@@ -22751,7 +22812,7 @@ function validateMember(uri, member, ownerName, documentKind, ownerScope, enviro
   );
   validateTypeAnnotations(uri, member.type, environment, diagnostics);
   if (documentKind !== "flow") {
-    validateListAnnotations(uri, member, environment, diagnostics);
+    validateListAnnotations(uri, member, ownerName, environment, diagnostics);
   }
   const scope = new Map(ownerScope);
   if (member.kind === "function") {
@@ -23965,14 +24026,21 @@ function anchorPosition(anchor, offset) {
   return { line: anchor.start.line + line, character };
 }
 function sourceClassFieldByName(declaration, name, environment, initialBindings = /* @__PURE__ */ new Map()) {
+  const resolved = sourceClassMemberByName(
+    declaration,
+    name,
+    environment,
+    initialBindings
+  );
+  return resolved?.member.kind === "field" ? resolved : void 0;
+}
+function sourceClassMemberByName(declaration, name, environment, initialBindings = /* @__PURE__ */ new Map()) {
   const visited = /* @__PURE__ */ new Set();
   let current = declaration;
   let bindings = initialBindings;
   while (current !== void 0 && !visited.has(current.name)) {
     visited.add(current.name);
-    const member = current.members.find(
-      (candidate) => candidate.kind === "field" && candidate.name === name
-    );
+    const member = current.members.find((candidate) => candidate.name === name);
     if (member !== void 0) return { member, bindings };
     const base = current.baseTypes.find(
       (candidate) => environment.types.has(candidate.name)
@@ -24202,20 +24270,17 @@ function semanticMemberType(member, environment, bindings = /* @__PURE__ */ new
   if (type.name !== "List") return type;
   const entryType = type.arguments?.[0];
   if (!entryType) return type;
-  const entryClass = environment.types.get(entryType.name);
-  if (!entryClass) return type;
   const indexes2 = /* @__PURE__ */ new Map();
-  for (const annotation2 of member.annotations) {
-    if (annotation2.name !== "index") continue;
-    const key = memberKeyArgument(annotation2)?.key;
-    if (!key) continue;
-    const field = resolveEntryField(entryClass, key, environment);
+  for (const index of sourceListIndexAnnotations(member.annotations)) {
+    const field = sourceClassMemberForType(entryType, index.key, environment);
     if (!field) continue;
-    const unique = contextualAnnotationEnum([annotation2], "index", "kind") === "Unique";
-    const valueType = unique ? { ...entryType, nullable: true } : { name: "List", arguments: [{ ...entryType, nullable: false }] };
-    indexes2.set(key, {
+    const valueType = index.unique ? { ...entryType, nullable: true } : { name: "List", arguments: [{ ...entryType, nullable: false }] };
+    indexes2.set(index.key, {
       name: "Dictionary",
-      arguments: [semanticType(field.type), valueType]
+      arguments: [
+        substituteSemanticType(semanticType(field.member.type), field.bindings),
+        valueType
+      ]
     });
   }
   return indexes2.size === 0 ? type : { ...type, listIndexes: indexes2 };
@@ -24449,15 +24514,18 @@ function contextualAnnotationEnum(annotations, name, field) {
   const value = annotations.find((annotation2) => annotation2.name === name)?.arguments.find((argument2) => argument2.name === field)?.text.trim();
   return value?.startsWith(".") ? value.slice(1) : null;
 }
-function validateListAnnotations(uri, member, environment, diagnostics) {
+function validateListAnnotations(uri, member, ownerName, environment, diagnostics) {
   const declared = member.annotations.filter(
     (annotation2) => annotation2.name === "index" || annotation2.name === "column"
   );
   if (declared.length === 0) return;
-  const entryClass = listEntryClass(member.type, environment);
+  const entryType = listEntryType(
+    member.type,
+    environment.types.get(ownerName)
+  );
   const seen = /* @__PURE__ */ new Set();
   for (const annotation2 of declared) {
-    const target = memberKeyArgument(annotation2);
+    const target = sourceMemberKeyArgument(annotation2);
     if (target === null) {
       pushDiagnostic(
         diagnostics,
@@ -24492,20 +24560,25 @@ function validateListAnnotations(uri, member, environment, diagnostics) {
     if (annotation2.name === "column" && target.key === LIST_COLUMN_INHERITANCE_KEY) {
       continue;
     }
-    if (entryClass === null) continue;
-    const field = resolveEntryField(entryClass, target.key, environment);
-    if (field === null) {
+    if (entryType === null) continue;
+    if (!environment.types.has(entryType.name)) continue;
+    const field = sourceClassMemberForType(entryType, target.key, environment);
+    if (field === void 0) {
       pushDiagnostic(
         diagnostics,
         uri,
         target.range,
         "unresolved-list-annotation-member",
-        `@${annotation2.name}(member: ${target.key}) on '${member.name}' does not resolve on list entry class '${entryClass.name}'.`
+        `@${annotation2.name}(member: ${target.key}) on '${member.name}' does not resolve on list entry class '${entryType.name}'.`
       );
       continue;
     }
     if (annotation2.name !== "index") continue;
-    const domainError = indexKeyDomainError(field, environment);
+    const domainError = indexKeyDomainError(
+      field.member,
+      substituteSemanticType(semanticType(field.member.type), field.bindings),
+      environment
+    );
     if (domainError !== null) {
       pushDiagnostic(
         diagnostics,
@@ -24517,46 +24590,45 @@ function validateListAnnotations(uri, member, environment, diagnostics) {
     }
   }
 }
-function memberKeyArgument(annotation2) {
-  const positional = annotation2.arguments[0];
-  const argument2 = annotation2.arguments.find((entry) => entry.name === "member") ?? (positional !== void 0 && positional.name === void 0 ? positional : void 0);
-  if (argument2 === void 0) return null;
-  const text = argument2.text.trim();
-  return {
-    key: IDENTIFIER_PATTERN.test(text) ? text : null,
-    range: argument2.range
-  };
-}
-function listEntryClass(type, environment) {
+function listEntryType(type, owner) {
   if (type.name !== "List" && type.name !== "Set") return null;
-  const entry = type.typeArguments[0];
-  if (entry === void 0) return null;
-  return environment.types.get(entry.name) ?? null;
-}
-function resolveEntryField(entryClass, key, environment) {
+  let entry = type.typeArguments[0];
   const visited = /* @__PURE__ */ new Set();
-  let current = entryClass;
-  while (current !== void 0 && !visited.has(current.name)) {
-    visited.add(current.name);
-    const match = current.members.find((entry) => entry.name === key);
-    if (match !== void 0) return match;
-    current = current.baseTypes.map((base) => environment.types.get(base.name)).find((base) => base !== void 0);
+  while (entry !== void 0) {
+    const name = entry.name;
+    const parameter4 = owner?.genericParameters.find(
+      (candidate) => candidate.name === name
+    );
+    if (!parameter4) return semanticType(entry);
+    if (visited.has(parameter4.name)) return null;
+    visited.add(parameter4.name);
+    entry = parameter4.constraint;
   }
   return null;
 }
-function indexKeyDomainError(field, environment) {
+function sourceClassMemberForType(type, name, environment) {
+  const declaration = environment.types.get(type.name);
+  if (!declaration) return void 0;
+  const bindings = /* @__PURE__ */ new Map();
+  for (const [index, parameter4] of declaration.genericParameters.entries()) {
+    const argument2 = type.arguments?.[index];
+    if (argument2) bindings.set(parameter4.name, argument2);
+  }
+  return sourceClassMemberByName(declaration, name, environment, bindings);
+}
+function indexKeyDomainError(field, type, environment) {
   if (field.kind !== "field") {
     return `'${field.name}' is a ${field.kind}, and index keys require a stored field`;
   }
-  if (field.type.name === "string") {
+  if (type.name === "string") {
     return annotationEnumOption(field.annotations, "settings", "format") === "Plain" ? null : `'${field.name}' is localized, and String index keys must be plain`;
   }
-  if (environment.enums.has(field.type.name)) return null;
-  const entry = field.type.typeArguments[0];
-  if (field.type.name === "List" && entry !== void 0 && environment.enums.has(entry.name) && annotationEnumOption(field.annotations, "settings", "selection") === "Multi") {
+  if (environment.enums.has(type.name)) return null;
+  const entry = type.arguments?.[0];
+  if (type.name === "List" && entry !== void 0 && environment.enums.has(entry.name) && annotationEnumOption(field.annotations, "settings", "selection") === "Multi") {
     return `'${field.name}' is a multi-select Enum, and index keys require a single-select Enum`;
   }
-  return `'${field.name}' is a ${field.type.name} field, and index keys require a plain String or a single-select Enum`;
+  return `'${field.name}' is a ${type.name} field, and index keys require a plain String or a single-select Enum`;
 }
 function annotationEnumOption(annotations, name, field) {
   const value = annotations.find((annotation2) => annotation2.name === name)?.arguments.find((argument2) => argument2.name === field)?.text.trim();
@@ -24711,10 +24783,11 @@ function classDerivesFromName(name, ancestorName, environment, seen = /* @__PURE
     return classDerivesFromName(base.name, ancestorName, environment, seen);
   });
 }
-var NEO_VARIANT_FOLDER_SETTING, primitiveType, IDENTIFIER_PATTERN, LIST_COLUMN_INHERITANCE_KEY, SEMANTIC_PRIMITIVE_TYPE_NAMES;
+var NEO_VARIANT_FOLDER_SETTING, primitiveType, LIST_COLUMN_INHERITANCE_KEY, SEMANTIC_PRIMITIVE_TYPE_NAMES;
 var init_project_source_semantics = __esm({
   "../packages/neoscript-language/src/project-source-semantics.ts"() {
     "use strict";
+    init_project_source_ast();
     init_project_local_values();
     init_language_spec();
     init_project_schema_contract_generated();
@@ -24727,7 +24800,6 @@ var init_project_source_semantics = __esm({
     init_project_root();
     NEO_VARIANT_FOLDER_SETTING = "folder";
     primitiveType = (name) => ({ name });
-    IDENTIFIER_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
     LIST_COLUMN_INHERITANCE_KEY = "__other__";
     SEMANTIC_PRIMITIVE_TYPE_NAMES = /* @__PURE__ */ new Set([
       "bool",
@@ -25326,8 +25398,29 @@ function buildProjectGraph(documents) {
       writable: false
     });
   }
+  const listIndexes2 = [];
+  for (const { member, symbol, uri } of memberInfo.values()) {
+    if (symbol.type.kind !== "list") continue;
+    const entryType = symbol.type.elementType;
+    const entrySchema = neoScriptMemberLookupType(entryType);
+    if (entrySchema.kind !== "named") continue;
+    const entryMembers = effectiveMembers.get(entrySchema.typeId);
+    for (const index of sourceListIndexAnnotations(member.annotations)) {
+      const key = entryMembers?.find((field) => field.name === index.key);
+      if (key === void 0) continue;
+      listIndexes2.push({
+        id: `${symbol.id}:index:${key.name}`,
+        listMemberId: symbol.id,
+        name: key.name,
+        keyType: key.type,
+        valueType: entryType,
+        unique: index.unique,
+        location: location(uri, index.annotation.range)
+      });
+    }
+  }
   return {
-    project: { version: 1, types, globals, roots },
+    project: { version: 1, types, globals, roots, listIndexes: listIndexes2 },
     declarationsByName,
     typeIdsByName: typeIds,
     memberInfo
@@ -25338,7 +25431,8 @@ function sourceMemberSymbol(member, owner, typeIds, source) {
     member.annotations,
     `member:${owner.id}:${member.name}`
   );
-  const type = sourceTypeRef(member.type, owner, typeIds);
+  const declaredType = sourceTypeRef(member.type, owner, typeIds);
+  const type = declaredType.kind === "list" ? { ...declaredType, listMemberId: id2 } : declaredType;
   const staticMember = member.modifiers.includes("static");
   const readonlyDeclaration = member.modifiers.includes("readonly");
   const common = {
@@ -31783,9 +31877,9 @@ function assertDialogue(value, path) {
     (entry, index) => assertMember(entry, `${path}.functions[${index}]`)
   );
   array(dialogue.members, `${path}.members`).forEach((entry, index) => {
-    const memberPath2 = `${path}.members[${index}]`;
-    const member = record(entry, memberPath2);
-    exactKeys(member, memberPath2, [
+    const memberPath3 = `${path}.members[${index}]`;
+    const member = record(entry, memberPath3);
+    exactKeys(member, memberPath3, [
       "id",
       "state",
       "source",
@@ -31796,16 +31890,16 @@ function assertDialogue(value, path) {
       "arguments",
       "content"
     ]);
-    assertIdentity(member, memberPath2);
-    string(member.name, `${memberPath2}.name`);
-    string(member.graphType, `${memberPath2}.graphType`);
+    assertIdentity(member, memberPath3);
+    string(member.name, `${memberPath3}.name`);
+    string(member.graphType, `${memberPath3}.graphType`);
     if (member.destination !== null) {
-      string(member.destination, `${memberPath2}.destination`);
+      string(member.destination, `${memberPath3}.destination`);
     }
-    string(member.initializer, `${memberPath2}.initializer`);
-    assertFlowArguments(member.arguments, `${memberPath2}.arguments`);
+    string(member.initializer, `${memberPath3}.initializer`);
+    assertFlowArguments(member.arguments, `${memberPath3}.arguments`);
     if (member.content !== null) {
-      assertDialogueContent(member.content, `${memberPath2}.content`);
+      assertDialogueContent(member.content, `${memberPath3}.content`);
     }
   });
 }
@@ -34796,6 +34890,111 @@ var init_src = __esm({
   }
 });
 
+// src/project-source/lower-support.ts
+function identityMap(declarations, kind) {
+  return new Map(
+    declarations.map((declaration) => [
+      declaration.name,
+      materializedId(declaration, kind, declaration.name)
+    ])
+  );
+}
+function sourceIdentity2(identity2, kind, name) {
+  const sourceSpan = span(identity2);
+  return {
+    symbolId: `${kind}:${materializedIdentityId(identity2, kind, name)}`,
+    kind,
+    span: sourceSpan,
+    selectionSpan: sourceSpan
+  };
+}
+function span(identity2) {
+  return {
+    path: identity2.source.uri,
+    start: { ...identity2.source.range.start },
+    end: { ...identity2.source.range.end }
+  };
+}
+function materializedId(identity2, kind, name) {
+  return materializedIdentityId(identity2, kind, name);
+}
+function materializedIdentityId(identity2, kind, name) {
+  return identity2.id ?? `__pending__:${kind}:${encodeURIComponent(identity2.source.uri)}:${identity2.source.range.start.line}:${identity2.source.range.start.character}:${encodeURIComponent(name)}`;
+}
+function expressionArguments(expression) {
+  const result = /* @__PURE__ */ new Map();
+  expression.args.forEach((entry, index) => {
+    const name = expression.argumentNames?.[index] ?? null;
+    if (name === null) {
+      throw new Error(
+        "Project configuration constructors require named arguments."
+      );
+    }
+    if (result.has(name)) {
+      throw new Error(
+        `Constructor argument ${JSON.stringify(name)} is duplicated.`
+      );
+    }
+    result.set(name, entry);
+  });
+  return result;
+}
+function annotation(annotations, name) {
+  return annotations.find((entry) => entry.name === name);
+}
+function argument(value, name) {
+  return value?.arguments.find((entry) => entry.name === name)?.expression ?? null;
+}
+function parseAnnotationExpression(value) {
+  return parseExpression(value);
+}
+function stringArgument(value, name) {
+  const raw = argument(value, name);
+  if (raw === null) return null;
+  const expression = parseAnnotationExpression(raw);
+  return expression.kind === "litString" ? expression.value : null;
+}
+function contextualEnumArgument(value, name) {
+  const raw = argument(value, name);
+  if (raw === null) return null;
+  const expression = parseAnnotationExpression(raw);
+  return expression.kind === "contextualEnum" ? expression.name : null;
+}
+function systemMetadata(annotations) {
+  const system = annotation(annotations, "system");
+  if (!system) return null;
+  const kind = contextualEnumArgument(system, "kind");
+  if (kind === null) {
+    throw new Error("@system requires a kind inferred enum argument.");
+  }
+  const worldKind = contextualEnumArgument(system, "worldKind");
+  return {
+    kind: lowerFirst2(kind),
+    worldKind: worldKind ? lowerFirst2(worldKind) : null
+  };
+}
+function requiredName(values, name, kind) {
+  const value = values.get(name);
+  if (!value) throw new Error(`Unknown ${kind} ${JSON.stringify(name)}.`);
+  return value;
+}
+function lowerFirst2(value) {
+  return value.length ? `${value[0].toLowerCase()}${value.slice(1)}` : value;
+}
+function indexFirstById(values) {
+  const result = /* @__PURE__ */ new Map();
+  for (const value of values) {
+    if (!result.has(value.id)) result.set(value.id, value);
+  }
+  return result;
+}
+var init_lower_support = __esm({
+  "src/project-source/lower-support.ts"() {
+    "use strict";
+    init_src();
+  }
+});
+
 // src/project-source/local-values.ts
 function validateLocalValuePlacementsV4(value) {
   if (!Array.isArray(value))
@@ -34870,6 +35069,23 @@ function validateLocalValuePlacementsV4(value) {
     for (const entry of active) visited.add(entry);
   }
 }
+function* staticMembersInitializedByName(analysis) {
+  for (const sourceClass of analysis.schema.classes) {
+    for (const declaration of sourceClass.members) {
+      if (!declaration.modifiers.includes("static")) continue;
+      if (declaration.kind !== "field" || declaration.initializer === null)
+        continue;
+      const name = declaration.initializer.trim();
+      if (!/^[A-Za-z_]\w*$/u.test(name)) continue;
+      const path = `${sourceClass.name}.${declaration.name}`;
+      yield {
+        name,
+        memberId: materializedId(declaration, "member", path),
+        path
+      };
+    }
+  }
+}
 function typeText2(type) {
   return type.name + (type.arguments.length === 0 ? "" : `<${type.arguments.map(typeText2).join(", ")}>`) + (type.nullable ? "?" : "");
 }
@@ -34879,12 +35095,15 @@ var init_local_values = __esm({
     "use strict";
     init_workspace_source_path();
     init_src();
+    init_lower_support();
     LocalValueBindingsV4 = class {
       definitions = /* @__PURE__ */ new Map();
       expressions = /* @__PURE__ */ new Map();
       owners = /* @__PURE__ */ new Map();
+      /** Static members whose initializer is a bare local name, by that name. */
+      ownerMembers = /* @__PURE__ */ new Map();
       scalarTypes;
-      constructor(globals, enumNames = []) {
+      constructor(globals, enumNames = [], ownerMembers = []) {
         const scalarTypes = /* @__PURE__ */ new Set(["string", "int", "float", "decimal", "bool"]);
         for (const name of enumNames) scalarTypes.add(name);
         this.scalarTypes = scalarTypes;
@@ -34893,6 +35112,12 @@ var init_local_values = __esm({
             throw new Error(`Duplicate local value ${global.name}.`);
           this.definitions.set(global.name, global);
         }
+        for (const owner of ownerMembers) {
+          if (!this.definitions.has(owner.name)) continue;
+          const members = this.ownerMembers.get(owner.name) ?? [];
+          members.push({ memberId: owner.memberId, path: owner.path });
+          this.ownerMembers.set(owner.name, members);
+        }
       }
       resolve(expression, source, valueId) {
         if (expression.kind !== "ident") return { expression, source };
@@ -34931,6 +35156,44 @@ var init_local_values = __esm({
       has(name) {
         return this.definitions.has(name);
       }
+      /**
+       * The row a local names, answered without its owning assignment having
+       * lowered, so the answer does not depend on which file lowered first: the
+       * `@id` its declaration carries (through any alias chain), else the static
+       * member whose initializer is the local, whose row derives from the member.
+       * `null` for a local no push has identified yet.
+       */
+      declaredTarget(name) {
+        const definition2 = this.definitions.get(name);
+        if (definition2 === void 0) return null;
+        const chain = /* @__PURE__ */ new Set();
+        let global = definition2;
+        let expression;
+        for (; ; ) {
+          if (chain.has(global.name))
+            throw new Error(`Local initializer cycle reaches ${global.name}.`);
+          chain.add(global.name);
+          expression = this.expressions.get(global.name) ?? parseExpression(global.initializer);
+          this.expressions.set(global.name, expression);
+          const alias = expression.kind === "ident" ? this.definitions.get(expression.name) : void 0;
+          if (alias === void 0) break;
+          global = alias;
+        }
+        const typeName = definition2.type.name;
+        const id2 = expression.kind === "annotated" ? expression.annotations.find((entry) => entry.name === "id")?.args[0] : void 0;
+        if (id2 !== void 0 && id2.kind === "litString" && id2.value.length > 0) {
+          return { id: id2.value, typeName };
+        }
+        const owners = this.ownerMembers.get(name);
+        if (owners === void 0) return null;
+        if (owners.length !== 1) {
+          throw new Error(
+            `Reference(${name}) requires exactly one owning assignment.`
+          );
+        }
+        const owner = owners[0];
+        return { ownerMemberId: owner.memberId, ownerPath: owner.path, typeName };
+      }
       target(name) {
         const owners = this.owners.get(name);
         if (owners?.size !== 1)
@@ -59609,7 +59872,7 @@ function emitSupplementalProjectSourcesV4(records2, binaryPaths) {
     (candidate) => candidate.recordKind === "priority-group"
   )) {
     const data = recordData(record6);
-    const name = requiredName(data, record6);
+    const name = requiredName2(data, record6);
     files.push({
       path: defaultDeclarationPathV4("PriorityGroups", name, record6.recordId),
       content: emitPriorityGroup(data, record6.recordId, name),
@@ -59620,7 +59883,7 @@ function emitSupplementalProjectSourcesV4(records2, binaryPaths) {
     (candidate) => candidate.recordKind === "dialogue-group"
   )) {
     const data = recordData(record6);
-    const name = requiredName(data, record6);
+    const name = requiredName2(data, record6);
     files.push({
       path: defaultDeclarationPathV4("DialogueGroups", name, record6.recordId),
       content: emitDialogueGroup(
@@ -60380,7 +60643,7 @@ function recordData(record6) {
   }
   return record6.data;
 }
-function requiredName(data, record6) {
+function requiredName2(data, record6) {
   if (typeof data.name !== "string") {
     throw new Error(`${record6.recordKind}:${record6.recordId} has no name.`);
   }
@@ -60391,7 +60654,7 @@ function namesById(records2, kind) {
   return new Map(
     records2.filter((record6) => record6.recordKind === kind).map((record6) => [
       record6.recordId,
-      requiredName(recordData(record6), record6)
+      requiredName2(recordData(record6), record6)
     ])
   );
 }
@@ -60512,9 +60775,9 @@ function lowerSystemMetadata(annotations) {
     throw new Error("@system worldKind must be an inferred enum or null.");
   }
   return {
-    kind: lowerFirst2(kindExpression.name),
+    kind: lowerFirst3(kindExpression.name),
     ...worldKindExpression === void 0 ? {} : {
-      worldKind: worldKindExpression.kind === "contextualEnum" ? lowerFirst2(worldKindExpression.name) : null
+      worldKind: worldKindExpression.kind === "contextualEnum" ? lowerFirst3(worldKindExpression.name) : null
     }
   };
 }
@@ -60524,7 +60787,7 @@ function hasAnnotation(annotations, name) {
 function enumCase2(value) {
   return value.split(/[-_\s]+/).filter(Boolean).map((part) => `${part[0]?.toUpperCase() ?? ""}${part.slice(1)}`).join("");
 }
-function lowerFirst2(value) {
+function lowerFirst3(value) {
   return `${value[0]?.toLowerCase() ?? ""}${value.slice(1)}`;
 }
 function assertProjectIdentifier2(value, kind) {
@@ -71125,6 +71388,33 @@ function exportInitializerCollections(created, writes, ctx) {
   });
   return [...exported, ...extra];
 }
+function prepareSessionValueExport(ctx, checkpoint, writes) {
+  const created = createdSessionValuesSince(ctx, checkpoint);
+  if (created.length === 0) return;
+  const invocationWrites = ctx.__executionState?.writes ?? writes;
+  const exported = exportInitializerCollections(
+    created,
+    invocationWrites === writes || writes.length === 0 ? invocationWrites : [...invocationWrites, ...writes],
+    ctx
+  );
+  if (exported === created) return;
+  const replacements = /* @__PURE__ */ new Map();
+  for (const row of exported) {
+    const existing = ctx.__runtimeSessionValues?.get(row.id);
+    if (existing === void 0) registerRuntimeSessionValue(ctx, row);
+    else if (existing !== row) replacements.set(row.id, row);
+  }
+  return replacements;
+}
+function exportedSessionValuesSince(ctx, checkpoint, replacements) {
+  const created = createdSessionValuesSince(ctx, checkpoint);
+  if (replacements !== void 0) {
+    for (const [index, row] of created.entries()) {
+      created[index] = replacements.get(row.id) ?? row;
+    }
+  }
+  return created;
+}
 function evaluateNSGetter(getter, ctx) {
   return evaluateNSGetterWithEffects(getter, ctx).value;
 }
@@ -71189,19 +71479,20 @@ function evaluateNSGetterWithEffects(getter, ctx, argumentValues = [], options =
         const rootIndex = created.findIndex(
           (row) => row.value === result.value
         );
-        const exported = exportInitializerCollections(
+        const exported2 = exportInitializerCollections(
           created,
           writes,
           runtimeCtx
         );
-        if (exported !== created) {
-          for (const row of exported)
+        if (exported2 !== created) {
+          for (const row of exported2)
             registerRuntimeSessionValue(runtimeCtx, row);
           invalidateEvaluatorIndexes(runtimeCtx, null);
         }
-        const exportedRoot = exported[rootIndex];
+        const exportedRoot = exported2[rootIndex];
         if (exportedRoot !== void 0) result.value = exportedRoot.value;
       }
+      const exported = !options.exportInitializerValues && options.sessionValueExport !== "defer" ? prepareSessionValueExport(runtimeCtx, creationCheckpoint, writes) : void 0;
       finalizeConstructorAllocations(
         runtimeCtx,
         result.value,
@@ -71209,9 +71500,10 @@ function evaluateNSGetterWithEffects(getter, ctx, argumentValues = [], options =
         getter.typeInfo
       );
       result.value = preserveReadOnlyReturnIdentity(result.value, runtimeCtx);
-      const createdSessionValues = createdSessionValuesSince(
+      const createdSessionValues = exportedSessionValuesSince(
         runtimeCtx,
-        creationCheckpoint
+        creationCheckpoint,
+        exported
       );
       return createdSessionValues.length === 0 ? { value: result.value, writes } : { value: result.value, writes, createdSessionValues };
     }
@@ -71230,6 +71522,7 @@ function evaluateNSVoidBody(action, ctx) {
   consumeBudget(runtimeCtx, "workUnits", 1, "work unit");
   const creationCheckpoint = sessionCreationCheckpoint(runtimeCtx);
   const scope = createTopLevelScope(runtimeCtx);
+  let exported;
   try {
     const result = evalInstructions(action.instructions, scope, runtimeCtx, {
       allowFallthroughReturn: true,
@@ -71243,14 +71536,20 @@ function evaluateNSVoidBody(action, ctx) {
       }
     }
     rejectEscapedLoopTransfer(result, "NeoScript action");
+    exported = prepareSessionValueExport(
+      runtimeCtx,
+      creationCheckpoint,
+      writes
+    );
     finalizeConstructorAllocations(runtimeCtx, void 0, ownsInvocationState);
   } catch (error) {
     finalizeConstructorAllocations(runtimeCtx, void 0, ownsInvocationState);
     throw error;
   }
-  const createdSessionValues = createdSessionValuesSince(
+  const createdSessionValues = exportedSessionValuesSince(
     runtimeCtx,
-    creationCheckpoint
+    creationCheckpoint,
+    exported
   );
   return createdSessionValues.length === 0 ? { writes } : { writes, createdSessionValues };
 }
@@ -71262,6 +71561,7 @@ function evaluateNSFunction(action, ctx, args) {
   const creationCheckpoint = sessionCreationCheckpoint(runtimeCtx);
   const runtimeArgs = remapRuntimeArguments(args, runtimeCtx);
   let value;
+  let exported;
   try {
     value = executeCompiledFunction(
       action,
@@ -71269,6 +71569,11 @@ function evaluateNSFunction(action, ctx, args) {
       runtimeArgs,
       action.typeInfo.type === 0 /* Null */
     );
+    exported = prepareSessionValueExport(
+      runtimeCtx,
+      creationCheckpoint,
+      writes
+    );
     finalizeConstructorAllocations(
       runtimeCtx,
       value,
@@ -71279,9 +71584,10 @@ function evaluateNSFunction(action, ctx, args) {
     finalizeConstructorAllocations(runtimeCtx, void 0, ownsInvocationState);
     throw error;
   }
-  const createdSessionValues = createdSessionValuesSince(
+  const createdSessionValues = exportedSessionValuesSince(
     runtimeCtx,
-    creationCheckpoint
+    creationCheckpoint,
+    exported
   );
   return createdSessionValues.length === 0 ? { value, writes } : { value, writes, createdSessionValues };
 }
@@ -74517,10 +74823,15 @@ function dispatchNSGetterById(memberId, receiver, ctx) {
   }
   const innerStack = new Set(stack);
   innerStack.add(memberId);
-  return evaluateNSGetter(getter, {
-    ...bindThisValue(ctx, receiver),
-    __getterCallStack: innerStack
-  });
+  return evaluateNSGetterWithEffects(
+    getter,
+    {
+      ...bindThisValue(ctx, receiver),
+      __getterCallStack: innerStack
+    },
+    [],
+    { sessionValueExport: "defer" }
+  ).value;
 }
 function resolveCompiledGetter(memberId, ctx) {
   const cache = evaluatorResolutionCache(ctx).compiledGetterByMemberId;
@@ -77846,7 +78157,10 @@ function evaluateInitializerInContext(init, member, ctx, createdValues, argument
       compiled,
       initializerCtx,
       argumentValues,
-      { initializerResult: { member, genericEnv } }
+      {
+        initializerResult: { member, genericEnv },
+        sessionValueExport: "defer"
+      }
     );
   } finally {
     closeFrame();
@@ -79784,15 +80098,22 @@ 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(
-        argument2.id,
-        (constructorArgumentReferenceCounts.get(argument2.id) ?? 0) + 1
-      );
+  const constructorArgumentCandidates = evaluatorValues(ctx);
+  let constructorArgumentReferenceCounts = null;
+  function constructorArgumentReferenceCount(valueId) {
+    if (constructorArgumentReferenceCounts === null) {
+      constructorArgumentReferenceCounts = /* @__PURE__ */ new Map();
+      for (const candidate of constructorArgumentCandidates) {
+        for (const argument2 of ownedConstructorArgumentValues(candidate, ctx)) {
+          constructorArgumentReferenceCounts.set(
+            argument2.id,
+            (constructorArgumentReferenceCounts.get(argument2.id) ?? 0) + 1
+          );
+        }
+      }
     }
+    return constructorArgumentReferenceCounts.get(valueId) ?? 0;
   }
   function cloneInitializerRow(sourceRow, sourceMember, id2, clonedContainerId, sourceTypeInfo) {
     if (sourceMember === null) {
@@ -79985,7 +80306,6 @@ function cloneClassValueGraph(receiver, expectedClassId, ctx) {
           constructorArgs[argument2.parameterId] = alreadyCloned.id;
           continue;
         }
-        if (constructorArgumentReferenceCounts.get(argument2.id) !== 1) continue;
         const argumentRow = evalValueById(
           ctx,
           argument2.id,
@@ -79996,6 +80316,7 @@ function cloneClassValueGraph(receiver, expectedClassId, ctx) {
         if (activeStaticBindingRoot(argument2.id, ctx) !== null || memberForValueRow(argumentRow, ctx) !== null) {
           continue;
         }
+        if (constructorArgumentReferenceCount(argument2.id) !== 1) continue;
         constructorArgs[argument2.parameterId] = cloneRow2(
           argumentRow,
           null,
@@ -82937,7 +83258,7 @@ function rewriteExpandedRow(node, expansion) {
   const rewrite = (id2) => expansion.nodesByExpandedId.get(id2)?.virtualId ?? id2;
   const row = cloneRow(node.expandedRow);
   row.id = node.virtualId;
-  if (isMemberClassBase(node.member) || isMemberDictionaryBase(node.member)) {
+  if (row.value !== null && (isMemberClassBase(node.member) || isMemberDictionaryBase(node.member))) {
     row.value = Object.fromEntries(
       Object.entries(stringRecord2(row.value)).map(([key, childId]) => [
         key,
@@ -96056,176 +96377,6 @@ function orderLocalizedTextWritesBesideLinks(prepared) {
   });
   return ordered;
 }
-function planProjectVersionTransaction(changes, atomicGroups, options = {}) {
-  if (changes.length === 0) {
-    throw new Error("A project-version transaction plan requires changes.");
-  }
-  if (options.basePayloadBytes !== void 0 && options.basePayloadBytes.length !== changes.length)
-    throw new Error("Transaction base payload sizes must cover every change.");
-  const changeCosts = changes.map(
-    (change, index) => estimateProjectVersionChangeCost(change, options.basePayloadBytes?.[index])
-  );
-  const groups = normalizeAtomicGroups(changes.length, atomicGroups);
-  let totalEstimatedCost = changeCosts.reduce(
-    addProjectVersionTransactionBudgets,
-    IMMEDIATE_FIXED_COST
-  );
-  if (changes.some(projectVersionChangeCanTriggerWholeGraphValidation)) {
-    totalEstimatedCost = addProjectVersionTransactionBudgets(
-      totalEstimatedCost,
-      WHOLE_GRAPH_VALIDATION_SURCHARGE
-    );
-  }
-  const limitingResource = firstExceededResource(
-    totalEstimatedCost,
-    PROJECT_TRANSACTION_IMMEDIATE_BUDGET
-  );
-  if (limitingResource === null && options.forceAsync !== true) {
-    return {
-      path: "immediate",
-      limitingResource: null,
-      totalEstimatedCost,
-      chunks: [
-        {
-          firstChangeIndex: 0,
-          changeCount: changes.length,
-          estimatedCost: totalEstimatedCost
-        }
-      ]
-    };
-  }
-  const stagedChangeCosts = changes.map((change, index) => {
-    const cost = changeCosts[index];
-    const receiptBytes = 2 * KIB + new TextEncoder().encode(change.recordId).byteLength;
-    return addProjectVersionTransactionBudgets(cost, {
-      ...EMPTY_BUDGET,
-      bytesRead: receiptBytes,
-      bytesWritten: receiptBytes,
-      documentsRead: 1,
-      documentsWritten: 1,
-      databaseQueries: 1,
-      indexRanges: 1
-    });
-  });
-  const chunks = [];
-  let firstChangeIndex = 0;
-  let chunkCost = CHUNK_FIXED_COST;
-  let changeCount = 0;
-  for (const group of groups) {
-    const groupCost = stagedChangeCosts.slice(group.firstChangeIndex, group.firstChangeIndex + group.changeCount).reduce(addProjectVersionTransactionBudgets, EMPTY_BUDGET);
-    const nativeExceeded = firstExceededResource(
-      addProjectVersionTransactionBudgets(CHUNK_FIXED_COST, groupCost),
-      PROJECT_TRANSACTION_SINGLE_CHANGE_NATIVE_BUDGET
-    );
-    if (nativeExceeded !== null) {
-      throw new Error(
-        `Project-version atomic group starting at change ${group.firstChangeIndex} (${group.changeCount} changes) exceeds the native worker budget for ${nativeExceeded}.`
-      );
-    }
-    const nextCost = addProjectVersionTransactionBudgets(chunkCost, groupCost);
-    const exceeded = firstExceededResource(
-      nextCost,
-      PROJECT_TRANSACTION_WORKER_BUDGET
-    );
-    if (exceeded !== null && changeCount > 0) {
-      chunks.push({ firstChangeIndex, changeCount, estimatedCost: chunkCost });
-      firstChangeIndex = group.firstChangeIndex;
-      changeCount = 0;
-      chunkCost = CHUNK_FIXED_COST;
-    }
-    chunkCost = addProjectVersionTransactionBudgets(chunkCost, groupCost);
-    changeCount += group.changeCount;
-  }
-  if (changeCount > 0) {
-    chunks.push({ firstChangeIndex, changeCount, estimatedCost: chunkCost });
-  }
-  return {
-    path: "asynchronous",
-    limitingResource,
-    totalEstimatedCost,
-    chunks
-  };
-}
-function projectVersionChangeCanTriggerWholeGraphValidation(change) {
-  if (change.recordKind === "enum" || change.recordKind === "member" || change.recordKind === "project" || change.recordKind === "internal-record-relation") {
-    return true;
-  }
-  if (change.recordKind === "class") return change.operation !== "create";
-  if (change.recordKind !== "value") return false;
-  if (change.operation === "delete") return true;
-  return valueChangeCarriesWorldLayerOverride(change);
-}
-function valueChangeCarriesWorldLayerOverride(change) {
-  const nextData = change.nextData;
-  if (nextData === null || typeof nextData !== "object") return false;
-  if (Array.isArray(nextData)) return false;
-  const value = nextData.value;
-  if (value === null || typeof value !== "object") return false;
-  if (Array.isArray(value)) return false;
-  return typeof value.layerOverrideValueId === "string";
-}
-function normalizeAtomicGroups(changeCount, groups) {
-  if (groups === void 0) {
-    return Array.from({ length: changeCount }, (_, firstChangeIndex) => ({
-      firstChangeIndex,
-      changeCount: 1
-    }));
-  }
-  let nextChangeIndex = 0;
-  for (const group of groups) {
-    if (!Number.isSafeInteger(group.firstChangeIndex) || !Number.isSafeInteger(group.changeCount) || group.firstChangeIndex !== nextChangeIndex || group.changeCount < 1) {
-      throw new Error(
-        "Project-version atomic groups must be positive, ordered, and contiguous."
-      );
-    }
-    nextChangeIndex += group.changeCount;
-  }
-  if (nextChangeIndex !== changeCount) {
-    throw new Error(
-      `Project-version atomic groups cover ${nextChangeIndex}/${changeCount} changes.`
-    );
-  }
-  return [...groups];
-}
-function estimateProjectVersionChangeCost(change, basePayloadBytes) {
-  const encoded = canonicalJsonStringify(change);
-  const payloadBytes = new TextEncoder().encode(encoded).byteLength;
-  const hasBase = change.operation !== "create";
-  if (basePayloadBytes !== void 0 && (!Number.isSafeInteger(basePayloadBytes) || basePayloadBytes < 0))
-    throw new Error(
-      "Transaction base payload size must be a nonnegative byte count."
-    );
-  const baseBytes = hasBase ? basePayloadBytes ?? payloadBytes : 0;
-  const nextStoredBytes = change.operation === "delete" ? baseBytes : payloadBytes;
-  const counts = changeCountCost(change);
-  return {
-    argumentBytes: payloadBytes + 128,
-    bytesRead: payloadBytes + 2 * baseBytes + CHANGE_BYTES_READ_OVERHEAD,
-    // Live records appear in the snapshot, result data, result snapshot and diff.
-    bytesWritten: (change.operation === "delete" ? 2 * baseBytes + payloadBytes : 4 * nextStoredBytes) + CHANGE_BYTES_WRITTEN_OVERHEAD,
-    documentsRead: counts.documentsRead,
-    documentsWritten: counts.documentsWritten,
-    databaseQueries: counts.databaseQueries,
-    // Not metered by Convex: `TransactionMetrics` reports seven dimensions and
-    // this is not one of them, so it cannot be measured the way the others
-    // were. Every index range a change opens is also a database query, so the
-    // measured query count is a strict upper bound on it. Charging exactly
-    // that keeps the dimension a true bound instead of an invented number,
-    // and keeps it dominated by `databaseQueries` rather than silently
-    // becoming the binding constraint on a well-measured plan.
-    indexRanges: counts.databaseQueries,
-    functionsScheduled: 0,
-    scheduledFunctionArgsBytes: 0,
-    // Deleted result rows still carry the complete tombstone snapshot.
-    returnBytes: (change.operation === "delete" ? baseBytes : 2 * nextStoredBytes) + 512
-  };
-}
-function changeCountCost(change) {
-  if (change.recordKind === "value") {
-    return VALUE_CHANGE_COUNT_COSTS[change.operation];
-  }
-  return SCHEMA_CHANGE_COUNT_COSTS[change.operation];
-}
 function addProjectVersionTransactionBudgets(left, right) {
   return {
     argumentBytes: left.argumentBytes + right.argumentBytes,
@@ -96240,15 +96391,7 @@ function addProjectVersionTransactionBudgets(left, right) {
     returnBytes: left.returnBytes + right.returnBytes
   };
 }
-function firstExceededResource(cost, target) {
-  for (const resource of Object.keys(
-    EMPTY_BUDGET
-  )) {
-    if (cost[resource] > target[resource]) return resource;
-  }
-  return null;
-}
-var KIB, MIB, PROJECT_TRANSACTION_CHUNK_PAYLOAD_TARGET_BYTES, PROJECT_TRANSACTION_IMMEDIATE_BUDGET, PROJECT_TRANSACTION_WORKER_BUDGET, PROJECT_TRANSACTION_SINGLE_CHANGE_NATIVE_BUDGET, EMPTY_BUDGET, CHUNK_GRAPH_VALIDATION_RESERVE, CHUNK_FIXED_COST, IMMEDIATE_FIXED_COST, WHOLE_GRAPH_VALIDATION_SURCHARGE, VALUE_CHANGE_COUNT_COSTS, SCHEMA_CHANGE_COUNT_COSTS, CHANGE_BYTES_READ_OVERHEAD, CHANGE_BYTES_WRITTEN_OVERHEAD;
+var KIB, MIB, PROJECT_TRANSACTION_CHUNK_PAYLOAD_TARGET_BYTES, PROJECT_TRANSACTION_IMMEDIATE_BUDGET, PROJECT_TRANSACTION_WORKER_BUDGET, PROJECT_TRANSACTION_SINGLE_CHANGE_NATIVE_BUDGET, EMPTY_BUDGET, CHUNK_GRAPH_VALIDATION_RESERVE, CHUNK_FIXED_COST, IMMEDIATE_FIXED_COST, WHOLE_GRAPH_VALIDATION_SURCHARGE, CHANGE_BYTES_READ_OVERHEAD, CHANGE_BYTES_WRITTEN_OVERHEAD;
 var init_project_version_transaction_planning = __esm({
   "../src/database/project-version-transaction-planning.ts"() {
     "use strict";
@@ -96340,16 +96483,6 @@ var init_project_version_transaction_planning = __esm({
       databaseQueries: 410,
       indexRanges: 410
     };
-    VALUE_CHANGE_COUNT_COSTS = {
-      create: { documentsRead: 3, documentsWritten: 3, databaseQueries: 8 },
-      update: { documentsRead: 6, documentsWritten: 3, databaseQueries: 9 },
-      delete: { documentsRead: 6, documentsWritten: 3, databaseQueries: 14 }
-    };
-    SCHEMA_CHANGE_COUNT_COSTS = {
-      create: { documentsRead: 9, documentsWritten: 7, databaseQueries: 9 },
-      update: { documentsRead: 6, documentsWritten: 5, databaseQueries: 22 },
-      delete: { documentsRead: 6, documentsWritten: 5, databaseQueries: 22 }
-    };
     CHANGE_BYTES_READ_OVERHEAD = 4 * KIB;
     CHANGE_BYTES_WRITTEN_OVERHEAD = 4 * KIB;
   }
@@ -101603,12 +101736,12 @@ var init_animation_clips = __esm({
        * fix.
        */
       validateStructuredLeafPartial(args) {
-        const memberPath2 = args.path.join(".");
+        const memberPath3 = args.path.join(".");
         const prefix = `Animation clip "${args.clipName}" frame ${args.frameIndex}`;
         const kind = args.member.kind;
         if (!isStructuredLeafKind(kind)) {
           throw new Error(
-            `${prefix} member "${memberPath2}" is of kind ${MemberKind[kind]}, which has no addressable fields, so it cannot take a "${STRUCTURED_LEAF_PARTIAL_KEY}" field override.`
+            `${prefix} member "${memberPath3}" is of kind ${MemberKind[kind]}, which has no addressable fields, so it cannot take a "${STRUCTURED_LEAF_PARTIAL_KEY}" field override.`
           );
         }
         const kindLabel = MemberKind[kind];
@@ -101617,7 +101750,7 @@ var init_animation_clips = __esm({
           args.member.id
         ])) {
           throw new Error(
-            `${prefix} ${kindLabel} member "${memberPath2}" cannot take a "${STRUCTURED_LEAF_PARTIAL_KEY}" field override; member "${args.member.name}" is not a writable Save/Session override leaf.`
+            `${prefix} ${kindLabel} member "${memberPath3}" cannot take a "${STRUCTURED_LEAF_PARTIAL_KEY}" field override; member "${args.member.name}" is not a writable Save/Session override leaf.`
           );
         }
         const violation = structuredLeafPartialViolation(
@@ -101626,14 +101759,14 @@ var init_animation_clips = __esm({
           kindLabel
         );
         if (violation !== null) {
-          throw new Error(`${prefix} member "${memberPath2}" ${violation}.`);
+          throw new Error(`${prefix} member "${memberPath3}" ${violation}.`);
         }
         const resolution = this.resolveDefinitionChildResolution(
           args.definitionNode,
           args.schemaKey,
           args.member
         );
-        const descent = `${prefix} cannot descend into ${kindLabel} member "${memberPath2}"`;
+        const descent = `${prefix} cannot descend into ${kindLabel} member "${memberPath3}"`;
         if (resolution.node === null) {
           if (resolution.absence.reason === "nullDefault") {
             throw new Error(
@@ -106922,111 +107055,6 @@ var init_value_record_comparison = __esm({
   }
 });
 
-// src/project-source/lower-support.ts
-function identityMap(declarations, kind) {
-  return new Map(
-    declarations.map((declaration) => [
-      declaration.name,
-      materializedId(declaration, kind, declaration.name)
-    ])
-  );
-}
-function sourceIdentity2(identity2, kind, name) {
-  const sourceSpan = span(identity2);
-  return {
-    symbolId: `${kind}:${materializedIdentityId(identity2, kind, name)}`,
-    kind,
-    span: sourceSpan,
-    selectionSpan: sourceSpan
-  };
-}
-function span(identity2) {
-  return {
-    path: identity2.source.uri,
-    start: { ...identity2.source.range.start },
-    end: { ...identity2.source.range.end }
-  };
-}
-function materializedId(identity2, kind, name) {
-  return materializedIdentityId(identity2, kind, name);
-}
-function materializedIdentityId(identity2, kind, name) {
-  return identity2.id ?? `__pending__:${kind}:${encodeURIComponent(identity2.source.uri)}:${identity2.source.range.start.line}:${identity2.source.range.start.character}:${encodeURIComponent(name)}`;
-}
-function expressionArguments(expression) {
-  const result = /* @__PURE__ */ new Map();
-  expression.args.forEach((entry, index) => {
-    const name = expression.argumentNames?.[index] ?? null;
-    if (name === null) {
-      throw new Error(
-        "Project configuration constructors require named arguments."
-      );
-    }
-    if (result.has(name)) {
-      throw new Error(
-        `Constructor argument ${JSON.stringify(name)} is duplicated.`
-      );
-    }
-    result.set(name, entry);
-  });
-  return result;
-}
-function annotation(annotations, name) {
-  return annotations.find((entry) => entry.name === name);
-}
-function argument(value, name) {
-  return value?.arguments.find((entry) => entry.name === name)?.expression ?? null;
-}
-function parseAnnotationExpression(value) {
-  return parseExpression(value);
-}
-function stringArgument(value, name) {
-  const raw = argument(value, name);
-  if (raw === null) return null;
-  const expression = parseAnnotationExpression(raw);
-  return expression.kind === "litString" ? expression.value : null;
-}
-function contextualEnumArgument(value, name) {
-  const raw = argument(value, name);
-  if (raw === null) return null;
-  const expression = parseAnnotationExpression(raw);
-  return expression.kind === "contextualEnum" ? expression.name : null;
-}
-function systemMetadata(annotations) {
-  const system = annotation(annotations, "system");
-  if (!system) return null;
-  const kind = contextualEnumArgument(system, "kind");
-  if (kind === null) {
-    throw new Error("@system requires a kind inferred enum argument.");
-  }
-  const worldKind = contextualEnumArgument(system, "worldKind");
-  return {
-    kind: lowerFirst3(kind),
-    worldKind: worldKind ? lowerFirst3(worldKind) : null
-  };
-}
-function requiredName2(values, name, kind) {
-  const value = values.get(name);
-  if (!value) throw new Error(`Unknown ${kind} ${JSON.stringify(name)}.`);
-  return value;
-}
-function lowerFirst3(value) {
-  return value.length ? `${value[0].toLowerCase()}${value.slice(1)}` : value;
-}
-function indexFirstById(values) {
-  const result = /* @__PURE__ */ new Map();
-  for (const value of values) {
-    if (!result.has(value.id)) result.set(value.id, value);
-  }
-  return result;
-}
-var init_lower_support = __esm({
-  "src/project-source/lower-support.ts"() {
-    "use strict";
-    init_src();
-  }
-});
-
 // src/project-source/lower-configuration.ts
 function lowerConfiguration(base, analysis) {
   const globals = analysis.configuration.globals;
@@ -107978,7 +108006,7 @@ function nullableStatusConstructorArgument(argumentsValue, name, fallback, statu
 }
 function resolveStatusExpression(expression, statusIdsByName) {
   if (expression.kind === "ident") {
-    return requiredName2(
+    return requiredName(
       statusIdsByName,
       expression.name,
       "localization status"
@@ -108054,6 +108082,200 @@ var init_lower_configuration = __esm({
   }
 });
 
+// src/project-source/initializer-reference-spellings.ts
+function sourceOffsetAt(source, pos) {
+  let offset = 0;
+  for (let line = 1; line < pos.line; line += 1) {
+    const next = source.indexOf("\n", offset);
+    if (next < 0) return null;
+    offset = next + 1;
+  }
+  return Math.min(offset + pos.column - 1, source.length);
+}
+function settleInitializerReferenceSpellings(code, settle) {
+  const splices = [];
+  const pending = [parseExpression(code)];
+  while (pending.length > 0) {
+    const node = pending.pop();
+    switch (node.kind) {
+      case "call": {
+        const target = settle(node);
+        if (target === null) {
+          pending.push(node.callee, ...node.args);
+          break;
+        }
+        const start = sourceOffsetAt(code, node.callee.pos);
+        const end = start === null ? null : referenceCallEnd(code, start);
+        if (start === null || end === null) break;
+        splices.push({
+          start,
+          end,
+          text: `Reference<${target.typeName}>(id: ${JSON.stringify(target.id)})`
+        });
+        break;
+      }
+      case "annotated":
+        pending.push(node.expression);
+        break;
+      case "new":
+        pending.push(...node.args);
+        for (const entry of node.initializer ?? []) pending.push(entry.value);
+        break;
+      case "litList":
+        pending.push(...node.elements);
+        break;
+      case "litDict":
+        for (const entry of node.entries) pending.push(entry.value);
+        break;
+      case "member":
+        pending.push(node.receiver);
+        break;
+      case "index":
+        pending.push(node.receiver, node.index);
+        break;
+      case "binary":
+      case "coalesce":
+        pending.push(node.left, node.right);
+        break;
+      case "conditional":
+        pending.push(node.condition, node.whenTrue, node.whenFalse);
+        break;
+      case "unary":
+      case "force":
+      case "is":
+        pending.push(node.operand);
+        break;
+    }
+  }
+  if (splices.length === 0) return code;
+  splices.sort((left, right) => right.start - left.start);
+  let settled = code;
+  for (const splice of splices) {
+    settled = settled.slice(0, splice.start) + splice.text + settled.slice(splice.end);
+  }
+  return settled;
+}
+function referenceCallEnd(code, start) {
+  const open = code.indexOf("(", start);
+  if (open < 0) return null;
+  let depth = 0;
+  let quoted = null;
+  for (let index = open; index < code.length; index += 1) {
+    const character = code[index];
+    if (quoted !== null) {
+      if (character === "\\") index += 1;
+      else if (character === quoted) quoted = null;
+      continue;
+    }
+    if (character === '"' || character === "'") quoted = character;
+    else if (character === "(") depth += 1;
+    else if (character === ")") {
+      depth -= 1;
+      if (depth === 0) return index + 1;
+    }
+  }
+  return null;
+}
+function memberValueIdV4(memberId) {
+  return isPendingId(memberId) ? pendingMemberValueId(memberId) : derivedMemberValueId(memberId);
+}
+function referencedSymbolPath(call) {
+  if (call.callee.kind !== "ident" || call.callee.name !== "Reference") {
+    return null;
+  }
+  if ((call.typeArguments?.length ?? 0) > 1) return null;
+  if (call.args.length !== 1) return null;
+  if (typeof call.argumentNames?.[0] === "string") return null;
+  const path = memberPath(call.args[0]);
+  if (path === null) return null;
+  const typeArgument = call.typeArguments?.[0];
+  return {
+    path,
+    genericTypeName: typeArgument === void 0 ? null : astTypeNameV4(typeArgument)
+  };
+}
+function memberPath(expression) {
+  if (expression.kind === "ident") return expression.name;
+  if (expression.kind !== "member") return null;
+  const receiver = memberPath(expression.receiver);
+  return receiver === null ? null : `${receiver}.${expression.name}`;
+}
+function unidentifiedLocalReferenceError(name) {
+  return new Error(
+    `Reference(${name}) inside a constructed initializer needs ${name} to carry an @id. Push the declaration of ${name} first, then reference it.`
+  );
+}
+function createSchemaInitializerReferenceSettlerV4(args) {
+  let sourceStatics = null;
+  const readSourceStatics = () => {
+    if (sourceStatics !== null) return sourceStatics;
+    const statics = /* @__PURE__ */ new Map();
+    for (const sourceClass of args.analysis.schema.classes) {
+      for (const declaration of sourceClass.members) {
+        if (!declaration.modifiers.includes("static")) continue;
+        if (declaration.kind !== "field") continue;
+        const path = `${sourceClass.name}.${declaration.name}`;
+        statics.set(path, {
+          memberId: materializedId(declaration, "member", path),
+          typeName: declaration.type.name
+        });
+      }
+    }
+    sourceStatics = statics;
+    return statics;
+  };
+  const staticValueId = (path, memberId) => args.staticValueIdsBySymbol.get(path) ?? memberValueIdV4(memberId);
+  const settle = (call) => {
+    const spelled = referencedSymbolPath(call);
+    if (spelled === null) return null;
+    if (args.localValues.has(spelled.path)) {
+      const declared = args.localValues.declaredTarget(spelled.path);
+      if (declared === null)
+        throw unidentifiedLocalReferenceError(spelled.path);
+      const typeName2 = spelled.genericTypeName ?? declared.typeName;
+      if ("id" in declared) return { id: declared.id, typeName: typeName2 };
+      return {
+        id: staticValueId(declared.ownerPath, declared.ownerMemberId),
+        typeName: typeName2
+      };
+    }
+    const source = readSourceStatics().get(spelled.path);
+    if (source !== void 0) {
+      return {
+        id: staticValueId(spelled.path, source.memberId),
+        typeName: spelled.genericTypeName ?? source.typeName
+      };
+    }
+    const stored = args.staticValueIdsBySymbol.get(spelled.path);
+    if (stored === void 0) return null;
+    const typeName = spelled.genericTypeName ?? storedStaticTypeName(args.manifest, spelled.path);
+    return typeName === null ? null : { id: stored, typeName };
+  };
+  return (code) => settleInitializerReferenceSpellings(code, settle);
+}
+function storedStaticTypeName(manifest, path) {
+  const separator = path.lastIndexOf(".");
+  if (separator < 0) return null;
+  const className = path.slice(0, separator);
+  const memberName = path.slice(separator + 1);
+  const schemaClass2 = manifest.classes.find(
+    (entry) => entry.name === className
+  );
+  const memberId = schemaClass2?.schema[memberName];
+  const member = manifest.members.find((entry) => entry.id === memberId);
+  if (member?.kind !== "class") return null;
+  return manifest.classes.find((entry) => entry.id === member.classId)?.name ?? null;
+}
+var init_initializer_reference_spellings = __esm({
+  "src/project-source/initializer-reference-spellings.ts"() {
+    "use strict";
+    init_member_value_id();
+    init_src();
+    init_key_reference_spelling();
+    init_lower_support();
+  }
+});
+
 // ../src/models/members/required-constructor-id.ts
 function derivedRequiredConstructorId(classId) {
   return inSystemRecordNamespaceOf(
@@ -108506,9 +108728,9 @@ function lowerClass(context, declaration) {
   if (classBases.length > 1) {
     throw new Error(`Class ${declaration.name} has more than one Class base.`);
   }
-  const extendsClassId = classBases[0] ? requiredName2(context.classIdsByName, classBases[0].name, "class") : null;
+  const extendsClassId = classBases[0] ? requiredName(context.classIdsByName, classBases[0].name, "class") : null;
   const implementsInterfaceIds = declaration.baseTypes.filter((type) => context.interfaceIdsByName.has(type.name)).map(
-    (type) => requiredName2(context.interfaceIdsByName, type.name, "interface")
+    (type) => requiredName(context.interfaceIdsByName, type.name, "interface")
   );
   const schema = {};
   const schemaKeyOrder = [];
@@ -109141,7 +109363,7 @@ function lowerFieldMember(context, ownerClass, declaration, id2, commonInput, ba
       entryMemberId: entryId,
       key: keyType.name === "string" ? { kind: "string" } : {
         kind: "enum",
-        enumId: requiredName2(context.enumIdsByName, keyType.name, "enum")
+        enumId: requiredName(context.enumIdsByName, keyType.name, "enum")
       }
     };
   }
@@ -109201,7 +109423,7 @@ function inheritedMember(context, memberId) {
 function lowerListIndexes(ownerClass, declaration) {
   const declared = /* @__PURE__ */ new Set();
   return declaration.annotations.filter((entry) => entry.name === "index").map((entry) => {
-    const schemaKey = memberKeyArgument2(entry, ownerClass, declaration);
+    const schemaKey = memberKeyArgument(entry, ownerClass, declaration);
     if (declared.has(schemaKey)) {
       throw new Error(
         `@index(member: ${schemaKey}) is declared more than once on ${ownerClass.name}.${declaration.name}.`
@@ -109217,7 +109439,7 @@ function lowerListIndexes(ownerClass, declaration) {
 function lowerListColumns(ownerClass, declaration) {
   const declared = /* @__PURE__ */ new Set();
   return declaration.annotations.filter((entry) => entry.name === "column").map((entry) => {
-    const memberKey = memberKeyArgument2(entry, ownerClass, declaration);
+    const memberKey = memberKeyArgument(entry, ownerClass, declaration);
     if (declared.has(memberKey)) {
       throw new Error(
         `@column(member: ${memberKey}) is declared more than once on ${ownerClass.name}.${declaration.name}.`
@@ -109236,7 +109458,7 @@ function lowerListColumns(ownerClass, declaration) {
     };
   });
 }
-function memberKeyArgument2(value, ownerClass, declaration) {
+function memberKeyArgument(value, ownerClass, declaration) {
   const positional = value.arguments[0];
   const raw = argument(value, "member") ?? (positional !== void 0 && positional.name === void 0 ? positional.expression : null);
   if (raw === null) {
@@ -109498,7 +109720,7 @@ function lowerInterface(context, declaration) {
     ...declaration.docsText === void 0 ? {} : { docsText: declaration.docsText },
     members,
     extendsInterfaceIds: declaration.baseTypes.map(
-      (type) => requiredName2(context.interfaceIdsByName, type.name, "interface")
+      (type) => requiredName(context.interfaceIdsByName, type.name, "interface")
     ),
     system: systemMetadata(declaration.annotations) ?? base?.system ?? null
   };
@@ -109595,7 +109817,7 @@ function lowerType(context, type, ownerClass) {
       kind: "dictionary",
       nullable: nullable2,
       entryType: lowerType(context, requiredTypeArgument(type, 1), ownerClass),
-      keyEnumId: key.name === "string" ? null : requiredName2(context.enumIdsByName, key.name, "enum"),
+      keyEnumId: key.name === "string" ? null : requiredName(context.enumIdsByName, key.name, "enum"),
       readOnly: false
     };
   }
@@ -109675,7 +109897,13 @@ function lowerDefault(context, initializer, type, ownerClass, base, memberId, st
   }
   const expression = parseExpression(initializer);
   if (positionRequiresEvaluation(context, expression, type, ownerClass)) {
-    return { init: { code: normalizeInitializerSource(initializer) } };
+    return {
+      init: {
+        code: context.settleInitializerReferences(
+          normalizeInitializerSource(initializer)
+        )
+      }
+    };
   }
   if (context.rowBackedDefaultMemberIds.has(memberId) && base?.defaultValue && !("serverValueId" in base.defaultValue)) {
     return base.defaultValue;
@@ -110000,7 +110228,7 @@ function lowerExpressionValue(context, expression, declaredExpected, ownerClass,
         );
       }
       const className = explicitPartial ? expectedType.name : expression.className ?? expectedType.name;
-      const classId = requiredName2(context.classIdsByName, className, "class");
+      const classId = requiredName(context.classIdsByName, className, "class");
       const innerEnvironment = constructedGenericEnvironment(
         context,
         classId,
@@ -110180,15 +110408,6 @@ function isStoredActionLiteral(type, expression) {
   while (current.kind === "annotated") current = current.expression;
   return current.kind === "litList";
 }
-function sourceOffsetAt(source, pos) {
-  let offset = 0;
-  for (let line = 1; line < pos.line; line += 1) {
-    const next = source.indexOf("\n", offset);
-    if (next < 0) return null;
-    offset = next + 1;
-  }
-  return Math.min(offset + pos.column - 1, source.length);
-}
 function lambdaExpressionSource(source, lambda) {
   const start = sourceOffsetAt(source, lambda.pos);
   if (start === null) return null;
@@ -110668,14 +110887,14 @@ function genericConstraint(context, ownerClass, parameterId, type, baseConstrain
   }
   return {
     kind: "enum",
-    enumId: requiredName2(context.enumIdsByName, type.name, "enum")
+    enumId: requiredName(context.enumIdsByName, type.name, "enum")
   };
 }
 function inheritedMemberId(context, ownerClass, name) {
   const directBase = ownerClass.baseTypes.find(
     (entry) => context.classIdsByName.has(entry.name)
   );
-  const classId = directBase ? requiredName2(context.classIdsByName, directBase.name, "class") : null;
+  const classId = directBase ? requiredName(context.classIdsByName, directBase.name, "class") : null;
   return effectiveMemberIdByName(context, classId, name);
 }
 function effectiveMemberIdByName(context, startClassId, name) {
@@ -110698,7 +110917,7 @@ function effectiveMemberIdByName(context, startClassId, name) {
       const sourceBase = sourceClass.baseTypes.find(
         (entry) => context.classIdsByName.has(entry.name)
       );
-      classId = sourceBase ? requiredName2(context.classIdsByName, sourceBase.name, "class") : null;
+      classId = sourceBase ? requiredName(context.classIdsByName, sourceBase.name, "class") : null;
       continue;
     }
     const pulledClass = context.baseClasses.get(classId);
@@ -111014,6 +111233,7 @@ var UNSET_LIST_COLUMN_WIDTH, EMPTY_GENERIC_TYPE_ENVIRONMENT, DICTIONARY_KEY_TYPE
 var init_lower_members = __esm({
   "src/project-source/lower-members.ts"() {
     "use strict";
+    init_initializer_reference_spellings();
     init_src();
     init_src2();
     init_lower_support();
@@ -111218,7 +111438,7 @@ function genericRelationEndpoint(context, expression, relationKind, side, prior)
     }
     return {
       recordKind: "class",
-      recordId: requiredName2(context.classIdsByName, expression.name, "class")
+      recordId: requiredName(context.classIdsByName, expression.name, "class")
     };
   }
   if (expression.kind === "member" && expression.receiver.kind === "ident" && expected === "value") {
@@ -111326,7 +111546,7 @@ function relationExpressionIdentity(expression) {
 }
 function relationTargetClassId(context, expression) {
   if (expression.kind === "ident") {
-    return requiredName2(context.classIdsByName, expression.name, "class");
+    return requiredName(context.classIdsByName, expression.name, "class");
   }
   if (expression.kind === "call" && expression.callee.kind === "ident" && expression.callee.name === "Reference") {
     const index = expression.argumentNames?.findIndex((name) => name === "id") ?? -1;
@@ -111374,7 +111594,7 @@ function lowerVariants(context, analysis) {
   );
   const variants = variantGlobals(analysis).map((global) => {
     const className = owningClassName(global);
-    const classId = requiredName2(context.classIdsByName, className, "class");
+    const classId = requiredName(context.classIdsByName, className, "class");
     const variantId = variantRecordId(global, global.type.name);
     return {
       id: variantId,
@@ -111406,7 +111626,7 @@ function variantValueBindingsV4(manifest, analysis) {
         targetClassId: variant2.classId,
         targetClassName: requiredClassName2(classNames, variant2.classId),
         variantTypeName: global.type.name,
-        valueClassId: global.type.name === NEO_LOOKUP_VARIANT_TYPE_NAME ? requiredName2(
+        valueClassId: global.type.name === NEO_LOOKUP_VARIANT_TYPE_NAME ? requiredName(
           new Map(
             manifest.classes.map((entry) => [entry.name, entry.id])
           ),
@@ -111441,7 +111661,7 @@ function lowerVariantFolders(context, analysis) {
     return {
       id: variantRecordId(global, NEO_VARIANT_FOLDER_TYPE_NAME),
       source: sourceIdentity2(global, "variantFolder", global.name),
-      classId: requiredName2(context.classIdsByName, className, "class"),
+      classId: requiredName(context.classIdsByName, className, "class"),
       path: folderPath2(global),
       binding: folderBinding(context, global)
     };
@@ -111641,6 +111861,7 @@ var init_lower_variants = __esm({
 // src/project-source/lower-schema.ts
 function lowerProjectSchemaV4(base, analysis, options = {}) {
   const classIdsByName = identityMap(analysis.schema.classes, "class");
+  const staticValueIdsBySymbol3 = options.staticValueIdsBySymbol ?? /* @__PURE__ */ new Map();
   const interfaceIdsByName = identityMap(
     analysis.schema.interfaces,
     "interface"
@@ -111716,7 +111937,17 @@ function lowerProjectSchemaV4(base, analysis, options = {}) {
     loweredMembers: /* @__PURE__ */ new Map(),
     entryTypesByEntryId: /* @__PURE__ */ new Map(),
     placements: /* @__PURE__ */ new Map(),
-    staticValueIdsBySymbol: options.staticValueIdsBySymbol ?? /* @__PURE__ */ new Map(),
+    staticValueIdsBySymbol: staticValueIdsBySymbol3,
+    settleInitializerReferences: createSchemaInitializerReferenceSettlerV4({
+      analysis,
+      manifest: base,
+      staticValueIdsBySymbol: staticValueIdsBySymbol3,
+      localValues: new LocalValueBindingsV4(
+        analysis.values.globals,
+        analysis.schema.enums.map((declaration) => declaration.name),
+        staticMembersInitializedByName(analysis)
+      )
+    }),
     templateIdsByName: new Map(
       analysis.configuration.globals.flatMap(
         (global) => global.type.name === "TextureTemplate" ? [
@@ -111849,6 +112080,8 @@ var init_lower_schema = __esm({
     init_lower_relations();
     init_lower_variants();
     init_lower_support();
+    init_initializer_reference_spellings();
+    init_local_values();
   }
 });
 
@@ -115321,7 +115554,7 @@ function materializedInitializerReconciliationFailuresV4(args) {
         `Cannot reconcile stored construction for value "${valueId}": its canonical pulled constructor expression is unavailable.`
       );
     }
-    const authoredConstructionChanged = args.manifest !== void 0 && canonicalExpression !== constructorExpressionSlice(reconciliation.code);
+    const authoredConstructionChanged = args.manifest !== void 0 && canonicalExpression !== reconciliation.construction;
     authoredConstructionChangedByValueId.set(
       valueId,
       authoredConstructionChanged
@@ -115710,7 +115943,6 @@ var init_local_initializer_materialization = __esm({
     init_src();
     init_projection();
     init_source_diagnostics();
-    init_init_source();
     init_initializer_replay();
     init_materialized_construction_cache();
     init_neoscript_build_cache();
@@ -119959,7 +120191,8 @@ function buildValueLowerContext(state, manifest, options = {}) {
   return {
     localValues: registry.localValues ??= new LocalValueBindingsV4(
       options.analysis?.values.globals ?? [],
-      manifest.enums.values().map((entry) => entry.name)
+      manifest.enums.values().map((entry) => entry.name),
+      options.analysis === void 0 ? [] : staticMembersInitializedByName(options.analysis)
     ),
     state,
     members,
@@ -121061,7 +121294,7 @@ function memberInitializerRequiresEvaluation(context, member, expression, source
   return requiresEvaluation;
 }
 function isSchemaMemberValueRead(context, expression, source) {
-  const path = memberPath(annotatedValue(expression).expression);
+  const path = memberPath2(annotatedValue(expression).expression);
   if (path === null) return false;
   const parts = path.split(".");
   const name = parts.at(-1);
@@ -121724,7 +121957,10 @@ function lowerSeedRow(context, member, sourceExpression, source, valueId, path,
       nodeType: "initializer",
       id: valueId,
       memberId: member.id,
-      code,
+      code: settleInitializerReferenceSpellings(
+        code,
+        (call) => settledReferenceTarget(context, call)
+      ),
       ...containerId === void 0 ? {} : { containerId }
     };
     registerSeedRow(context, rows, initRow, source, sourceExpression);
@@ -122369,6 +122605,10 @@ function lowerValueRow(context, member, sourceExpression, expectedValueId, sourc
       );
     }
     indexInitAuthoredRowIds(context, code, source.label);
+    const compiledCode = settleInitializerReferenceSpellings(
+      code,
+      (call) => settledReferenceTarget(context, call)
+    );
     const storedConstructorArgs = isObjectRecord2(base.constructorArgs) ? base.constructorArgs : null;
     if (resolvedMember.kind !== "class" && isLiteralValueContent(base)) {
       addReconstructed(
@@ -122403,7 +122643,8 @@ function lowerValueRow(context, member, sourceExpression, expectedValueId, sourc
       if (source.purpose === "stored" || requiresCanonicalConstruction) {
         context.initializerReconciliations.set(expectedValueId, {
           valueId: expectedValueId,
-          code,
+          code: compiledCode,
+          construction: authoredConstruction,
           storedConstructorArgs: storedConstructorArgs === null ? null : structuredClone(storedConstructorArgs),
           // Only a construction this pass could not apply is a conflict. A
           // re-projected one landed on the rows the canonical expression is
@@ -122435,7 +122676,7 @@ function lowerValueRow(context, member, sourceExpression, expectedValueId, sourc
       context,
       "value",
       expectedValueId,
-      { ...literalFields, init: { code } },
+      { ...literalFields, init: { code: compiledCode } },
       source.source
     );
     return expectedValueId;
@@ -123815,7 +124056,7 @@ function requiredDecimal(expression) {
 }
 function sourceValueSymbol(context, expression) {
   const unwrapped = annotatedValue(expression).expression;
-  const path = memberPath(unwrapped);
+  const path = memberPath2(unwrapped);
   return path === null ? null : context.staticValueIdsBySymbol.get(path) ?? null;
 }
 function resolveKeyReferenceMemberDefaultsV4(args) {
@@ -123899,12 +124140,12 @@ function referenceTargetSpelling(context, expression) {
     };
   }
   const resolved = referenceTargetBySymbol(context, argument2, genericTypeName);
-  const path = memberPath(argument2);
+  const path = memberPath2(argument2);
   if (resolved === null || path === null) return null;
   return { spelling: "symbol", path, resolved };
 }
 function referenceTargetBySymbol(context, argument2, genericTypeName) {
-  const path = memberPath(argument2);
+  const path = memberPath2(argument2);
   if (path === null) return null;
   const valueId = context.staticValueIdsBySymbol.get(path);
   if (valueId) {
@@ -123924,6 +124165,22 @@ function referenceTargetBySymbol(context, argument2, genericTypeName) {
     genericTypeName
   } : null;
 }
+function settledReferenceTarget(context, call) {
+  const target = referenceTargetSpelling(context, call);
+  if (target?.spelling === "symbol") {
+    const typeName2 = target.resolved.genericTypeName ?? target.resolved.typeName;
+    return typeName2 === null ? null : { id: target.resolved.id, typeName: typeName2 };
+  }
+  if (target?.spelling !== "local") return null;
+  const declared = context.localValues.declaredTarget(target.name);
+  if (declared === null) throw unidentifiedLocalReferenceError(target.name);
+  const typeName = target.typeName ?? declared.typeName;
+  if ("id" in declared) return { id: declared.id, typeName };
+  return {
+    id: context.staticValueIdsBySymbol.get(declared.ownerPath) ?? memberValueId(declared.ownerMemberId),
+    typeName
+  };
+}
 function referenceTargetById(context, id2, genericTypeName) {
   const pendingValue = context.pendingValues.get(id2);
   if (pendingValue !== void 0) {
@@ -124419,7 +124676,7 @@ function indexSourceStaticTargets(targets, state, analysis, manifest, parsedInit
   }
 }
 function sourceValueSymbolFromMap(targets, expression) {
-  const path = memberPath(annotatedValue(expression).expression);
+  const path = memberPath2(annotatedValue(expression).expression);
   return path === null ? null : targets.get(path) ?? null;
 }
 function returnedSymbol(body) {
@@ -124437,7 +124694,7 @@ function returnedSymbol(body) {
 function firstReturnedMemberPath(statements) {
   for (const statement of statements) {
     if (statement.kind === "return") {
-      const path = statement.expr === null ? null : memberPath(statement.expr);
+      const path = statement.expr === null ? null : memberPath2(statement.expr);
       if (path !== null) return path;
       continue;
     }
@@ -124560,7 +124817,7 @@ function classMemberByName(context, classId, name) {
   );
 }
 function lowerFunctionReference(context, expression, ownerClassId) {
-  const symbol = memberPath(expression);
+  const symbol = memberPath2(expression);
   if (symbol === null || symbol.includes(".")) {
     throw new Error("FunctionRef values require a bare function symbol.");
   }
@@ -124609,7 +124866,7 @@ function lowerActionListener2(context, element, ownerClassId, index) {
       `NeoAction listener ${index} is a lambda. A listener must be a member reference: extract the body to an NSFunction member and subscribe that member instead.`
     );
   }
-  const path = memberPath(expression);
+  const path = memberPath2(expression);
   if (path === null) {
     throw new Error(
       `NeoAction listener ${index} must name a function, NSFunction, NSDelegate, or NeoAction member on the current Class or a receiver reachable through root.`
@@ -124666,7 +124923,7 @@ function lowerDelegateValue(context, expression, ownerClassId, authoredSlice) {
     }
     return { code };
   }
-  const path = memberPath(expression);
+  const path = memberPath2(expression);
   const symbol = path?.startsWith("this.") ? path.slice("this.".length) : path;
   if (symbol === null || symbol === void 0 || symbol.includes(".")) {
     throw new Error(
@@ -124687,7 +124944,7 @@ function lowerDelegateValue(context, expression, ownerClassId, authoredSlice) {
   return { memberId: target.id, valueId: null };
 }
 function fileTargetId(context, expression, registry) {
-  const path = memberPath(expression);
+  const path = memberPath2(expression);
   if (path !== null) {
     if (!path.startsWith(`${registry}.`)) return null;
     return context.projectFileIdsBySymbol.get(path) ?? null;
@@ -124699,10 +124956,10 @@ function fileTargetId(context, expression, registry) {
   }
   return null;
 }
-function memberPath(expression) {
+function memberPath2(expression) {
   if (expression.kind === "ident") return expression.name;
   if (expression.kind !== "member") return null;
-  const receiver = memberPath(expression.receiver);
+  const receiver = memberPath2(expression.receiver);
   return receiver === null ? null : `${receiver}.${expression.name}`;
 }
 function annotatedValue(expression) {
@@ -126748,6 +127005,7 @@ var init_value_sources = __esm({
     init_initializer_replay();
     init_key_reference_spelling();
     init_local_values();
+    init_initializer_reference_spellings();
     init_lower_members();
     init_lower_variants();
     init_member_kind_type_names();
@@ -128145,16 +128403,6 @@ var init_api = __esm({
 });
 
 // src/convex.ts
-var convex_exports = {};
-__export(convex_exports, {
-  api: () => api2,
-  convexHttpActionUrl: () => convexHttpActionUrl,
-  createConvexClient: () => createConvexClient,
-  createConvexClientForApi: () => createConvexClientForApi,
-  createConvexPushConnection: () => createConvexPushConnection,
-  mintConvexJwt: () => mintConvexJwt,
-  resolveConvexUrl: () => resolveConvexUrl
-});
 import { gzipSync } from "node:zlib";
 import { ConvexClient, ConvexHttpClient } from "convex/browser";
 import { Buffer as Buffer2 } from "node:buffer";
@@ -129843,6 +130091,7 @@ __export(push_exports, {
   applyPushResult: () => applyPushResult,
   assignPendingIds: () => assignPendingIds,
   buildPostPushCompileSchema: () => buildPostPushCompileSchema,
+  commitProjectVersionChanges: () => commitProjectVersionChanges,
   createPendingProjectSourceIdentityV4: () => createPendingProjectSourceIdentityV4,
   prepareCompleteNeoScriptBodyChanges: () => prepareCompleteNeoScriptBodyChanges,
   prepareLocalCandidateV4: () => prepareLocalCandidateV4,
@@ -130074,6 +130323,81 @@ function pendingInterfaceMemberSymbolOwner(value) {
   if (!/^\d+$/u.test(parts[4] ?? "")) return null;
   return owner;
 }
+async function commitProjectVersionChanges(args) {
+  const { workspace } = args;
+  const body = {
+    operation: args.operation,
+    changes: args.changes,
+    authoredValueSeeds: [],
+    initializerMaterialization: { roots: [] },
+    stagedFiles: [],
+    stagedUploadSessionId: null,
+    // The asynchronous path keys reconnects on this identity; the rows name
+    // the commit, so the same repair resubmitted is the same transaction.
+    sourceHash: createHash10("sha256").update(
+      JSON.stringify(
+        args.changes.map((change) => `${change.recordKind}:${change.recordId}`).sort()
+      )
+    ).digest("hex"),
+    pendingIdAssignments: {},
+    summary: args.summary,
+    headTransactionHash: workspace.state.headTransactionHash ?? null,
+    derivedEdgeExtractorVersion: PROJECT_SNAPSHOT_DERIVED_EDGE_EXTRACTOR_VERSION,
+    forceRecompile: false
+  };
+  const reporter = createPushProgressReporter(args.json, args.progressLabel);
+  reporter.report({
+    type: "project-transaction-progress",
+    transactionId: null,
+    phase: "submitting",
+    totalChangeCount: args.changes.length,
+    appliedChangeCount: 0,
+    totalChunkCount: null,
+    appliedChunkCount: 0,
+    errorCode: null,
+    errorMessage: null
+  });
+  try {
+    const connection = await createConvexPushConnection(workspace);
+    let response;
+    try {
+      response = await connection.submit(body, false);
+    } catch (error) {
+      if (!(error instanceof NeoApiError) || error.status !== 413 || !isObjectRecord2(error.body) || error.body.error !== "schema-commit-route-required")
+        throw error;
+      response = await NeoApiClient.forBaseUrl(
+        workspace.config.apiBaseUrl
+      ).post(
+        `/api/projects/${workspace.config.projectId}/versions/${workspace.config.versionId}/schema/commit`,
+        body
+      );
+    }
+    const accepted = readAcceptedProjectVersionCommitResponse(response);
+    if (accepted === null) {
+      if (!isObjectRecord2(response) || typeof response.kind !== "string") {
+        throw new Error(
+          "Project transaction response is neither accepted nor an immediate commit result."
+        );
+      }
+      return {
+        kind: response.kind === "noop" ? "noop" : "committed",
+        transactionId: immediateTransactionId(response)
+      };
+    }
+    const completed = await waitForAcceptedProjectVersionTransaction({
+      workspace,
+      accepted,
+      reporter,
+      connection
+    });
+    return {
+      kind: completed.totalChangeCount === 0 ? "noop" : "committed",
+      transactionId: completed.transactionId
+    };
+  } finally {
+    reporter.stop();
+  }
+}
 function readAcceptedProjectVersionCommitResponse(value) {
   if (!isObjectRecord2(value) || value.kind !== "accepted") return null;
   if (typeof value.transactionId !== "string") {
@@ -130255,9 +130579,9 @@ function readNullableString(value, field) {
 function isProjectVersionTransactionCommitStatus(value) {
   return value === "preparing" || value === "waiting" || value === "queued" || value === "applying" || value === "reverting" || value === "noop" || value === "committed" || value === "failed";
 }
-function createPushProgressReporter(json) {
+function createPushProgressReporter(json, label = "Pushing\u2026") {
   const animated = process.stdout.isTTY === true && !json;
-  const indicator = animated ? spinner("Pushing\u2026") : null;
+  const indicator = animated ? spinner(label) : null;
   let lastStructuredEvent = "";
   return {
     report(event) {
@@ -138393,7 +138717,7 @@ var init_registry2 = __esm({
   "schema-contract/registry.mjs"() {
     "use strict";
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
-      cliVersion: "0.53.1",
+      cliVersion: "0.53.3",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -141885,8 +142209,7 @@ async function repairUnprojectedValueRows(workspace, findings, yes) {
     return;
   }
   const rows = plan.roots.flatMap((root) => root.rows);
-  const pulledHeadTransactionHash = workspace.state.headTransactionHash;
-  if (typeof pulledHeadTransactionHash !== "string") {
+  if (typeof workspace.state.headTransactionHash !== "string") {
     throw new Error(
       'This workspace has no recorded project head, so `neo doctor --fix` cannot prove its deletions land on the state the audit read. Run "neo pull", then rerun.'
     );
@@ -141920,7 +142243,7 @@ async function repairUnprojectedValueRows(workspace, findings, yes) {
     console.log("Cancelled. No records were deleted.");
     return;
   }
-  const { api: api3, createConvexClient: createConvexClient2 } = await Promise.resolve().then(() => (init_convex(), convex_exports));
+  const { commitProjectVersionChanges: commitProjectVersionChanges2 } = await Promise.resolve().then(() => (init_push(), push_exports));
   const { createProjectVersionIntent: createProjectVersionIntent2 } = await Promise.resolve().then(() => (init_project_version_intents(), project_version_intents_exports));
   const changes = rows.map((row) => ({
     recordKind: "value",
@@ -141932,95 +142255,44 @@ async function repairUnprojectedValueRows(workspace, findings, yes) {
       source: "neo-cli-doctor"
     })
   }));
-  const batchSize = immediateCommitBatchSize(changes);
-  const convex = await createConvexClient2(workspace);
-  const progress = spinner(`Deleting ${rowLabel(rows.length)}\u2026`);
-  let deleted = 0;
-  let expectedHeadTransactionHash = pulledHeadTransactionHash;
-  for (let index = 0; index < changes.length; index += batchSize) {
-    const batch = changes.slice(index, index + batchSize);
-    let transactionHash;
-    try {
-      const result = await convex.mutation(
-        api3.serverProjectRecordOperations.commitFromSession,
-        {
-          projectId: workspace.config.projectId,
-          versionId: workspace.config.versionId,
-          operation: "delete",
-          changes: batch,
-          summary: `neo doctor --fix (${rowLabel(batch.length)})`,
-          expectedHeadTransactionHash
-        }
-      );
-      transactionHash = committedTransactionHash(result);
-    } catch (error) {
-      progress.fail(
-        deleted === 0 ? `Failed to delete ${rowLabel(batch.length)}.` : `Failed after deleting ${rowLabel(deleted)}.`
-      );
-      throw repairFailure(error, deleted);
-    }
-    if (transactionHash === null) continue;
-    expectedHeadTransactionHash = transactionHash;
-    deleted += batch.length;
-    progress.update(
-      `Deleting ${rowLabel(rows.length)}\u2026 ${String(deleted)} done`
-    );
-  }
-  progress.succeed(`Deleted ${rowLabel(deleted)} across ${rootLabel}.`);
-  console.log('Run "neo pull" to refresh the working copy.');
-}
-function immediateCommitBatchSize(changes) {
-  let fits = 0;
-  let low = 1;
-  let high = changes.length;
-  while (low <= high) {
-    const size = Math.floor((low + high) / 2);
-    if (planProjectVersionTransaction(changes.slice(0, size)).path === "immediate") {
-      fits = size;
-      low = size + 1;
-    } else {
-      high = size - 1;
-    }
-  }
-  if (fits === 0) {
-    throw new Error(
-      "Deleting a single value row exceeds the immediate transaction budget, so `neo doctor --fix` cannot commit anything. The transaction cost model needs to change before this repair can run."
-    );
-  }
-  return fits;
-}
-function committedTransactionHash(result) {
-  if (!isObjectRecord2(result)) {
-    throw new Error(
-      "Doctor repair committed a deletion but the server returned no transaction envelope."
-    );
+  let committed;
+  try {
+    committed = await commitProjectVersionChanges2({
+      workspace,
+      operation: "delete",
+      changes,
+      summary: `neo doctor --fix (${rowLabel(rows.length)})`,
+      progressLabel: `Deleting ${rowLabel(rows.length)}\u2026`,
+      json: false
+    });
+  } catch (error) {
+    throw repairFailure(error);
   }
-  if (result.transaction === null) return null;
-  const transactionHash = isObjectRecord2(result.transaction) ? result.transaction.transactionHash : void 0;
-  if (typeof transactionHash !== "string") {
-    throw new Error(
-      "Doctor repair committed a transaction that carries no hash, so the remaining deletions have no fast-forward base."
+  if (committed.kind === "noop") {
+    console.log(
+      `${sym.info} Nothing to delete: the ${rowLabel(rows.length)} were already gone.`
     );
+  } else {
+    success(`Deleted ${rowLabel(rows.length)} across ${rootLabel}.`);
   }
-  return transactionHash;
+  console.log('Run "neo pull" to refresh the working copy.');
 }
-function repairFailure(error, deleted) {
-  const applied = deleted === 0 ? "" : ` ${rowLabel(deleted)} were already deleted.`;
-  const code = convexErrorCode(error);
+function repairFailure(error) {
+  const code = writeRefusalCode(error);
   if (code === "non-fast-forward" || code === "base-hash-conflict") {
     return new Error(
-      `neo doctor --fix was refused: the project moved on since this workspace pulled, so the audit is stale.${applied} Run \`neo pull\` to re-derive it, then rerun.`,
+      "neo doctor --fix was refused: the project moved on since this workspace pulled, so the audit is stale. Run `neo pull` to re-derive it, then rerun.",
       { cause: error }
     );
   }
   return new Error(
-    `neo doctor --fix could not delete the audited rows: ${errorMessage3(error)}${applied}`,
+    `neo doctor --fix could not delete the audited rows: ${errorMessage3(error)}`,
     { cause: error }
   );
 }
-function convexErrorCode(error) {
+function writeRefusalCode(error) {
   if (!isObjectRecord2(error)) return null;
-  const data = error.data;
+  const data = error instanceof NeoApiError ? error.body : error.data;
   if (!isObjectRecord2(data)) return null;
   return typeof data.error === "string" ? data.error : null;
 }
@@ -142035,8 +142307,8 @@ var init_doctor = __esm({
     init_source_diagnostics();
     init_project_documents();
     init_project_integrity();
-    init_project_version_transaction_planning();
     init_projection();
+    init_http();
     NEO_COMPILER_CONTRACT = "ProjectSourceAnalysisV4";
     NEO_VSCODE_EXTENSION_ID = "neocompose.neo-compose-neoscript";
     NEO_VSCODE_EXTENSION_CONTRACT_VERSION = "0.3.0";
@@ -144995,16 +145267,16 @@ function dryrunOwnership(document, valueById, saveBindings = /* @__PURE__ */ new
     return memberById2.get(memberId)?.valueId;
   };
   const visitedPlacements = /* @__PURE__ */ new Set();
-  const walkOwnedGraph = (memberPath2, valueId) => {
-    const memberId = memberPath2.at(-1);
+  const walkOwnedGraph = (memberPath3, valueId) => {
+    const memberId = memberPath3.at(-1);
     if (memberId === void 0) return;
-    const visitKey = `${memberPath2.join("/")}\0${valueId}`;
+    const visitKey = `${memberPath3.join("/")}\0${valueId}`;
     if (visitedPlacements.has(visitKey)) return;
     visitedPlacements.add(visitKey);
     const value = valueById.get(valueId);
     const member = memberById2.get(memberId);
     if (value === void 0 || member === void 0) return;
-    const storage = storageResolver.effectiveStorageForPath(memberPath2);
+    const storage = storageResolver.effectiveStorageForPath(memberPath3);
     if (storage === 2 /* Save */) saveOwned.add(valueId);
     if (storage === 3 /* Session */) sessionOwned.add(valueId);
     if (member.kind === 7 /* Class */ && isObjectRecord2(value.value)) {
@@ -145016,7 +145288,7 @@ function dryrunOwnership(document, valueById, saveBindings = /* @__PURE__ */ new
       for (const [key, childValueId] of Object.entries(value.value)) {
         const childMemberId = childMemberByKey.get(key);
         if (childMemberId !== void 0 && typeof childValueId === "string") {
-          walkOwnedGraph([...memberPath2, childMemberId], childValueId);
+          walkOwnedGraph([...memberPath3, childMemberId], childValueId);
         }
       }
       return;
@@ -145027,7 +145299,7 @@ function dryrunOwnership(document, valueById, saveBindings = /* @__PURE__ */ new
       if (entryMemberId === void 0) return;
       for (const childValueId of membership.get(valueId) ?? []) {
         if (typeof childValueId === "string") {
-          walkOwnedGraph([...memberPath2, entryMemberId], childValueId);
+          walkOwnedGraph([...memberPath3, entryMemberId], childValueId);
         }
       }
       return;
@@ -145038,7 +145310,7 @@ function dryrunOwnership(document, valueById, saveBindings = /* @__PURE__ */ new
       const childIds = Array.isArray(value.value) ? value.value : Object.values(value.value);
       for (const childValueId of childIds) {
         if (typeof childValueId === "string") {
-          walkOwnedGraph([...memberPath2, entryMemberId], childValueId);
+          walkOwnedGraph([...memberPath3, entryMemberId], childValueId);
         }
       }
     }
@@ -146266,7 +146538,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.53.1");
+    console.log("0.53.3");
     return;
   }
   if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {