@neocompose/cli 0.56.0 → 0.57.0

package/dist/neo.mjs

@@ -1359,7 +1359,7 @@ function indexLocals(tokens, pairs, lexed, diagnostics) {
     }
     const loop = tryParseLoopLocal(tokens, index, pairs, lexed, diagnostics);
     if (loop) {
-      locals.push(loop.local);
+      locals.push(...loop.locals);
       index = loop.resumeTokenIndex;
       continue;
     }
@@ -1793,7 +1793,7 @@ function tryParseLoopLocal(tokens, start, pairs, lexed, diagnostics) {
       });
     }
     return {
-      local: { ...declaration.local, scopeEnd },
+      locals: [{ ...declaration.local, scopeEnd }],
       resumeTokenIndex: declaration.endTokenIndex
     };
   }
@@ -1805,22 +1805,65 @@ function tryParseLoopLocal(tokens, start, pairs, lexed, diagnostics) {
   const inIndex = start + 2 + inOffset;
   const name = tokens[inIndex - 1];
   const first = tokens[start + 2];
-  if (!name || name.kind !== "identifier" || !first) return null;
+  if (!first) return null;
   const inferred = first.kind === "identifier" && first.text === NEOSCRIPT_INFERRED_LOCAL_KEYWORD;
+  const receiver = tokens.slice(inIndex + 1, closeIndex);
+  const local = (token, typeTokens, key) => ({
+    name: token.text,
+    nameRange: token.range,
+    typeTokens,
+    inferred,
+    ...inferred ? { contextualKeywordRange: first.range } : {},
+    initializerTokens: receiver,
+    collectionIteration: true,
+    ...key ? { collectionIterationKey: true } : {},
+    declarationRange: lexed.source.range(first.start, token.end),
+    scopeStart: tokens[closeIndex]?.end ?? token.end,
+    scopeEnd,
+    lambdaParameter: false
+  });
+  const tupleOpenIndex = start + (inferred ? 3 : 2);
+  const tupleOpen = tokens[tupleOpenIndex];
+  if (tupleOpen?.kind === "punctuation" && tupleOpen.text === "(") {
+    const tupleCloseIndex = pairs.get(tupleOpenIndex);
+    if (tupleCloseIndex !== inIndex - 1) return null;
+    let commaIndex = -1;
+    let angleDepth = 0;
+    for (let cursor = tupleOpenIndex + 1; cursor < tupleCloseIndex; cursor++) {
+      const text = tokens[cursor]?.text;
+      if (text === "<") angleDepth++;
+      if (text === ">") angleDepth--;
+      if (text === "," && angleDepth === 0) {
+        commaIndex = cursor;
+        break;
+      }
+    }
+    if (commaIndex < 0) return null;
+    const keyName = tokens[commaIndex - 1];
+    const valueName = tokens[tupleCloseIndex - 1];
+    if (keyName?.kind !== "identifier" || valueName?.kind !== "identifier")
+      return null;
+    return {
+      locals: [
+        local(
+          keyName,
+          inferred ? [] : tokens.slice(tupleOpenIndex + 1, commaIndex - 1),
+          true
+        ),
+        local(
+          valueName,
+          inferred ? [] : tokens.slice(commaIndex + 1, tupleCloseIndex - 1),
+          false
+        )
+      ],
+      resumeTokenIndex: inIndex - 1
+    };
+  }
+  if (!name || name.kind !== "identifier") return null;
   return {
-    local: {
-      name: name.text,
-      nameRange: name.range,
-      typeTokens: inferred ? [] : tokens.slice(start + 2, inIndex - 1),
-      inferred,
-      ...inferred ? { contextualKeywordRange: first.range } : {},
-      initializerTokens: tokens.slice(inIndex + 1, closeIndex),
-      collectionIteration: true,
-      declarationRange: lexed.source.range(first.start, name.end),
-      scopeStart: tokens[closeIndex]?.end ?? name.end,
-      scopeEnd,
-      lambdaParameter: false
-    },
+    locals: [
+      local(name, inferred ? [] : tokens.slice(start + 2, inIndex - 1), false)
+    ],
     resumeTokenIndex: inIndex - 1
   };
 }
@@ -2877,14 +2920,25 @@ var init_executable_parser = __esm({
         const token = this.expect("keyword", "foreach");
         this.expect("punctuation", "(");
         const inferred = this.peek().kind === "identifier" && this.peek().text === NEOSCRIPT_INFERRED_LOCAL_KEYWORD;
+        if (inferred) this.next();
+        const deconstructed = this.peek().kind === "punctuation" && this.peek().text === "(";
+        if (deconstructed) this.next();
         let type;
         if (inferred) {
-          this.next();
           type = null;
         } else {
           type = this.parseType();
         }
-        const name = this.expect("identifier");
+        const firstName = this.expect("identifier");
+        let key;
+        let name = firstName;
+        if (deconstructed) {
+          key = { name: firstName.text, type };
+          this.expect("punctuation", ",");
+          type = inferred ? null : this.parseType();
+          name = this.expect("identifier");
+          this.expect("punctuation", ")");
+        }
         this.expect("keyword", "in");
         const collection = this.parseExpr();
         this.expect("punctuation", ")");
@@ -2892,6 +2946,7 @@ var init_executable_parser = __esm({
           kind: "forEach",
           type,
           name: name.text,
+          ...key ? { key } : {},
           collection,
           body: this.parseStatementBody(),
           pos: at(token)
@@ -5834,6 +5889,9 @@ function collectionParts(type) {
 function collectionPartsFor(expression) {
   return collectionParts(expression.type);
 }
+function isCollectionPath(expression) {
+  return expression.kind === "ident" || expression.kind === "member" && !expression.optional && isCollectionPath(expression.receiver);
+}
 function collectionOperationValueType(expression, collection) {
   if (isLookupSelectionCollection(expression, collection)) {
     return { kind: "primitive", name: "string" };
@@ -6934,6 +6992,12 @@ var init_strict_resolver = __esm({
             };
           }
           case "forEach": {
+            if (statement.key && !isCollectionPath(statement.collection)) {
+              throw new CompileError(
+                "Assign the dictionary to a local before deconstructing it in foreach.",
+                statement.collection.pos
+              );
+            }
             const collection = this.resolveExpression(statement.collection, scope);
             if (isNullable(collection.type)) {
               throw new CompileError(
@@ -6948,36 +7012,88 @@ var init_strict_resolver = __esm({
                 statement.collection.pos
               );
             }
+            if (statement.key && parts.kind !== "dictionary") {
+              throw new CompileError(
+                `foreach key/value deconstruction requires a Dictionary, got ${this.describe(collection.type)}`,
+                statement.collection.pos
+              );
+            }
             this.assertLocalNameAvailable(statement.name, scope, statement.pos);
-            const inferredType = parts.valueType;
-            const bindingType = statement.type ? this.resolveType(statement.type) : inferredType;
-            if (statement.type) {
+            if (statement.key) {
+              this.assertLocalNameAvailable(
+                statement.key.name,
+                scope,
+                statement.pos
+              );
+              if (statement.key.name === statement.name) {
+                throw new CompileError(
+                  "foreach key and value need different names.",
+                  statement.pos
+                );
+              }
+            }
+            const inferredType = statement.key ? parts.keyType : parts.valueType;
+            const declared = statement.key ? statement.key.type : statement.type;
+            const bindingType = declared ? this.resolveType(declared) : inferredType;
+            if (declared) {
               this.requireAssignable(
                 inferredType,
                 bindingType,
                 statement.pos,
-                "foreach iterator"
+                statement.key ? "foreach key" : "foreach iterator"
               );
             }
             const binding = variable(
-              statement.name,
+              statement.key?.name ?? statement.name,
               bindingType,
               void 0,
               this.project
             );
+            const iterationCollection = statement.key ? this.selectDictionaryKeys(collection, parts) : collection;
             const bindingWritability = collection.entryWritability ?? collection.writability ?? "runtime" /* Runtime */;
+            const collectionWriteRoot = this.expressionWriteRoot(collection, scope);
             const loopScope = new Scope(scope);
             loopScope.define(
               scopeVariable(
-                statement.name,
+                statement.key?.name ?? statement.name,
                 binding,
                 bindingType,
                 bindingWritability,
                 bindingWritability,
-                collection.writeRoot ?? this.writeThroughRoot(collection.pointer, scope),
+                collectionWriteRoot,
                 "foreach"
               )
             );
+            if (statement.key) {
+              const valueType = statement.type ? this.resolveType(statement.type) : parts.valueType;
+              if (statement.type) {
+                this.requireAssignable(
+                  parts.valueType,
+                  valueType,
+                  statement.pos,
+                  "foreach value"
+                );
+              }
+              const indexed = this.resolveIndex(
+                statement.collection,
+                { kind: "ident", name: statement.key.name, pos: statement.pos },
+                loopScope,
+                statement.pos,
+                false
+              );
+              loopScope.define({
+                name: statement.name,
+                type: valueType,
+                variableId: statement.name,
+                pointer: indexed.pointer,
+                ...indexed.writability ? {
+                  writability: indexed.writability,
+                  ownership: indexed.writability
+                } : {},
+                writeRoot: collectionWriteRoot,
+                readonlyBinding: "foreach"
+              });
+            }
             const iterationScope = new Scope(loopScope);
             invalidateLoopEntryNarrowingsAssignedBy(
               iterationScope,
@@ -7025,8 +7141,8 @@ var init_strict_resolver = __esm({
                 readonly: true,
                 writability: bindingWritability
               },
-              collectionPointer: collection.pointer,
-              collectionTypeInfo: collection.wireType ?? toWireType(collection.type, this.project),
+              collectionPointer: iterationCollection.pointer,
+              collectionTypeInfo: iterationCollection.wireType ?? toWireType(iterationCollection.type, this.project),
               instructions
             };
           }
@@ -7468,6 +7584,8 @@ var init_strict_resolver = __esm({
           let label = "foreach iterator";
           if (local.readonlyBinding === "catch") label = "catch parameter";
           if (local.readonlyBinding === "capture") label = "captured value";
+          if (local.readonlyBinding === "enumKey")
+            label = "enum dictionary key parameter";
           throw new CompileError(
             `Cannot assign to ${label} '${local.name}' because it is read-only.`,
             statement.pos
@@ -11631,6 +11749,67 @@ var init_strict_resolver = __esm({
         }
         return value.pointer;
       }
+      selectDictionaryKeys(dictionary, parts) {
+        const key = this.collectionLambdaParameter(
+          "__foreach_key__",
+          parts.keyType,
+          parts,
+          0
+        );
+        const value = variable(
+          "__foreach_value__",
+          parts.valueType,
+          void 0,
+          this.project
+        );
+        const alias = this.enumDictionaryKeyPointer(key, parts.keyType, parts, 0);
+        const fn = {
+          compilerRevision: NEOSCRIPT_COMPILER_REVISION,
+          parameters: [key, value],
+          instructions: [
+            {
+              type: "return" /* Return */,
+              pointer: alias ?? {
+                type: "variable" /* Variable */,
+                variableId: key.id
+              }
+            }
+          ],
+          typeInfo: toWireType(parts.keyType, this.project)
+        };
+        return intrinsic(
+          "select" /* Select */,
+          { collectionPointer: dictionary.pointer, function: fn },
+          { kind: "list", elementType: parts.keyType, readOnly: true }
+        );
+      }
+      collectionLambdaParameter(name, type, collection, index) {
+        const rawType = this.isEnumDictionaryKey(type, collection, index) ? { kind: "primitive", name: "string" } : type;
+        return variable(name, rawType, void 0, this.project);
+      }
+      isEnumDictionaryKey(type, collection, index) {
+        return collection.kind === "dictionary" && index === 0 && type.kind === "named" && this.project.typeById.get(type.typeId)?.kind === "enum";
+      }
+      enumDictionaryKeyPointer(parameter4, type, collection, index) {
+        if (!this.isEnumDictionaryKey(type, collection, index)) return void 0;
+        const wire = toWireType(
+          {
+            kind: "list",
+            elementType: { kind: "primitive", name: "string" }
+          },
+          this.project
+        );
+        if (wire.type !== 6 /* List */) {
+          throw new Error("Enum key alias requires a list wire type.");
+        }
+        return {
+          type: "listLiteral" /* ListLiteral */,
+          typeInfo: wire,
+          entries: [
+            { type: "variable" /* Variable */, variableId: parameter4.id }
+          ]
+        };
+      }
       resolveCollectionLambda(ast, collection, returnType, outerScope, pos) {
         if (ast.kind !== "lambda") {
           throw new CompileError(
@@ -11658,16 +11837,30 @@ var init_strict_resolver = __esm({
               parameter4.pos,
               "lambda parameter"
             );
-          const item = variable(parameter4.name, declared, void 0, this.project);
-          scope.define(
-            scopeVariable(
+          const item = this.collectionLambdaParameter(
+            parameter4.name,
+            declared,
+            collection,
+            index
+          );
+          const alias = this.enumDictionaryKeyPointer(
+            item,
+            declared,
+            collection,
+            index
+          );
+          scope.define({
+            ...scopeVariable(
               parameter4.name,
               item,
               declared,
               void 0,
-              "runtime" /* Runtime */
-            )
-          );
+              "runtime" /* Runtime */,
+              void 0,
+              alias ? "enumKey" : void 0
+            ),
+            ...alias ? { pointer: alias } : {}
+          });
           return item;
         });
         this.functionControlBoundaries.push({
@@ -11714,16 +11907,30 @@ var init_strict_resolver = __esm({
           this.assertLocalNameAvailable(parameter4.name, scope, parameter4.pos);
           const type = parameter4.type ? this.resolveType(parameter4.type) : requiredAt(parameterTypes, index);
           const isValueParameter = index === valueParameterIndex;
-          scope.define(
-            scopeVariable(
+          const item = this.collectionLambdaParameter(
+            parameter4.name,
+            type,
+            collection,
+            index
+          );
+          const alias = this.enumDictionaryKeyPointer(
+            item,
+            type,
+            collection,
+            index
+          );
+          scope.define({
+            ...scopeVariable(
               parameter4.name,
-              variable(parameter4.name, type, void 0, this.project),
+              item,
               type,
               isValueParameter ? sourceWritability : "runtime" /* Runtime */,
               isValueParameter ? sourceWritability : "runtime" /* Runtime */,
-              isValueParameter ? sourceWriteRoot : "local"
-            )
-          );
+              isValueParameter ? sourceWriteRoot : "local",
+              alias ? "enumKey" : void 0
+            ),
+            ...alias ? { pointer: alias } : {}
+          });
         });
         let inferred = null;
         let inferredWritability = null;
@@ -14252,7 +14459,9 @@ function inferLocalType(local, snapshot) {
     tokens[0]?.start ?? snapshot.source.offsetAt(local.nameRange.end)
   );
   if (!local.collectionIteration) return inferred;
-  if (inferred.kind === "dictionary") return inferred.valueType;
+  if (inferred.kind === "dictionary") {
+    return local.collectionIterationKey ? inferred.keyType : inferred.valueType;
+  }
   if (inferred.kind === "list" || inferred.kind === "set") {
     return inferred.elementType;
   }
@@ -22707,6 +22916,7 @@ function collectIdentifierReads(expression, names) {
         walk(statement.collection, visible);
         const inner = new Set(visible);
         inner.delete(statement.name);
+        if (statement.key) inner.delete(statement.key.name);
         for (const bodyStatement of statement.body) {
           walkStatement(bodyStatement, inner);
         }
@@ -38029,6 +38239,12 @@ function normalizeDocumentFields(recordKind, value) {
       }
     }
   }
+  if (recordKind === "class" && Array.isArray(normalized.genericParams)) {
+    for (const parameter4 of normalized.genericParams) {
+      if (!isRecord(parameter4) || !isRecord(parameter4.constraint)) continue;
+      if (parameter4.constraint.kind === 0) delete parameter4.constraint.kind;
+    }
+  }
   omitRedundantDeclarationOrder(recordKind, normalized);
   return normalized;
 }
@@ -45095,6 +45311,109 @@ var init_project_manifest = __esm({
   }
 });
 
+// src/project-source/source-format.ts
+function quoteNeoString(value) {
+  return JSON.stringify(value);
+}
+function indentNeoSource(value, spaces) {
+  return indentLines(value, spaces, true);
+}
+function indentNeoSourceNonEmptyLines(value, spaces) {
+  return indentLines(value, spaces, false);
+}
+function indentLines(value, spaces, indentEmptyLines) {
+  const prefix = " ".repeat(spaces);
+  return value.split("\n").map(
+    (line) => indentEmptyLines || line.length > 0 ? `${prefix}${line}` : line
+  ).join("\n");
+}
+function formatNeoNumber(value) {
+  if (!Number.isFinite(value)) {
+    throw new Error(`Cannot emit non-finite Neo number ${String(value)}.`);
+  }
+  const source = String(value);
+  const match = /^(?<sign>-?)(?<integer>\d+)(?:\.(?<fraction>\d+))?[eE](?<exponent>[+-]?\d+)$/u.exec(
+    source
+  );
+  if (match?.groups === void 0) return source;
+  const sign = match.groups.sign ?? "";
+  const integer3 = match.groups.integer ?? "";
+  const fraction = match.groups.fraction ?? "";
+  const digits = `${integer3}${fraction}`;
+  const decimalIndex = integer3.length + Number(match.groups.exponent);
+  if (decimalIndex <= 0) {
+    return `${sign}0.${"0".repeat(-decimalIndex)}${digits}`;
+  }
+  if (decimalIndex >= digits.length) {
+    return `${sign}${digits}${"0".repeat(decimalIndex - digits.length)}`;
+  }
+  return `${sign}${digits.slice(0, decimalIndex)}.${digits.slice(decimalIndex)}`;
+}
+function invariantCaseKey(value) {
+  return value.toLowerCase();
+}
+var init_source_format = __esm({
+  "src/project-source/source-format.ts"() {
+    "use strict";
+    init_machine_strings();
+  }
+});
+
+// src/project-source/dictionary-enum-keys.ts
+function lowerDictionaryKey(expression, keyEnum, path) {
+  if (expression.kind === "litString") {
+    if (keyEnum?.optionsByName.has(expression.value)) {
+      throw new Error(
+        `Dictionary key ${JSON.stringify(expression.value)} at ${path} names an option in enum ${JSON.stringify(keyEnum.name)}. Write .${expression.value} or its option ID.`
+      );
+    }
+    return expression.value;
+  }
+  if (keyEnum === null) {
+    throw new Error(`Dictionary ${path} requires string keys.`);
+  }
+  let optionName;
+  if (expression.kind === "contextualEnum") {
+    optionName = expression.name;
+  } else if (expression.kind === "member" && expression.receiver.kind === "ident") {
+    if (expression.receiver.name !== keyEnum.name) {
+      throw new Error(
+        `Dictionary key at ${path} names enum ${JSON.stringify(expression.receiver.name)}, expected ${JSON.stringify(keyEnum.name)}.`
+      );
+    }
+    optionName = expression.name;
+  } else {
+    throw new Error(
+      `Dictionary key at ${path} must be .Option, ${keyEnum.name}.Option, or a quoted option ID.`
+    );
+  }
+  const optionId = keyEnum.optionsByName.get(optionName);
+  if (optionId === void 0) {
+    throw new Error(
+      `Enum ${JSON.stringify(keyEnum.name)} has no option ${JSON.stringify(optionName)} at ${path}.`
+    );
+  }
+  return optionId;
+}
+function emitDictionaryKey(key, options) {
+  const name = options?.get(key)?.name;
+  return name === void 0 ? quoteNeoString(key) : `.${name}`;
+}
+function orderedDictionaryEntries(value, options) {
+  return Object.entries(value).sort(([left], [right]) => {
+    const leftOrder = options?.get(left)?.order ?? Infinity;
+    const rightOrder = options?.get(right)?.order ?? Infinity;
+    if (leftOrder !== rightOrder) return leftOrder - rightOrder;
+    return compareCodePoints(left, right);
+  });
+}
+var init_dictionary_enum_keys = __esm({
+  "src/project-source/dictionary-enum-keys.ts"() {
+    "use strict";
+    init_source_format();
+  }
+});
+
 // ../src/models/system-record-id.ts
 function isSystemRecordId(id2) {
   return id2.startsWith(SYSTEM_RECORD_ID_PREFIX2);
@@ -45153,54 +45472,6 @@ var init_declaration_path = __esm({
   }
 });
 
-// src/project-source/source-format.ts
-function quoteNeoString(value) {
-  return JSON.stringify(value);
-}
-function indentNeoSource(value, spaces) {
-  return indentLines(value, spaces, true);
-}
-function indentNeoSourceNonEmptyLines(value, spaces) {
-  return indentLines(value, spaces, false);
-}
-function indentLines(value, spaces, indentEmptyLines) {
-  const prefix = " ".repeat(spaces);
-  return value.split("\n").map(
-    (line) => indentEmptyLines || line.length > 0 ? `${prefix}${line}` : line
-  ).join("\n");
-}
-function formatNeoNumber(value) {
-  if (!Number.isFinite(value)) {
-    throw new Error(`Cannot emit non-finite Neo number ${String(value)}.`);
-  }
-  const source = String(value);
-  const match = /^(?<sign>-?)(?<integer>\d+)(?:\.(?<fraction>\d+))?[eE](?<exponent>[+-]?\d+)$/u.exec(
-    source
-  );
-  if (match?.groups === void 0) return source;
-  const sign = match.groups.sign ?? "";
-  const integer3 = match.groups.integer ?? "";
-  const fraction = match.groups.fraction ?? "";
-  const digits = `${integer3}${fraction}`;
-  const decimalIndex = integer3.length + Number(match.groups.exponent);
-  if (decimalIndex <= 0) {
-    return `${sign}0.${"0".repeat(-decimalIndex)}${digits}`;
-  }
-  if (decimalIndex >= digits.length) {
-    return `${sign}${digits}${"0".repeat(decimalIndex - digits.length)}`;
-  }
-  return `${sign}${digits.slice(0, decimalIndex)}.${digits.slice(decimalIndex)}`;
-}
-function invariantCaseKey(value) {
-  return value.toLowerCase();
-}
-var init_source_format = __esm({
-  "src/project-source/source-format.ts"() {
-    "use strict";
-    init_machine_strings();
-  }
-});
-
 // src/project-source/ui-action-source.ts
 function isCompleteUIAction(rawAction) {
   const action = object(rawAction);
@@ -52927,7 +53198,7 @@ function assertReadOnlyMembersValid(document) {
         `Read-only member "${member.name}" (${member.id}) must declare Immutable storage; ${ownerContext}.`
       );
     }
-    if (isAbstractMember(member) !== true && resolved.kind !== 21 /* Generic */ && resolved.defaultValue === void 0) {
+    if (isAbstractMember(resolved) !== true && resolved.kind !== 21 /* Generic */ && resolved.defaultValue === void 0) {
       throw new Error(
         `Read-only member "${member.name}" (${member.id}) requires an explicit defaultValue; ${ownerContext}.`
       );
@@ -52967,7 +53238,7 @@ function assertReadOnlyMembersValid(document) {
             `Read-only member "${member.name}" (${member.id}) must be value-bearing in every closed Generic placement; ${ownerContext}.`
           );
         }
-        if (isAbstractMember(member) === true) continue;
+        if (isAbstractMember(resolved) === true) continue;
         if (effective.defaultValue == null) {
           throw new Error(
             `Read-only member "${member.name}" (${member.id}) requires an explicit field defaultValue in every closed Generic placement; ${ownerContext}.`
@@ -52984,7 +53255,7 @@ function assertReadOnlyMembersValid(document) {
           );
         }
       }
-      if (isAbstractMember(member) === true) continue;
+      if (isAbstractMember(resolved) === true) continue;
       assertOwnedSchemaIsImmutable({
         member,
         memberId: member.id,
@@ -53209,6 +53480,25 @@ function virtualValueId(instanceRootId, sourceIdentity3) {
     )
   );
 }
+function virtualSourceIdentityHead(sourceIdentity3) {
+  const pathStart = sourceIdentity3.indexOf(":$");
+  return pathStart < 0 ? sourceIdentity3 : sourceIdentity3.slice(0, pathStart);
+}
+function hasPendingVirtualSourceIdentity(sourceIdentity3) {
+  const head = virtualSourceIdentityHead(sourceIdentity3);
+  return head.startsWith("path:__pending__:") || head.startsWith("__pending__:");
+}
+function rewriteVirtualSourceIdentity(sourceIdentity3, rewriteId) {
+  const head = virtualSourceIdentityHead(sourceIdentity3);
+  const path = sourceIdentity3.slice(head.length);
+  if (head.startsWith("path:__pending__:")) {
+    return `path:${rewriteId(head.slice("path:".length))}${path}`;
+  }
+  if (head.startsWith("__pending__:")) {
+    return `${rewriteId(head)}${path}`;
+  }
+  return sourceIdentity3;
+}
 function pendingVirtualValueId(pendingInstanceRootId, sourceIdentity3) {
   return `${PENDING_VIRTUAL_VALUE_PREFIX}${encodeURIComponent(pendingInstanceRootId)}:${encodeURIComponent(sourceIdentity3)}`;
 }
@@ -57815,6 +58105,7 @@ function emitProjectSourcesV4(manifest, options = {}) {
     classes: new Map(manifest.classes.map((entry) => [entry.id, entry])),
     interfaces: new Map(manifest.interfaces.map((entry) => [entry.id, entry])),
     enums: new Map(manifest.enums.map((entry) => [entry.id, entry])),
+    dictionaryKeyOptions: /* @__PURE__ */ new Map(),
     members: new Map(manifest.members.map((entry) => [entry.id, entry])),
     constructorsById: new Map(
       manifest.constructors.map((entry) => [entry.id, entry])
@@ -58833,6 +59124,18 @@ function initDefaultSource(member) {
   if (!("init" in value)) return void 0;
   return value.init.code;
 }
+function dictionaryOptions(context, enumId) {
+  const cached = context.dictionaryKeyOptions.get(enumId);
+  if (cached !== void 0) return cached;
+  const result = new Map(
+    required(context.enums, enumId, "enum").options.map((option, order) => [
+      option.id,
+      { name: option.name, order }
+    ])
+  );
+  context.dictionaryKeyOptions.set(enumId, result);
+  return result;
+}
 function renderDefaultValue(context, member, wrapper, enclosingClassId) {
   const value = wrapper.value;
   if (value === null) return "null";
@@ -58861,8 +59164,10 @@ function renderDefaultValue(context, member, wrapper, enclosingClassId) {
       member.entryMemberId,
       "dictionary entry"
     );
-    return `{ ${Object.entries(value).map(
-      ([key, item]) => `${quote(key)}: ${renderNestedValue(context, entry, item, enclosingClassId)}`
+    const keyOptions = member.key.kind === "enum" ? dictionaryOptions(context, member.key.enumId) : null;
+    const entries = keyOptions ? orderedDictionaryEntries(value, keyOptions) : Object.entries(value);
+    return `{ ${entries.map(
+      ([key, item]) => `${emitDictionaryKey(key, keyOptions)}: ${renderNestedValue(context, entry, item, enclosingClassId)}`
     ).join(", ")} }`;
   }
   if (member.kind === "class" && isObject3(value)) {
@@ -59478,6 +59783,7 @@ var SPECIALIZED_RELATION_PROPERTIES;
 var init_emitter = __esm({
   "src/project-source/emitter.ts"() {
     "use strict";
+    init_dictionary_enum_keys();
     init_declaration_path();
     init_src();
     init_source_format();
@@ -68646,6 +68952,76 @@ var init_unattributable_reads = __esm({
   }
 });
 
+// ../src/runtime/neoscript/NSGetterRuntimeError.ts
+var NSGetterRuntimeError, UncompiledInitializerRuntimeError;
+var init_NSGetterRuntimeError = __esm({
+  "../src/runtime/neoscript/NSGetterRuntimeError.ts"() {
+    "use strict";
+    NSGetterRuntimeError = class extends Error {
+      constructor(message, options) {
+        super(message, options);
+        this.name = "NSGetterRuntimeError";
+      }
+    };
+    UncompiledInitializerRuntimeError = class extends NSGetterRuntimeError {
+      constructor(memberId, memberName, initializer = null, valueId = null) {
+        super(
+          `Initializer for '${memberName}' has no compiled body; push the project so the server compiles it.`
+        );
+        this.memberId = memberId;
+        this.initializer = initializer;
+        this.valueId = valueId;
+        this.name = "UncompiledInitializerRuntimeError";
+      }
+      memberId;
+      initializer;
+      valueId;
+    };
+  }
+});
+
+// ../src/runtime/neoscript/initializer-dependencies.ts
+function materializeInitializerDependencies(pending, materialize) {
+  const active = /* @__PURE__ */ new Set();
+  for (const rootId of pending) {
+    const stack = [rootId];
+    active.add(rootId);
+    while (stack.length > 0) {
+      const valueId = stack[stack.length - 1];
+      try {
+        materialize(valueId);
+        pending.delete(valueId);
+        active.delete(valueId);
+        stack.pop();
+      } catch (error) {
+        if (!(error instanceof PendingInitializerDependency)) throw error;
+        if (!pending.has(error.valueId)) throw error;
+        if (active.has(error.valueId)) {
+          throw new Error(
+            `Initializer dependency cycle: ${[...stack, error.valueId].join(" -> ")}.`
+          );
+        }
+        active.add(error.valueId);
+        stack.push(error.valueId);
+      }
+    }
+  }
+}
+var PendingInitializerDependency;
+var init_initializer_dependencies = __esm({
+  "../src/runtime/neoscript/initializer-dependencies.ts"() {
+    "use strict";
+    init_NSGetterRuntimeError();
+    PendingInitializerDependency = class extends NSGetterRuntimeError {
+      constructor(valueId) {
+        super(`Initializer dependency "${valueId}" has not been materialized.`);
+        this.valueId = valueId;
+      }
+      valueId;
+    };
+  }
+});
+
 // ../src/runtime/neoscript/cell-pattern.ts
 function integer2(value, name, minimum = -2147483648) {
   if (typeof value !== "number" || !Number.isInteger(value)) {
@@ -70581,37 +70957,9 @@ var init_NeoScriptScope = __esm({
   }
 });
 
-// ../src/runtime/neoscript/NSGetterRuntimeError.ts
-var NSGetterRuntimeError, UncompiledInitializerRuntimeError;
-var init_NSGetterRuntimeError = __esm({
-  "../src/runtime/neoscript/NSGetterRuntimeError.ts"() {
-    "use strict";
-    NSGetterRuntimeError = class extends Error {
-      constructor(message, options) {
-        super(message, options);
-        this.name = "NSGetterRuntimeError";
-      }
-    };
-    UncompiledInitializerRuntimeError = class extends NSGetterRuntimeError {
-      constructor(memberId, memberName, initializer = null, valueId = null) {
-        super(
-          `Initializer for '${memberName}' has no compiled body; push the project so the server compiles it.`
-        );
-        this.memberId = memberId;
-        this.initializer = initializer;
-        this.valueId = valueId;
-        this.name = "UncompiledInitializerRuntimeError";
-      }
-      memberId;
-      initializer;
-      valueId;
-    };
-  }
-});
-
 // ../src/runtime/neoscript/evaluateNSGetter.ts
 function isCatchableNeoScriptRuntimeError(error) {
-  return error instanceof NSGetterRuntimeError && !(error instanceof UncompiledInitializerRuntimeError) && !(error instanceof NonCatchableNSGetterRuntimeError);
+  return error instanceof NSGetterRuntimeError && !(error instanceof UncompiledInitializerRuntimeError) && !(error instanceof PendingInitializerDependency) && !(error instanceof NonCatchableNSGetterRuntimeError);
 }
 function makeUnindexedEvaluatorLookups(members, storedValues) {
   const values = expandPackedValueRows(storedValues);
@@ -73910,7 +74258,7 @@ function evalStaticMember(memberId, ctx) {
       `Static member '${member.name}' is bound to missing value '${targetId}'.`
     );
   }
-  return shouldUnwrapSingleLookupValue(member) ? unwrapSingleLookupValue(row.value, ctx) : resolveLocalizedRowValueForMember(row, member, ctx);
+  return shouldUnwrapSingleLookupValue(member) ? unwrapSingleLookupValue(readRowValue(row, ctx), ctx) : resolveLocalizedRowValueForMember(row, member, ctx);
 }
 function evalPointer(pointer, scope, ctx) {
   switch (pointer.type) {
@@ -73950,7 +74298,7 @@ function evalPointer(pointer, scope, ctx) {
           `Missing value reference: ${pointer.valueId}`
         );
       }
-      return row.value;
+      return readRowValue(row, ctx);
     }
     case "variant" /* variant */:
       return {
@@ -74328,7 +74676,7 @@ function invokeDelegateValue(value, args, ctx, callSiteId, ownerReceiver) {
         `NeoDelegate target '${member.name}' has missing receiver value '${value.valueId}'.`
       );
     }
-    receiver = row.value;
+    receiver = readRowValue(row, ctx);
   } else if (ownerReceiver !== null && ownerReceiver !== void 0) {
     receiver = listenerReceiverOnOwner(member.id, ownerReceiver, ctx);
   }
@@ -75363,6 +75711,20 @@ function dispatchSchemaMember(receiver, schemaKey, ctx) {
   if (typeof receiver !== "object" || receiver === null) {
     return { kind: "no-info", matchedMember: false };
   }
+  if (ctx.vm.databaseVM?.onInitializerRead !== void 0 && receiver === ctx.rootValue) {
+    const root = PROJECT_ROOTS.find((root2) => root2.key === schemaKey);
+    if (root !== void 0) {
+      const memberId = ctx.vm.project[root.projectField];
+      let bindings;
+      if (root.storage === 2 /* Save */)
+        bindings = ctx.__saveStaticBindings;
+      if (root.storage === 3 /* Session */)
+        bindings = ctx.__sessionStaticBindings;
+      const targetId = bindings?.has(memberId) ? bindings.get(memberId) : evalMemberById(ctx.vm, memberId)?.valueId;
+      if (typeof targetId === "string")
+        ctx.vm.databaseVM.onInitializerRead(targetId);
+    }
+  }
   const member = resolveRuntimeSchemaMember(receiver, schemaKey, ctx);
   if (!member) return { kind: "no-info", matchedMember: false };
   if (member.kind === 10 /* NSProperty */) {
@@ -75688,20 +76050,27 @@ function unwrapSingleLookupValue(value, ctx) {
       ctx.__valueOverlay
     );
     if (next) {
-      return next.value;
+      return readRowValue(next, ctx);
     }
   }
   return value;
 }
+function readRowValue(row, ctx) {
+  const onInitializerRead = ctx.vm.databaseVM?.onInitializerRead;
+  if (onInitializerRead !== void 0 && isInitValueContent(row)) {
+    onInitializerRead(row.id);
+  }
+  return row.value;
+}
 function resolveLocalizedRowValue(row, ctx) {
-  const value = row.value;
+  const value = readRowValue(row, ctx);
   if (typeof value !== "string") return value;
   const member = memberForValueRow(row, ctx);
   if (member === null) return value;
   return resolveLocalizedRowValueForMember(row, member, ctx);
 }
 function resolveLocalizedRowValueForMember(row, member, ctx) {
-  const value = row.value;
+  const value = readRowValue(row, ctx);
   if (typeof value !== "string") return value;
   if (!isMemberString(member)) return value;
   if (isLocalizedStringMember(member) === false) return value;
@@ -76003,7 +76372,7 @@ function evaluateSystemNative(memberId, receiver, args, ctx) {
           `Tile placement '${tile.placementValueId}' is missing.`
         );
       }
-      return { handled: true, value: row.value };
+      return { handled: true, value: readRowValue(row, ctx) };
     }
     return evaluateCellPatternNative(memberId, receiver, args, {
       readPattern: (value) => readCellPattern(value, ctx),
@@ -78813,7 +79182,7 @@ function resolveVariantGraph(selection2, ctx) {
       `Variant '${record6.name}' has no root value row '${record6.valueId}'.`
     );
   }
-  const root = row.value;
+  const root = readRowValue(row, ctx);
   if (typeof root !== "object" || root === null || Array.isArray(root)) {
     throw new NSGetterRuntimeError(
       `Variant '${record6.name}' root row is not a class record.`
@@ -78886,19 +79255,21 @@ function resolveVariantRowParameter(args) {
     ctx.__runtimeSessionValues,
     ctx.__valueOverlay
   );
-  const isOrderedEntry = Array.isArray(collection?.value) ? collection.value.includes(rowId) : false;
+  const collectionValue = collection === null ? null : readRowValue(collection, ctx);
+  const isOrderedEntry = Array.isArray(collectionValue) ? collectionValue.includes(rowId) : false;
   const isUnorderedEntry = row.containerId === binding.collectionValueId;
   if (!isOrderedEntry && !isUnorderedEntry) {
     throw new NSGetterRuntimeError(
       `Lookup variant '${graph.name}' row '${rowId}' is not an entry of collection '${binding.collectionValueId}'.`
     );
   }
-  if (explicitPointer !== void 0 && rowValue !== row.value) {
+  const resolvedRowValue = readRowValue(row, ctx);
+  if (explicitPointer !== void 0 && rowValue !== resolvedRowValue) {
     throw new NSGetterRuntimeError(
       `Lookup variant '${graph.name}' received a value that does not resolve to bound row '${rowId}'.`
     );
   }
-  return [row.value];
+  return [resolvedRowValue];
 }
 function invokeVariantClosure(args) {
   const { closureValueId, ctx, label, lexicalThis, parameters } = args;
@@ -80306,7 +80677,7 @@ function constructorCollectionEntryValue(value, ctx, resolveStoredId) {
     ctx.__runtimeSessionValues,
     ctx.__valueOverlay
   );
-  return row === null ? value : row.value;
+  return row === null ? value : readRowValue(row, ctx);
 }
 function retainOnlyCreatedRowsReachableFrom(rootId, createdValues, ctx) {
   const byId = new Map(createdValues.map((row) => [row.id, row]));
@@ -80716,14 +81087,16 @@ function readOptionalMember(receiver, key, ctx) {
     const record6 = receiver;
     if (!Object.prototype.hasOwnProperty.call(record6, key)) return null;
     return resolveValueIfId(record6[key], ctx);
-  } catch {
+  } catch (error) {
+    if (error instanceof PendingInitializerDependency) throw error;
     return null;
   }
 }
 function collectionEntriesOrEmpty(value, ctx) {
   try {
     return collectionEntries(value, ctx);
-  } catch {
+  } catch (error) {
+    if (error instanceof PendingInitializerDependency) throw error;
     return [];
   }
 }
@@ -80816,6 +81189,8 @@ var DELEGATE_LEXICAL_THIS, DELEGATE_LEXICAL_ROOT, NonCatchableNSGetterRuntimeErr
 var init_evaluateNSGetter = __esm({
   "../src/runtime/neoscript/evaluateNSGetter.ts"() {
     "use strict";
+    init_project_root_members();
+    init_initializer_dependencies();
     init_unattributable_reads();
     init_value_row_owner_members();
     init_src();
@@ -84137,7 +84512,8 @@ function createHeadlessVirtualInstanceResolver(args) {
       readsByRootId.set(rootId, reads);
       remember(graph, rows);
       return rows;
-    } catch {
+    } catch (error) {
+      if (error instanceof PendingInitializerDependency) throw error;
       failedRootIds.add(rootId);
       return emptyRows;
     } finally {
@@ -84253,6 +84629,7 @@ var KEPT_ROW_SAMPLE_LIMIT, CORPUS_SCANNING_MEMBER_KINDS, VirtualExpansionUnsuppo
 var init_virtual_instance_graph = __esm({
   "../src/runtime/virtual-instance-graph.ts"() {
     "use strict";
+    init_initializer_dependencies();
     init_constructor_argument_ownership();
     init_classes();
     init_constructor_parameter_settlement();
@@ -84320,6 +84697,7 @@ function initializerEvaluatorLookups(document, readTracking) {
     const lookups2 = {
       memberById: (id2) => databaseVM.memberById(id2),
       valueById: (id2) => databaseVM.valueById(id2),
+      onInitializerRead: databaseVM.onInitializerRead,
       localizedTextById: (id2) => databaseVM.localizedTextById?.(id2) ?? null,
       ...databaseVM.hasStoredValueId === void 0 ? {} : {
         hasStoredValueId: (id2) => databaseVM.hasStoredValueId?.(id2) ?? false
@@ -84475,7 +84853,7 @@ function indexedInitializerEvaluatorLookups(document, key, revision) {
   });
   return lookups;
 }
-function createInitializerMaterializationBatch(authoredDocument) {
+function createInitializerMaterializationBatch(authoredDocument, pendingInitializerIds) {
   const indexed = createInitializerBatchLookups(authoredDocument);
   const unorderedListEntryIds2 = indexed.snapshot().unorderedListEntryIds;
   let materializedIndex;
@@ -84526,6 +84904,9 @@ function createInitializerMaterializationBatch(authoredDocument) {
     globalReads.delete(entry);
   };
   return {
+    get valuesById() {
+      return indexed.valuesById;
+    },
     upsert(rows) {
       const previousRows = [];
       const touched = /* @__PURE__ */ new Set();
@@ -84600,6 +84981,12 @@ function createInitializerMaterializationBatch(authoredDocument) {
       });
       const lookups = {
         ...base,
+        ...pendingInitializerIds === void 0 ? {} : {
+          onInitializerRead: (id2) => {
+            if (pendingInitializerIds.has(id2))
+              throw new PendingInitializerDependency(id2);
+          }
+        },
         valueById: (id2) => base.valueById(id2) ?? expandedById.get(id2) ?? virtual().valueById(id2),
         rowForValueReference: (value) => base.rowForValueReference(value) ?? expandedByReference.get(value) ?? virtual().rowForValueReference(value),
         virtualInstanceRowsForValue: (id2) => {
@@ -84666,7 +85053,8 @@ function buildInitializerRootValueWithLookups(document, lookups, tracking) {
       continue;
     }
     tracking?.valueDependencies?.add(targetId);
-    rootValue[root.key] = lookups.valueById(targetId)?.value ?? null;
+    const row = lookups.valueById(targetId);
+    rootValue[root.key] = row?.value ?? null;
   }
   return rootValue;
 }
@@ -84823,6 +85211,7 @@ var evaluatorLookupsByDocument, headlessResolversByLookupKey, indexedEvaluatorLo
 var init_evaluateInitializer = __esm({
   "../src/runtime/neoscript/evaluateInitializer.ts"() {
     "use strict";
+    init_initializer_dependencies();
     init_deep_clone_plain_data();
     init_members();
     init_instance_provenance();
@@ -93044,7 +93433,9 @@ function validateWorldPlacementSidecars(args) {
       `Placement value "${args.placement.id}" under layer link "${args.linkValueId}" must store a class record.`
     );
   }
-  const assetClassId = args.isTile ? requiredValueClassId(args.placement, "tile") : optionalNonEmptyString(record6.assetClassId);
+  const hasObjectSidecar = !args.isTile && WORLD_PLACEMENT_SIDECAR_KEYS.some((key) => Object.hasOwn(record6, key));
+  const objectClassId = hasObjectSidecar ? record6.assetClassId : args.placement.classId;
+  const assetClassId = args.isTile ? requiredValueClassId(args.placement, "tile") : optionalNonEmptyString(objectClassId);
   if (assetClassId === null) {
     throw new Error(
       `Class-backed placement value "${args.placement.id}" is missing assetClassId.`
@@ -93093,10 +93484,10 @@ function validateWorldPlacementSidecars(args) {
     assetClassId,
     placementId: args.placement.id,
     variantId: optionalNonEmptyString(
-      args.isTile ? getField(args.placement, "instanceVariantId") : record6.variantId
+      args.isTile || !hasObjectSidecar ? getField(args.placement, "instanceVariantId") : record6.variantId
     ),
     rowValueId: optionalNonEmptyString(
-      args.isTile ? getField(args.placement, "instanceVariantRowValueId") : record6.rowValueId
+      args.isTile || !hasObjectSidecar ? getField(args.placement, "instanceVariantRowValueId") : record6.rowValueId
     ),
     context: args.context
   });
@@ -95076,6 +95467,121 @@ var init_member_access_modifier_validation = __esm({
   }
 });
 
+// ../src/database/project-version-write-changes.ts
+function applyProjectVersionWriteChanges(document, changes) {
+  return projectVersionDocumentWithChanges(document, changes, false);
+}
+function projectVersionDocumentWithChanges(document, changes, reuseUnchangedBuckets) {
+  const projectRows = (rows, kind) => {
+    const relevant = changes.filter((change) => change.recordKind === kind);
+    if (reuseUnchangedBuckets && relevant.length === 0) return rows;
+    return applyArrayChanges(rows, relevant);
+  };
+  const hasGranularDialogueRecords = document.dialogueRecords !== void 0 || changes.some((change) => change.recordKind === "dialogue");
+  const hasGranularDialogueNodes = document.dialogueNodes !== void 0 || changes.some((change) => change.recordKind === "dialogue-node");
+  const dialogueRecords = hasGranularDialogueRecords ? projectRows(document.dialogueRecords ?? [], "dialogue") : void 0;
+  const dialogueNodes = hasGranularDialogueNodes ? projectRows(document.dialogueNodes ?? [], "dialogue-node") : void 0;
+  const projected = {
+    localizedTexts: projectRows(
+      document.localizedTexts ?? [],
+      "localized-text"
+    ),
+    localizationConfig: applySingletonChange(
+      document.localizationConfig,
+      changes,
+      "localization-config"
+    ),
+    project: applySingletonChange(document.project, changes, "project"),
+    members: projectRows(document.members, "member"),
+    classes: projectRows(document.classes, "class"),
+    // P43 §6. Declared constructors participate in the post-transaction
+    // document so the whole-graph validator and every body compile see the
+    // same constructor surface the transaction is about to persist.
+    constructors: projectRows(document.constructors ?? [], "constructor"),
+    // P67 §2.1. Same reason as constructors: without these buckets the
+    // whole-graph validator, the variant ownership roots, and every body
+    // compile would grade the transaction against the pre-transaction
+    // variant set — so a newly pushed variant's closures would compile
+    // against a document that does not contain it.
+    variants: projectRows(document.variants ?? [], "variant"),
+    variantFolders: projectRows(
+      document.variantFolders ?? [],
+      "variant-folder"
+    ),
+    values: projectRows(document.values ?? [], "value"),
+    // Project-file staging finalizes pending uploads before schema
+    // preparation. Defaults and authored instance graphs may reference a file
+    // created by the same source transaction, so every construction pass must
+    // see that finalized row in its post-write document.
+    projectFiles: projectRows(document.projectFiles ?? [], "project-file"),
+    // Import-setting templates are part of the same file graph. A new file
+    // may select a new template in one source transaction, and default-value
+    // materialization validates that relationship immediately against this
+    // post-write document.
+    textureTemplates: projectRows(
+      document.textureTemplates ?? [],
+      "unity-texture-template"
+    ),
+    audioClipTemplates: projectRows(
+      document.audioClipTemplates ?? [],
+      "unity-audio-clip-template"
+    ),
+    internalRecordRelations: projectRows(
+      document.internalRecordRelations ?? [],
+      "internal-record-relation"
+    ),
+    enums: projectRows(document.enums, "enum"),
+    interfaces: projectRows(document.interfaces, "interface"),
+    dialogues: dialogueRecords === void 0 || dialogueNodes === void 0 || dialogueRecords === document.dialogueRecords && dialogueNodes === document.dialogueNodes ? document.dialogues : materializeDialogues(
+      dialogueRecords,
+      dialogueNodes
+    ),
+    dialogueGroups: projectRows(
+      document.dialogueGroups ?? [],
+      "dialogue-group"
+    ),
+    migrations: projectRows(document.migrations ?? [], "migration")
+  };
+  return {
+    ...document,
+    ...projected,
+    ...dialogueRecords === void 0 ? {} : { dialogueRecords },
+    ...dialogueNodes === void 0 ? {} : { dialogueNodes }
+    // The document spread above carries every bucket the caller's view declares
+    // beyond the projected ones, so the result is the same view; TypeScript
+    // cannot prove that of an object literal built over a type parameter.
+  };
+}
+function applySingletonChange(current, changes, recordKind) {
+  const change = changes.find(
+    (candidate) => candidate.recordKind === recordKind
+  );
+  if (change === void 0) return current;
+  if (change.operation === "delete" || change.nextData === void 0) {
+    throw new Error(`Schema commit cannot delete the ${recordKind} record.`);
+  }
+  return change.nextData;
+}
+function applyArrayChanges(current, changes) {
+  const byId = new Map(current.map((record6) => [record6.id, record6]));
+  for (const change of changes) {
+    if (change.operation === "delete") {
+      byId.delete(change.recordId);
+      continue;
+    }
+    if (change.nextData !== void 0) {
+      byId.set(change.recordId, change.nextData);
+    }
+  }
+  return [...byId.values()];
+}
+var init_project_version_write_changes = __esm({
+  "../src/database/project-version-write-changes.ts"() {
+    "use strict";
+    init_projectDocumentDialogueMaterialization();
+  }
+});
+
 // ../src/database/member-localization-normalization.ts
 function planMemberLocalizationNormalization(input, now = 0) {
   const before = expandPackedDocumentValues(input);
@@ -95366,7 +95872,7 @@ var init_member_localization_normalization = __esm({
     init_constructor_argument_ownership();
     init_variant_value_graph();
     init_packed_value_write_fold();
-    init_project_version_schema_commit();
+    init_project_version_write_changes();
     init_packed_value_encoding();
     init_inheritance();
     init_members();
@@ -98052,37 +98558,49 @@ function materializePreparedInstanceInitializers(args) {
     materializationScope.document.localizedTexts.map((text) => text.id)
   );
   const replayOnlyIndexes = [];
+  const pendingSites = /* @__PURE__ */ new Map();
   for (const [valueId, site] of sites) {
     const existingRoot = existingValueById.get(valueId);
-    const existingConstructedRoot = existingRoot !== void 0 && isLiteralValueContent(existingRoot) && (typeof existingRoot.classId === "string" || existingRoot.constructorArgs !== void 0 && existingRoot.constructorArgs !== null);
-    if (rootKinds.get(valueId) === "declaration" && !existingConstructedRoot) {
+    const existingConstructedRoot = existingRoot !== void 0 && isLiteralValueContent(existingRoot) && (typeof existingRoot.classId === "string" || existingRoot.constructorArgs !== void 0 && existingRoot.constructorArgs !== null) ? existingRoot : void 0;
+    if (rootKinds.get(valueId) === "declaration" && !existingConstructedRoot)
       continue;
-    }
+    pendingSites.set(valueId, { ...site, existingConstructedRoot });
+  }
+  const pendingInitializerIds = new Set(pendingSites.keys());
+  if (pendingInitializerIds.size === 0) return;
+  const batch = createInitializerMaterializationBatch(
+    materializationScope.document,
+    pendingInitializerIds
+  );
+  materializeInitializerDependencies(pendingInitializerIds, (valueId) => {
+    const site = pendingSites.get(valueId);
+    const existingConstructedRoot = site.existingConstructedRoot;
     const member = owners.get(valueId);
     if (member === void 0) {
       throw new Error(
         `Value "${valueId}" carries an initializer but no ownership path resolves its declared member.`
       );
     }
+    const currentDocument = batch.document();
     const materialized = materializeInitializerValue2({
       // Every site that survives the declaration-default guard is source for
       // a persisted instance construction. The trusted replay mode both
       // admits Immutable storage and installs the concrete generic slot; the
       // CLI uses the same mode on the first push, so it cannot be conditional
       // on a literal row already existing.
-      document: materializationScope.document,
+      document: currentDocument,
       member,
       row: site.row,
       storedConstructionReplay: true
     });
-    if (existingConstructedRoot) {
-      if (!isLiteralValueContent(materialized.root) || existingRoot.classId !== materialized.root.classId || !replayedCreationDataMatches({
+    if (existingConstructedRoot !== void 0) {
+      if (!isLiteralValueContent(materialized.root) || existingConstructedRoot.classId !== materialized.root.classId || !replayedCreationDataMatches({
         // The synthetic variant binding members are part of the ownership
         // scope that compiled and evaluated this initializer. Stored replay
         // closes its generic slot from the same ephemeral member id, so its
         // expansion must read that scoped document too.
         currentReader: requireCurrentReader(),
-        currentRoot: existingRoot,
+        currentRoot: existingConstructedRoot,
         rootMember: member,
         replayRoot: materialized.root,
         replayCreated: materialized.createdValues
@@ -98092,10 +98610,11 @@ function materializePreparedInstanceInitializers(args) {
         );
       }
       replayOnlyIndexes.push(site.index);
-      continue;
+      batch.upsert([existingConstructedRoot]);
+      return;
     }
     const baseline = materializeInitializerValue2({
-      document: materializationScope.document,
+      document: currentDocument,
       member,
       row: {
         ...site.row,
@@ -98106,7 +98625,7 @@ function materializePreparedInstanceInitializers(args) {
     });
     const sparse2 = sparsifyConstructedInstance({
       localizedTextIds,
-      document: materializationScope.document,
+      document: currentDocument,
       rootMember: member,
       constructed: {
         root: materialized.root,
@@ -98122,7 +98641,7 @@ function materializePreparedInstanceInitializers(args) {
       pinnedRootSchemaKeys: materialized.pinnedRootSchemaKeys
     });
     const original = args.prepared[site.index];
-    if (original === void 0) continue;
+    if (original === void 0) return;
     args.prepared[site.index] = {
       ...original,
       nextData: sparse2.root
@@ -98163,7 +98682,8 @@ function materializePreparedInstanceInitializers(args) {
       });
       existingValueById.set(created.id, created);
     }
-  }
+    batch.upsert([sparse2.root, ...sparse2.createdChildren]);
+  });
   for (const index of replayOnlyIndexes.sort((left, right) => right - left)) {
     args.prepared.splice(index, 1);
   }
@@ -100590,16 +101110,38 @@ function prepareServerOwnedValueInitializerBodies(args) {
   }
 }
 function collectDelegateSweepRows(args) {
-  if (args.targetIds.size === 0) return [];
+  const closureRows = [];
+  const inlineRows = [];
+  if (args.targetIds.size === 0) return { closureRows, inlineRows };
   const preparedValueIds = indexChangesByRecordId(args.prepared, "value");
-  const sweepRows = [];
   for (const value of args.postDocument.values) {
     if (!args.targetIds.has(value.id)) continue;
     if (preparedValueIds.has(value.id)) continue;
     const row = delegateValueRow(value);
-    if (row !== null) sweepRows.push(row);
+    if (row !== null) {
+      closureRows.push(row);
+      continue;
+    }
+    const inlineRow = inlineDelegateSweepRow(value);
+    if (inlineRow !== null) inlineRows.push(inlineRow);
+  }
+  return { closureRows, inlineRows };
+}
+function inlineDelegateSweepRow(value) {
+  if (!isMemberValue(value) || !isLiteralValueContent(value)) return null;
+  const constructorArgs = asRecord4(
+    value.constructorArgs
+  );
+  if (constructorArgs === null) return null;
+  let sourceArgs = null;
+  for (const [key, argument2] of Object.entries(constructorArgs)) {
+    const closure = asRecord4(argument2);
+    if (typeof closure?.code !== "string") continue;
+    if (!("action" in closure)) continue;
+    sourceArgs ??= { ...constructorArgs };
+    sourceArgs[key] = { code: closure.code };
   }
-  return sweepRows;
+  return sourceArgs === null ? null : { ...value, constructorArgs: sourceArgs };
 }
 function delegateValueRow(value) {
   if (!isMemberValue(value) || !isLiteralValueContent(value)) return null;
@@ -100746,8 +101288,8 @@ function prepareServerOwnedDelegateValueBodies(args) {
     const withInlineArgs = inlineDelegateArgumentRow(change.nextData);
     if (withInlineArgs !== null) inlineArgumentRows.set(index, withInlineArgs);
   }
-  const sweepRows = collectDelegateSweepRows(args);
-  if (explicitRows.size === 0 && sweepRows.length === 0 && inlineArgumentRows.size === 0) {
+  const { closureRows: sweepRows, inlineRows: inlineSweepRows } = collectDelegateSweepRows(args);
+  if (explicitRows.size === 0 && sweepRows.length === 0 && inlineArgumentRows.size === 0 && inlineSweepRows.length === 0) {
     return;
   }
   const committedDocument = applyProjectVersionWriteChanges(
@@ -100756,7 +101298,7 @@ function prepareServerOwnedDelegateValueBodies(args) {
   );
   const targetIds = valueIdsFromRows(
     [...explicitRows.values(), ...inlineArgumentRows.values()],
-    sweepRows
+    [...sweepRows, ...inlineSweepRows]
   );
   const rootOwnerByValueId = /* @__PURE__ */ new Map();
   const delegateScope = withVariantOwnershipRoots(
@@ -100831,7 +101373,7 @@ function prepareServerOwnedDelegateValueBodies(args) {
       };
     }
   }
-  if (sweepRows.length === 0) return;
+  if (sweepRows.length === 0 && inlineSweepRows.length === 0) return;
   const currentById = new Map(
     args.document.values.map((value) => [value.id, value])
   );
@@ -100841,40 +101383,65 @@ function prepareServerOwnedDelegateValueBodies(args) {
     prepared: args.prepared,
     contentHashHeads: args.contentHashHeads
   });
+  const refresh = (id2, compiled) => {
+    const current = currentById.get(id2);
+    if (current === void 0 || canonicallyEqual2(current, compiled)) return;
+    const contentHash = baseHashFor(id2);
+    if (contentHash === void 0) {
+      throw new Error(
+        `Cannot safely refresh the compiled NeoDelegate closure for value "${id2}": its current content hash is unavailable.`
+      );
+    }
+    args.prepared.push({
+      recordKind: "value",
+      recordId: id2,
+      operation: "update",
+      nextData: compiled,
+      intent: createProjectVersionIntent("value.update", {
+        source: "server-neoscript-recompile"
+      }),
+      ...contentHash === null ? {} : { expectedBaseContentHash: contentHash }
+    });
+  };
   for (const row of sweepRows) {
     const compiled = { ...row, value: { ...row.value } };
     try {
       compileOne(delegateScope.document, compiled);
     } catch (postWriteError) {
-      const current2 = delegateValueRow(
+      const current = delegateValueRow(
         structuredClone(currentById.get(row.id))
       );
-      if (current2 === null) throw postWriteError;
+      if (current === null) throw postWriteError;
       try {
-        compileOne(args.document, current2);
+        compileOne(args.document, current);
       } catch (preWriteError) {
         if (sameCompileFailure(preWriteError, postWriteError)) continue;
       }
       throw postWriteError;
     }
-    const current = currentById.get(row.id);
-    if (current === void 0 || canonicallyEqual2(current, compiled)) continue;
-    const contentHash = baseHashFor(row.id);
-    if (contentHash === void 0) {
-      throw new Error(
-        `Cannot safely refresh the compiled NeoDelegate closure for value "${row.id}": its current content hash is unavailable.`
-      );
+    refresh(row.id, compiled);
+  }
+  const compileInlineOne = (document, row) => compileInlineDelegateConstructorArguments({
+    document,
+    row,
+    ownerMember: ownerByValueId.get(row.id),
+    rootOwner: rootOwnerByValueId.get(row.id) ?? null
+  });
+  for (const row of inlineSweepRows) {
+    let compiledArgs;
+    try {
+      compiledArgs = compileInlineOne(delegateScope.document, row);
+    } catch (postWriteError) {
+      const current = inlineDelegateSweepRow(currentById.get(row.id));
+      if (current === null) throw postWriteError;
+      try {
+        compileInlineOne(args.document, current);
+      } catch (preWriteError) {
+        if (sameCompileFailure(preWriteError, postWriteError)) continue;
+      }
+      throw postWriteError;
     }
-    args.prepared.push({
-      recordKind: "value",
-      recordId: row.id,
-      operation: "update",
-      nextData: compiled,
-      intent: createProjectVersionIntent("value.update", {
-        source: "server-neoscript-recompile"
-      }),
-      ...contentHash === null ? {} : { expectedBaseContentHash: contentHash }
-    });
+    refresh(row.id, { ...row, constructorArgs: compiledArgs });
   }
 }
 function prepareServerOwnedConstructorBodies(args) {
@@ -101129,113 +101696,6 @@ function assertUniqueChanges(changes) {
     }
   }
 }
-function applyProjectVersionWriteChanges(document, changes) {
-  return projectVersionDocumentWithChanges(document, changes, false);
-}
-function projectVersionDocumentWithChanges(document, changes, reuseUnchangedBuckets) {
-  const projectRows = (rows, kind) => {
-    const relevant = changes.filter((change) => change.recordKind === kind);
-    if (reuseUnchangedBuckets && relevant.length === 0) return rows;
-    return applyArrayChanges(rows, relevant);
-  };
-  const hasGranularDialogueRecords = document.dialogueRecords !== void 0 || changes.some((change) => change.recordKind === "dialogue");
-  const hasGranularDialogueNodes = document.dialogueNodes !== void 0 || changes.some((change) => change.recordKind === "dialogue-node");
-  const dialogueRecords = hasGranularDialogueRecords ? projectRows(document.dialogueRecords ?? [], "dialogue") : void 0;
-  const dialogueNodes = hasGranularDialogueNodes ? projectRows(document.dialogueNodes ?? [], "dialogue-node") : void 0;
-  const projected = {
-    localizedTexts: projectRows(
-      document.localizedTexts ?? [],
-      "localized-text"
-    ),
-    localizationConfig: applySingletonChange(
-      document.localizationConfig,
-      changes,
-      "localization-config"
-    ),
-    project: applySingletonChange(document.project, changes, "project"),
-    members: projectRows(document.members, "member"),
-    classes: projectRows(document.classes, "class"),
-    // P43 §6. Declared constructors participate in the post-transaction
-    // document so the whole-graph validator and every body compile see the
-    // same constructor surface the transaction is about to persist.
-    constructors: projectRows(document.constructors ?? [], "constructor"),
-    // P67 §2.1. Same reason as constructors: without these buckets the
-    // whole-graph validator, the variant ownership roots, and every body
-    // compile would grade the transaction against the pre-transaction
-    // variant set — so a newly pushed variant's closures would compile
-    // against a document that does not contain it.
-    variants: projectRows(document.variants ?? [], "variant"),
-    variantFolders: projectRows(
-      document.variantFolders ?? [],
-      "variant-folder"
-    ),
-    values: projectRows(document.values ?? [], "value"),
-    // Project-file staging finalizes pending uploads before schema
-    // preparation. Defaults and authored instance graphs may reference a file
-    // created by the same source transaction, so every construction pass must
-    // see that finalized row in its post-write document.
-    projectFiles: projectRows(document.projectFiles ?? [], "project-file"),
-    // Import-setting templates are part of the same file graph. A new file
-    // may select a new template in one source transaction, and default-value
-    // materialization validates that relationship immediately against this
-    // post-write document.
-    textureTemplates: projectRows(
-      document.textureTemplates ?? [],
-      "unity-texture-template"
-    ),
-    audioClipTemplates: projectRows(
-      document.audioClipTemplates ?? [],
-      "unity-audio-clip-template"
-    ),
-    internalRecordRelations: projectRows(
-      document.internalRecordRelations ?? [],
-      "internal-record-relation"
-    ),
-    enums: projectRows(document.enums, "enum"),
-    interfaces: projectRows(document.interfaces, "interface"),
-    dialogues: dialogueRecords === void 0 || dialogueNodes === void 0 || dialogueRecords === document.dialogueRecords && dialogueNodes === document.dialogueNodes ? document.dialogues : materializeDialogues(
-      dialogueRecords,
-      dialogueNodes
-    ),
-    dialogueGroups: projectRows(
-      document.dialogueGroups ?? [],
-      "dialogue-group"
-    ),
-    migrations: projectRows(document.migrations ?? [], "migration")
-  };
-  return {
-    ...document,
-    ...projected,
-    ...dialogueRecords === void 0 ? {} : { dialogueRecords },
-    ...dialogueNodes === void 0 ? {} : { dialogueNodes }
-    // The document spread above carries every bucket the caller's view declares
-    // beyond the projected ones, so the result is the same view; TypeScript
-    // cannot prove that of an object literal built over a type parameter.
-  };
-}
-function applySingletonChange(current, changes, recordKind) {
-  const change = changes.find(
-    (candidate) => candidate.recordKind === recordKind
-  );
-  if (change === void 0) return current;
-  if (change.operation === "delete" || change.nextData === void 0) {
-    throw new Error(`Schema commit cannot delete the ${recordKind} record.`);
-  }
-  return change.nextData;
-}
-function applyArrayChanges(current, changes) {
-  const byId = new Map(current.map((record6) => [record6.id, record6]));
-  for (const change of changes) {
-    if (change.operation === "delete") {
-      byId.delete(change.recordId);
-      continue;
-    }
-    if (change.nextData !== void 0) {
-      byId.set(change.recordId, change.nextData);
-    }
-  }
-  return [...byId.values()];
-}
 function asRecord4(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
     return null;
@@ -101426,11 +101886,11 @@ var init_project_version_schema_commit = __esm({
     init_variants2();
     init_effective_value_reader();
     init_materialize_values();
+    init_initializer_dependencies();
     init_neoscript2();
     init_evaluateInitializer();
     init_virtual_instance_graph();
     init_virtual_instance_values();
-    init_projectDocumentDialogueMaterialization();
     init_valueHeadPlacementGraph();
     init_canonical_json();
     init_compile_ns_property();
@@ -101455,6 +101915,7 @@ var init_project_version_schema_commit = __esm({
     init_project_version_relation_sweep_trigger();
     init_project_version_static_value_writes();
     init_project_version_transaction_planning();
+    init_project_version_write_changes();
     init_value_row_owner_members();
     init_variant_value_graph();
     SERVER_COMPILATION_PROJECT_CACHE_LIMIT = 4;
@@ -101562,6 +102023,7 @@ var init_animation_clips = __esm({
   "../src/models/animation/animation-clips.ts"() {
     "use strict";
     init_inheritance();
+    init_read_class_member();
     init_generics();
     init_world_system_classes();
     init_member_kinds();
@@ -102580,14 +103042,7 @@ var init_animation_clips = __esm({
        * when it is dangling, then the member default, then the retained value row.
        */
       listFieldIds(parent, field) {
-        const mapped = isRecord6(parent.value) ? parent.value[field.schemaKey] : null;
-        if (typeof mapped === "string") {
-          return this.valueById.get(mapped)?.value;
-        }
-        if (field.member.defaultValue !== void 0) {
-          return field.member.defaultValue.value;
-        }
-        return typeof field.member.valueId === "string" ? this.valueById.get(field.member.valueId)?.value : void 0;
+        return this.fieldValue(parent, field);
       }
       /** Class a list's rows carry when a row omits its own `classId`. */
       listEntryClassId(member) {
@@ -102637,11 +103092,21 @@ var init_animation_clips = __esm({
       }
       scalarField(parent, classId, memberId) {
         const field = this.requireField(classId, memberId, `Class "${classId}"`);
-        const mapped = isRecord6(parent.value) ? parent.value[field.schemaKey] : null;
-        if (typeof mapped === "string") {
-          return this.valueById.get(mapped)?.value;
+        return this.fieldValue(parent, field);
+      }
+      fieldValue(parent, field) {
+        const slot = readClassMember({
+          member: field.member,
+          schemaKey: field.schemaKey,
+          record: isRecord6(parent.value) ? parent.value : {},
+          expandedRecord: () => null,
+          mode: "declaration"
+        });
+        if (slot.kind === "declaration") return slot.content.value;
+        if (slot.kind === "value") {
+          return typeof slot.value === "string" ? this.valueById.get(slot.value)?.value : slot.value;
         }
-        return field.member.defaultValue?.value;
+        return typeof field.member.valueId === "string" ? this.valueById.get(field.member.valueId)?.value : void 0;
       }
       requireNodeClassId(node, expectedWorldKind) {
         if (typeof node.classId !== "string" || !this.classHasWorldKind(node.classId, expectedWorldKind)) {
@@ -102680,7 +103145,13 @@ var init_animation_clips = __esm({
         );
         if (entry === void 0) return null;
         const member = this.memberById.get(entry.memberId);
-        return member === void 0 ? null : { ...entry, member };
+        return member === void 0 ? null : {
+          ...entry,
+          member: {
+            ...member,
+            ...resolveMember2(member, this.document.members)
+          }
+        };
       }
       requireField(classId, memberId, label) {
         const field = this.field(classId, memberId);
@@ -104279,7 +104750,7 @@ function assertProjectInterfaceDocumentValid(view, options = {}) {
         `Read-only member "${member.name}" (${member.id}) must declare Immutable storage; ${ownerLabel}.`
       );
     }
-    if (!isAbstractMember(member) && resolved.kind !== 21 && (resolved.defaultValue === void 0 || resolved.defaultValue === null)) {
+    if (!isAbstractMember(resolved) && resolved.kind !== 21 && (resolved.defaultValue === void 0 || resolved.defaultValue === null)) {
       throw new Error(
         `Read-only member "${member.name}" (${member.id}) requires an explicit defaultValue; ${ownerLabel}.`
       );
@@ -104343,7 +104814,7 @@ function assertProjectInterfaceDocumentValid(view, options = {}) {
               `Read-only member "${member.name}" (${member.id}) must be value-bearing in every closed Generic placement; ${ownerLabel}.`
             );
           }
-          if (isAbstractMember(member)) return;
+          if (isAbstractMember(inherited)) return;
           if (owned.defaultValue === void 0 || owned.defaultValue === null) {
             throw new Error(
               `Read-only member "${member.name}" (${member.id}) requires an explicit defaultValue from every closed Generic binding; ${ownerLabel}.`
@@ -104361,7 +104832,7 @@ function assertProjectInterfaceDocumentValid(view, options = {}) {
           }
         }
       }
-      if (rawOwned.id === member.id && isAbstractMember(member)) return;
+      if (rawOwned.id === member.id && isAbstractMember(inherited)) return;
       if (owned.storage === 2 /* Save */ || owned.storage === 3 /* Session */ || owned.storage === 4 /* Writable */) {
         throw new Error(
           `Read-only member "${member.name}" has a non-Immutable owned default child "${owned.name}"; ${ownerLabel}.`
@@ -106506,7 +106977,10 @@ function assertProjectVersionWholeGraphWritesValid(args) {
   assertStagedInternalRecordRelationsValid(args.document, projected, changes);
   assertStagedWorldContentLayerBindingsValid(args.document, projected, changes);
   assertAnimationClipDocumentValid(
-    materializeDeclarationInitializersForAnimationValidation(projected),
+    materializeDeclarationInitializersForAnimationValidation(
+      projected,
+      args.animationValidationMemberIds
+    ),
     args.animationValidationMemberIds === void 0 ? void 0 : { memberIds: args.animationValidationMemberIds }
   );
   if (args.operation === void 0 || !isSystemOwnedProjectVersionOperation(args.operation)) {
@@ -106624,7 +107098,71 @@ function valueDematerializationRefusal(args) {
   }
   return null;
 }
-function materializeDeclarationInitializersForAnimationValidation(document) {
+function animationRootsInValidationScope(args) {
+  const {
+    document,
+    valuesById,
+    animationFamilyClassIds,
+    animationRoots,
+    scopeMemberIds
+  } = args;
+  if (scopeMemberIds === void 0 || animationRoots.length === 0) {
+    return animationRoots;
+  }
+  const segmentIds = new Set(
+    [...valuesById.values()].flatMap(
+      (row) => typeof row.classId === "string" && animationFamilyClassIds.get(row.classId) === "animationSegment" ? [row.id] : []
+    )
+  );
+  const placements = findSemanticOwnerPlacementsForValues(
+    document,
+    /* @__PURE__ */ new Set([...animationRoots.map((row) => row.id), ...segmentIds]),
+    void 0,
+    true
+  );
+  const segmentAncestors = /* @__PURE__ */ new Set();
+  for (const segmentId of segmentIds) {
+    let id2 = segmentId;
+    while (id2 !== null && !segmentAncestors.has(id2)) {
+      segmentAncestors.add(id2);
+      id2 = placements.get(id2)?.parentValueId ?? null;
+    }
+  }
+  const insideValidatedRootById = /* @__PURE__ */ new Map();
+  return animationRoots.filter((row) => {
+    if (segmentAncestors.has(row.id)) return true;
+    let id2 = row.id;
+    const path = [];
+    const seen = /* @__PURE__ */ new Set();
+    let insideValidatedRoot = false;
+    while (id2 !== null && !seen.has(id2)) {
+      const cached = insideValidatedRootById.get(id2);
+      if (cached !== void 0) {
+        insideValidatedRoot = cached;
+        break;
+      }
+      if (segmentIds.has(id2)) {
+        insideValidatedRoot = true;
+        break;
+      }
+      seen.add(id2);
+      path.push(id2);
+      const placement = placements.get(id2);
+      if (placement === void 0) break;
+      if (placement.parentValueId === null) {
+        const memberId = getField(placement.member, "id");
+        insideValidatedRoot = typeof memberId === "string" && scopeMemberIds.has(memberId);
+        break;
+      }
+      id2 = placement.parentValueId;
+    }
+    for (const valueId of path) {
+      insideValidatedRootById.set(valueId, insideValidatedRoot);
+    }
+    return insideValidatedRoot;
+  });
+}
+function materializeDeclarationInitializersForAnimationValidation(document, scopeMemberIds) {
   const animationFamilyClassIds = animationFamilyClassKinds(document.classes);
   const initializers = document.values.filter(
     (value) => isInitValueContent(value)
@@ -106637,12 +107175,13 @@ function materializeDeclarationInitializersForAnimationValidation(document) {
   if (initializers.length === 0 && defaultInitializerMemberIds.size === 0) {
     return document;
   }
+  const initializerRootOwners = /* @__PURE__ */ new Map();
   const rootKinds = /* @__PURE__ */ new Map();
   const owners = resolveSemanticOwnerMembersForValues(
     document,
     new Set(initializers.map((value) => value.id)),
     void 0,
-    void 0,
+    initializerRootOwners,
     rootKinds
   );
   const valuesById = new Map(
@@ -106651,6 +107190,7 @@ function materializeDeclarationInitializersForAnimationValidation(document) {
   const materializationBatch = createInitializerMaterializationBatch(document);
   let members = document.members;
   const deferred = /* @__PURE__ */ new Set();
+  const parameterizedDeclarationMemberIds = /* @__PURE__ */ new Set();
   if (defaultInitializerMemberIds.size > 0) {
     members = document.members.map((member) => {
       if (!defaultInitializerMemberIds.has(member.id)) return member;
@@ -106658,6 +107198,7 @@ function materializeDeclarationInitializersForAnimationValidation(document) {
       if (!isInitValueContent(defaultValue)) return member;
       const parameters = defaultValue.init.compiled?.parameters;
       if (parameters === void 0 || parameters.length > 2) {
+        parameterizedDeclarationMemberIds.add(member.id);
         const deferredMember = { ...member };
         delete deferredMember.defaultValue;
         delete deferredMember.valueId;
@@ -106696,6 +107237,11 @@ function materializeDeclarationInitializersForAnimationValidation(document) {
     const parameters = row.init.compiled?.parameters;
     if (parameters === void 0 || parameters.length > 2) {
       deferred.add(row.id);
+      const rootOwner = initializerRootOwners.get(row.id);
+      const rootOwnerId = rootOwner === void 0 ? void 0 : getField(rootOwner, "id");
+      if (typeof rootOwnerId === "string") {
+        parameterizedDeclarationMemberIds.add(rootOwnerId);
+      }
       continue;
     }
     const materialized = materializeInitializerValue2({
@@ -106712,6 +107258,73 @@ function materializeDeclarationInitializersForAnimationValidation(document) {
       valuesById.set(created.id, created);
     }
   }
+  const expandedRows = /* @__PURE__ */ new Map();
+  const classesById = new Map(
+    document.classes.map((entry) => [entry.id, entry])
+  );
+  const membersById = new Map(
+    document.members.map((entry) => [entry.id, entry])
+  );
+  const classNeedsExpansion = /* @__PURE__ */ new Map();
+  const memberHasParameterizedDefault = /* @__PURE__ */ new Map();
+  const reachesParameterizedDefault = (memberId) => {
+    const path = [];
+    const visited = /* @__PURE__ */ new Set();
+    let currentId = memberId;
+    let result = false;
+    while (currentId !== void 0 && !visited.has(currentId)) {
+      const cached = memberHasParameterizedDefault.get(currentId);
+      if (cached !== void 0) {
+        result = cached;
+        break;
+      }
+      if (parameterizedDeclarationMemberIds.has(currentId)) {
+        result = true;
+        break;
+      }
+      visited.add(currentId);
+      path.push(currentId);
+      currentId = membersById.get(currentId)?.extendsMemberId;
+    }
+    for (const id2 of path) memberHasParameterizedDefault.set(id2, result);
+    return result;
+  };
+  const inheritsParameterizedDefault = (classId) => {
+    const cached = classNeedsExpansion.get(classId);
+    if (cached !== void 0) return cached;
+    const schemaClass2 = classesById.get(classId);
+    if (schemaClass2 === void 0) return false;
+    classNeedsExpansion.set(classId, false);
+    for (const memberId of Object.values(schemaClass2.schema)) {
+      if (reachesParameterizedDefault(memberId)) {
+        classNeedsExpansion.set(classId, true);
+        return true;
+      }
+    }
+    const result = typeof schemaClass2.extendsClassId === "string" && inheritsParameterizedDefault(schemaClass2.extendsClassId);
+    classNeedsExpansion.set(classId, result);
+    return result;
+  };
+  const animationRoots = parameterizedDeclarationMemberIds.size === 0 ? [] : [...valuesById.values()].filter(
+    (row) => isLiteralValueContent(row) && isVirtualInstanceRootShape(row) && typeof row.classId === "string" && animationFamilyClassIds.has(row.classId) && inheritsParameterizedDefault(row.classId)
+  );
+  const rootsToExpand = animationRootsInValidationScope({
+    document,
+    valuesById,
+    animationFamilyClassIds,
+    animationRoots,
+    scopeMemberIds
+  });
+  if (rootsToExpand.length > 0) {
+    const lookups = initializerEvaluatorLookups(
+      materializationBatch.document()
+    );
+    for (const root of rootsToExpand) {
+      for (const row of lookups.virtualInstanceRowsForValue(root.id)) {
+        expandedRows.set(row.id, row);
+      }
+    }
+  }
   if (deferred.size > 0) {
     for (const id2 of deferred) valuesById.delete(id2);
     members = members.map((member) => {
@@ -106803,6 +107416,9 @@ function materializeDeclarationInitializersForAnimationValidation(document) {
       }
     }
   }
+  for (const [id2, row] of expandedRows) {
+    if (!deferred.has(id2)) valuesById.set(id2, row);
+  }
   return { ...document, members, values: [...valuesById.values()] };
 }
 function containsDirectValueId(value, ids) {
@@ -107537,10 +108153,11 @@ var init_project_version_whole_graph_validation = __esm({
     init_project_root_members();
     init_project_schema_identifier_validation();
     init_packed_value_write_fold();
-    init_project_version_schema_commit();
+    init_project_version_write_changes();
     init_project_version_system_protection_writes();
     init_reserved_record_id_validation();
     init_members();
+    init_instance_provenance();
     init_generics();
     init_inheritance();
     init_neoscript();
@@ -110872,29 +111489,25 @@ function lowerExpressionValue(context, expression, declaredExpected, ownerClass,
     }
     case "litDict": {
       const valueType = expected.arguments[1] ?? expected;
+      const keyType = expected.arguments[0];
+      const keyEnumId = context.enumIdsByName.get(keyType?.name ?? "");
+      const keyEnum = keyEnumId === void 0 ? null : {
+        name: keyType.name,
+        optionsByName: context.enumOptionsByName.get(keyEnumId) ?? /* @__PURE__ */ new Map()
+      };
       const value = {};
       for (const entry of expression.entries) {
         if (positionRequiresEvaluation(
           context,
           entry.key,
-          DICTIONARY_KEY_TYPE,
+          keyType ?? expected,
           ownerClass
         )) {
           throw new Error(
-            `Dictionary key at ${path} is a computed expression. Dictionary keys must be string literals.`
+            `Dictionary key at ${path} is a computed expression. Dictionary keys must be ${keyEnum === null ? "string literals" : "enum options or quoted option IDs"}.`
           );
         }
-        const key = lowerExpressionValue(
-          context,
-          entry.key,
-          DICTIONARY_KEY_TYPE,
-          ownerClass,
-          path,
-          genericEnvironment,
-          sourceText
-        );
-        if (typeof key !== "string")
-          throw new Error("Dictionary keys must be strings.");
+        const key = lowerDictionaryKey(entry.key, keyEnum, path);
         value[key] = lowerExpressionValue(
           context,
           entry.value,
@@ -112017,7 +112630,7 @@ function variantPathSegments2(expression) {
   if (segments.length < 3) return null;
   return segments;
 }
-var UNSET_LIST_COLUMN_WIDTH, EMPTY_GENERIC_TYPE_ENVIRONMENT, DICTIONARY_KEY_TYPE, STRUCTURED_LEAF_COMPONENT_TYPE, primitiveMemberKinds;
+var UNSET_LIST_COLUMN_WIDTH, EMPTY_GENERIC_TYPE_ENVIRONMENT, STRUCTURED_LEAF_COMPONENT_TYPE, primitiveMemberKinds;
 var init_lower_members = __esm({
   "src/project-source/lower-members.ts"() {
     "use strict";
@@ -112036,13 +112649,9 @@ var init_lower_members = __esm({
     init_member_kind_type_names();
     init_source_diagnostics();
     init_key_reference_spelling();
+    init_dictionary_enum_keys();
     UNSET_LIST_COLUMN_WIDTH = -1;
     EMPTY_GENERIC_TYPE_ENVIRONMENT = /* @__PURE__ */ new Map();
-    DICTIONARY_KEY_TYPE = {
-      name: "string",
-      nullable: false,
-      arguments: []
-    };
     STRUCTURED_LEAF_COMPONENT_TYPE = {
       name: "float",
       nullable: false,
@@ -116300,6 +116909,23 @@ var init_neoscript_build_cache = __esm({
 });
 
 // src/project-source/local-initializer-materialization.ts
+function initializerRecompileTargets(args) {
+  return collectNeoScriptRecompileTargets({
+    currentDocument: args.currentDocument,
+    postDocument: args.postDocument,
+    forceRecompile: args.forceRecompile,
+    changes: args.changes.map((change) => {
+      const operation = "operation" in change ? change.operation : change.kind;
+      return {
+        recordKind: change.recordKind,
+        recordId: change.recordId,
+        operation,
+        ...operation === "delete" ? { deleted: true } : {},
+        ...change.nextData === void 0 ? {} : { nextData: change.nextData }
+      };
+    })
+  });
+}
 function materializedInitializerReconciliationFailuresV4(args) {
   if (args.reconciliations.size === 0) return [];
   const records2 = reconciliationRecords(
@@ -116310,17 +116936,11 @@ function materializedInitializerReconciliationFailuresV4(args) {
   const document = readPulledProjectDocumentV4(records2);
   const currentRecords = reconciliationRecords(args.workspace, []);
   const currentDocument = readPulledProjectDocumentV4(currentRecords);
-  const recompileTargets = collectNeoScriptRecompileTargets({
+  const recompileTargets = initializerRecompileTargets({
     currentDocument,
     postDocument: document,
     forceRecompile: args.forceRecompile,
-    changes: args.changes.map((change) => ({
-      recordKind: change.recordKind,
-      recordId: change.recordId,
-      operation: change.kind,
-      ...change.kind === "delete" ? { deleted: true } : {},
-      ...change.nextData === void 0 ? {} : { nextData: change.nextData }
-    }))
+    changes: args.changes
   });
   const reconciliationByValueId = /* @__PURE__ */ new Map();
   const candidateValueIds = /* @__PURE__ */ new Set();
@@ -116393,8 +117013,14 @@ function materializedInitializerReconciliationFailuresV4(args) {
   let compilationProject;
   if (replayableValueIds.size > 0) {
     compilationProject = args.useBuildCaches === false ? createNeoScriptCompilationProject(document) : loadOrBuildNeoScriptProjectV1(args.workspace.root, document);
+    compilePulledProjectDocumentForEvaluationV4(
+      document,
+      compilationProject,
+      recompileTargets
+    );
   }
-  const replayContext = replayableValueIds.size > 0 ? createPulledConstructionReplayContext({ document }) : void 0;
+  const replayDocument = replayableValueIds.size > 0 ? { ...document } : document;
+  const replayContext = replayableValueIds.size > 0 ? createPulledConstructionReplayContext({ document: replayDocument }) : void 0;
   let currentRows;
   let currentReader;
   const failures = [];
@@ -116429,7 +117055,7 @@ function materializedInitializerReconciliationFailuresV4(args) {
     const replayRows = /* @__PURE__ */ new Map();
     for (const [id2, row] of replayStoredConstructionV4({
       records: records2,
-      document,
+      document: replayDocument,
       replayContext,
       valueId: reconciliation.valueId,
       code: reconciliation.code,
@@ -116443,9 +117069,9 @@ function materializedInitializerReconciliationFailuresV4(args) {
       }
       replayRows.set(id2, row);
     }
-    assertPulledConstructorsCompiled(document, replayContext);
+    assertPulledConstructorsCompiled(replayDocument, replayContext);
     currentRows ??= new Map(currentDocument.values.map((row) => [row.id, row]));
-    currentReader ??= new EffectiveValueReader(document, currentRows);
+    currentReader ??= new EffectiveValueReader(replayDocument, currentRows);
     const replay = replayRows.get(reconciliation.valueId);
     const replayArgs = replay !== void 0 && isLiteralValueContent(replay) ? replay.constructorArgs : void 0;
     const currentRoot = currentRows.get(reconciliation.valueId);
@@ -116503,10 +117129,10 @@ function materializeInitializersLocallyV4(args) {
     readPulledProjectDocumentV4(records2),
     variantOwnershipRootRecords(records2)
   );
-  let document = variantScope.document;
+  const authoredDocument = variantScope.document;
   const rootKinds = /* @__PURE__ */ new Map();
   const rootOwners = resolveSemanticOwnerMembersForValues(
-    document,
+    authoredDocument,
     sourceRoots,
     variantScope.roots,
     void 0,
@@ -116514,19 +117140,73 @@ function materializeInitializersLocallyV4(args) {
   );
   const roots = [];
   const localizedTextIds = new Set(
-    document.localizedTexts?.map((text) => text.id)
+    authoredDocument.localizedTexts?.map((text) => text.id)
   );
-  let compilationProject;
-  for (const sourceValueId of [...sourceRoots].sort()) {
-    if (rootKinds.get(sourceValueId) === "declaration") continue;
+  const pendingRoots = new Set(
+    [...sourceRoots].filter((id2) => rootKinds.get(id2) !== "declaration").sort()
+  );
+  if (pendingRoots.size === 0) return { roots };
+  const compilationProject = createNeoScriptCompilationProject(authoredDocument);
+  const changedBodies = {
+    memberIds: /* @__PURE__ */ new Set(),
+    constructorIds: /* @__PURE__ */ new Set()
+  };
+  for (const change of args.changes) {
+    if (change.operation === "delete") continue;
+    if (change.recordKind === "member") {
+      changedBodies.memberIds.add(change.recordId);
+    } else if (change.recordKind === "constructor") {
+      changedBodies.constructorIds.add(change.recordId);
+    }
+  }
+  const needsDependentBodies = args.forceRecompile === true || args.changes.some(
+    (change) => ["class", "member", "constructor", "enum", "interface"].includes(
+      change.recordKind
+    )
+  );
+  if (needsDependentBodies) {
+    const currentDocument = readPulledProjectDocumentV4(
+      reconciliationRecords(args.workspace, [])
+    );
+    const dependentBodies = initializerRecompileTargets({
+      currentDocument,
+      postDocument: authoredDocument,
+      changes: args.changes,
+      forceRecompile: args.forceRecompile
+    });
+    for (const id2 of dependentBodies.memberIds) changedBodies.memberIds.add(id2);
+    for (const id2 of dependentBodies.constructorIds) {
+      changedBodies.constructorIds.add(id2);
+    }
+  }
+  compilePulledProjectDocumentForEvaluationV4(
+    authoredDocument,
+    compilationProject,
+    changedBodies
+  );
+  assertPulledConstructorsCompiled(authoredDocument);
+  const batch = createInitializerMaterializationBatch(
+    authoredDocument,
+    pendingRoots
+  );
+  const compiledInitializers = /* @__PURE__ */ new Map();
+  materializeInitializerDependencies(pendingRoots, (sourceValueId) => {
+    const batchDocument = batch.document();
+    const document = {
+      ...authoredDocument,
+      values: batchDocument.values,
+      databaseVM: batchDocument.databaseVM
+    };
     const rootOwner = rootOwners.get(sourceValueId);
     if (rootOwner === void 0) {
       throw new Error(
         `CLI initializer materialization cannot resolve the owning member for root "${sourceValueId}".`
       );
     }
-    compilationProject ??= createNeoScriptCompilationProject(document);
-    const replayContext = createPulledConstructionReplayContext({ document });
+    const replayContext = createPulledConstructionReplayContext({
+      document,
+      valuesById: batch.valuesById
+    });
     const code = initializerCode(records2, sourceValueId);
     let compiledInitializer;
     let pinnedRootSchemaKeys = /* @__PURE__ */ new Set();
@@ -116538,8 +117218,10 @@ function materializeInitializersLocallyV4(args) {
       compilationProject,
       replayContext,
       member: rootOwner,
+      compiledInitializer: compiledInitializers.get(sourceValueId),
       onCompiledInitializer: (init) => {
         compiledInitializer = init;
+        compiledInitializers.set(sourceValueId, init);
       },
       onPinnedRootSchemaKeys: (schemaKeys) => {
         pinnedRootSchemaKeys = schemaKeys;
@@ -116573,6 +117255,7 @@ function materializeInitializersLocallyV4(args) {
       compilationProject,
       replayContext,
       member: rootOwner,
+      compiledInitializer,
       omitConstructionFields: true
     });
     const baselineRoot = baseline.get(sourceValueId);
@@ -116606,15 +117289,9 @@ function materializeInitializersLocallyV4(args) {
       // class default, so the evaluated construction's own field list is what
       // pins rows against collapse. The server commit pins the same set.
       pinnedRootSchemaKeys,
-      virtualValueIdForSource: (instanceRootId, sourceIdentity3) => isPendingId(instanceRootId) ? pendingVirtualValueId(instanceRootId, sourceIdentity3) : virtualValueId(instanceRootId, sourceIdentity3)
+      virtualValueIdForSource: (instanceRootId, sourceIdentity3) => isPendingId(instanceRootId) || hasPendingVirtualSourceIdentity(sourceIdentity3) ? pendingVirtualValueId(instanceRootId, sourceIdentity3) : virtualValueId(instanceRootId, sourceIdentity3)
     });
     const evaluatedRows = [sparse2.root, ...sparse2.createdChildren];
-    const valuesById = new Map(document.values.map((row) => [row.id, row]));
-    for (const row of evaluatedRows) valuesById.set(row.id, row);
-    const materializedDocument = {
-      ...document,
-      values: [...valuesById.values()]
-    };
     roots.push({
       sourceValueId,
       rows: evaluatedRows.map((row) => ({ ...row }))
@@ -116628,8 +117305,8 @@ function materializeInitializersLocallyV4(args) {
         data: row
       });
     }
-    document = materializedDocument;
-  }
+    batch.upsert(evaluatedRows);
+  });
   return { roots };
 }
 function prospectiveInitializerRecordsV4(args) {
@@ -116778,6 +117455,8 @@ function variantOwnershipRootRecords(records2) {
 var init_local_initializer_materialization = __esm({
   "src/project-source/local-initializer-materialization.ts"() {
     "use strict";
+    init_evaluateInitializer();
+    init_initializer_dependencies();
     init_initializer_replay();
     init_effective_value_comparison();
     init_constructor_argument_ownership();
@@ -117695,6 +118374,7 @@ function computeWorkspaceStatus(workspace, options) {
   try {
     localInitializerMaterialization = materializeInitializersLocallyV4({
       workspace,
+      forceRecompile: options.forceRecompile,
       changes: changes.map((change) => ({
         recordKind: change.recordKind,
         recordId: change.recordId,
@@ -117827,9 +118507,11 @@ function replayAnimationDeclarationInitializersV4(records2, document, fallbackDo
     ...document.values.map((row) => [row.id, row])
   ]);
   for (const { row, code } of initializers) {
-    if (rootKinds.get(row.id) !== "declaration") continue;
     const owner = owners.get(row.id);
     if (owner === void 0) continue;
+    if (rootKinds.get(row.id) !== "declaration" && !isStaticMember(owner)) {
+      continue;
+    }
     const declaredClassId = typeof row.classId === "string" ? row.classId : Reflect.get(owner, "classId");
     if (typeof declaredClassId !== "string") continue;
     if (!classBelongsToAnimationFamily(document.classesById, declaredClassId)) {
@@ -118801,6 +119483,7 @@ function verifyProjectSourceCommitAgainstStateV4(args) {
     }
   }
   const status = computeWorkspaceStatus(workspace, {
+    forceRecompile: args.forceRecompile,
     skipProjectBinaryInspection: true,
     useBuildCaches: false,
     writeProjectAnalysisCache: () => void 0,
@@ -118966,7 +119649,18 @@ function derivedAssignment(pendingId2) {
   if (virtualIdentity !== null) {
     return {
       ownerLocator: virtualIdentity.instanceRootId,
-      derive: (ownerId) => virtualValueId(ownerId, virtualIdentity.sourceIdentity),
+      derive: (ownerId, assignments) => virtualValueId(
+        ownerId,
+        rewriteVirtualSourceIdentity(virtualIdentity.sourceIdentity, (id2) => {
+          const assigned = assignments.get(id2);
+          if (assigned === void 0) {
+            throw new ProjectSourceCommitVerificationError(
+              `Virtual value assignment ${pendingId2} names source ${id2}, which has no pending id assignment.`
+            );
+          }
+          return assigned;
+        })
+      ),
       label: "Virtual value assignment",
       ownerNoun: "instance root"
     };
@@ -118983,7 +119677,7 @@ function assertDerivedAssignmentsAreDerived(assignments) {
         `${derivation.label} ${pendingId2} names ${derivation.ownerNoun} ${derivation.ownerLocator}, which has no pending id assignment.`
       );
     }
-    const derived = derivation.derive(ownerId);
+    const derived = derivation.derive(ownerId, assignments);
     if (assignedId !== derived) {
       throw new ProjectSourceCommitVerificationError(
         `${derivation.label} ${pendingId2} is ${assignedId}, but ${derivation.ownerNoun} ${ownerId} owns ${derived}.`
@@ -119013,24 +119707,51 @@ function positionIndependentAssignments(assignments) {
   }
   return resolved;
 }
-function relocatedAssignment(pendingId2, assignments, byPosition) {
+function relocatedAssignment(pendingId2, assignments, byPosition, used) {
   const key = positionIndependentPendingKey(pendingId2);
   const relocated = key === null ? void 0 : byPosition.get(key);
   if (relocated !== void 0) return relocated;
+  for (const [owner, rebuild] of [
+    [pendingMemberValueMemberId(pendingId2), pendingMemberValueId],
+    [pendingEntryMemberDeclaringId(pendingId2), pendingEntryMemberId],
+    [
+      pendingRequiredConstructorClassId(pendingId2),
+      pendingRequiredConstructorId
+    ]
+  ]) {
+    if (owner === null) continue;
+    const relocatedOwner = assignments.has(owner) ? owner : relocatedAssignment(owner, assignments, byPosition, used);
+    if (relocatedOwner === null) return null;
+    const rebuilt = rebuild(relocatedOwner);
+    return assignments.has(rebuilt) ? rebuilt : null;
+  }
   const virtual = pendingVirtualValueIdentity(pendingId2);
   if (virtual === null) return null;
   let relocatedRoot = virtual.instanceRootId;
-  if (!assignments.has(relocatedRoot)) {
-    const rootKey = positionIndependentPendingKey(relocatedRoot);
-    if (rootKey === null) return null;
-    const canonicalRoot = byPosition.get(rootKey);
-    if (canonicalRoot === void 0) return null;
+  if (isPendingId(relocatedRoot) && !assignments.has(relocatedRoot)) {
+    const canonicalRoot = relocatedAssignment(
+      relocatedRoot,
+      assignments,
+      byPosition,
+      used
+    );
+    if (canonicalRoot === null) return null;
     relocatedRoot = canonicalRoot;
   }
-  const relocatedVirtual = pendingVirtualValueId(
-    relocatedRoot,
-    virtual.sourceIdentity
+  const sourceIdentity3 = rewriteVirtualSourceIdentity(
+    virtual.sourceIdentity,
+    (sourceId3) => {
+      const relocatedSource = assignments.has(sourceId3) ? sourceId3 : relocatedAssignment(sourceId3, assignments, byPosition, used);
+      if (relocatedSource === null) {
+        throw new ProjectSourceCommitVerificationError(
+          `Virtual value ${pendingId2} names source ${sourceId3}, which has no pending id assignment.`
+        );
+      }
+      used.add(relocatedSource);
+      return relocatedSource;
+    }
   );
+  const relocatedVirtual = pendingVirtualValueId(relocatedRoot, sourceIdentity3);
   return assignments.has(relocatedVirtual) ? relocatedVirtual : null;
 }
 function rewritePending(value, assignments, used, positionless) {
@@ -119041,7 +119762,12 @@ function rewritePending(value, assignments, used, positionless) {
       return exact;
     }
     if (value.startsWith("__pending__:")) {
-      const relocated = relocatedAssignment(value, assignments, positionless);
+      const relocated = relocatedAssignment(
+        value,
+        assignments,
+        positionless,
+        used
+      );
       if (relocated !== null) {
         used.add(relocated);
         return assignments.get(relocated);
@@ -119903,7 +120629,7 @@ function createPulledConstructionReplayContext(args) {
   return {
     document: args.document,
     constructorsValidated: false,
-    valuesById: new Map(args.document.values.map((value) => [value.id, value]))
+    valuesById: args.valuesById ?? new Map(args.document.values.map((value) => [value.id, value]))
   };
 }
 function describePulledProjectBodyCompileError(error) {
@@ -119979,26 +120705,27 @@ function replayStoredConstructionV4(args) {
   delete envelope.init;
   const candidate = {
     ...envelope,
-    init: { code: args.code }
+    init: args.compiledInitializer ?? { code: args.code }
   };
-  compileValueRowInitializerBody({
-    project: document.project,
-    projectFiles: document.projectFiles,
-    members: document.members,
-    classes: document.classes,
-    enums: document.enums,
-    interfaces: document.interfaces,
-    constructors: document.constructors,
-    member: compileMember,
-    valueRow: candidate,
-    valueId: args.valueId,
-    // Instance calls are self-contained. Declaration calls inherit the class
-    // header parameters that are in lexical scope at their source site.
-    initializerOwnerClass: args.initializerOwnerClass ?? null,
-    lexicalThisClass: args.lexicalThisClass ?? null,
-    storedConstructionReplay: true,
-    ...compilationProject === void 0 ? {} : { compilationProject }
-  });
+  if (args.compiledInitializer === void 0)
+    compileValueRowInitializerBody({
+      project: document.project,
+      projectFiles: document.projectFiles,
+      members: document.members,
+      classes: document.classes,
+      enums: document.enums,
+      interfaces: document.interfaces,
+      constructors: document.constructors,
+      member: compileMember,
+      valueRow: candidate,
+      valueId: args.valueId,
+      // Instance calls are self-contained. Declaration calls inherit the class
+      // header parameters that are in lexical scope at their source site.
+      initializerOwnerClass: args.initializerOwnerClass ?? null,
+      lexicalThisClass: args.lexicalThisClass ?? null,
+      storedConstructionReplay: true,
+      ...compilationProject === void 0 ? {} : { compilationProject }
+    });
   if (!isMemberValue(candidate) || !isInitValueContent(candidate)) {
     throw new Error(
       `Construction replay for value "${args.valueId}" did not compile an initializer row.`
@@ -120076,7 +120803,7 @@ function compilePulledUncompiledConstructorsV4(document, compilationProject, rep
   }
   assertPulledConstructorsCompiled(document, replayContext);
 }
-function compilePulledProjectDocumentForEvaluationV4(document, compilationProject) {
+function compilePulledProjectDocumentForEvaluationV4(document, compilationProject, targets) {
   const sharedCompilationProject = compilationProject ?? createNeoScriptCompilationProject({
     project: document.project,
     projectFiles: document.projectFiles,
@@ -120098,11 +120825,15 @@ function compilePulledProjectDocumentForEvaluationV4(document, compilationProjec
     compilationProject: sharedCompilationProject
   };
   for (const constructor2 of compileArgs.constructors) {
+    if (targets !== void 0 && !targets.constructorIds.has(constructor2.id) && !hasPendingNeoScriptDerivation("constructor", constructor2))
+      continue;
     compileConstructorRecord({ ...compileArgs, constructor: constructor2 });
   }
   assertPulledConstructorsCompiled(document);
   const memberIndex = documentMemberCompilationIndex(document);
   for (const member of compileArgs.members) {
+    if (targets !== void 0 && !targets.memberIds.has(member.id) && !hasPendingNeoScriptDerivation("member", member))
+      continue;
     try {
       compileAuthoredMemberBodies({
         ...compileArgs,
@@ -120289,6 +121020,7 @@ var init_initializer_replay = __esm({
     init_server_preparation_preflight();
     init_projection();
     init_constructors2();
+    init_neo_script_derived_bodies();
     init_compiler_adapter();
     pulledBodyCompileSites = /* @__PURE__ */ new WeakMap();
     recentPulledDocuments = [];
@@ -120382,6 +121114,7 @@ function buildValueEmitContext(records2, manifest, options = {}) {
     ownerClassIds: memberOwnerClassIdIndex(classes),
     values,
     enums,
+    dictionaryKeyOptions: /* @__PURE__ */ new Map(),
     localizedTexts,
     mainLocale: projectMainLocale(records2),
     symbolsByValueId,
@@ -120945,6 +121678,7 @@ function buildValueLowerContext(state, manifest, options = {}) {
         new Map(entry.options.map((option) => [option.name, option.id]))
       ])
     ),
+    enumNames: new Map(manifest.enums.map((entry) => [entry.id, entry.name])),
     staticValueIdsBySymbol: staticTargets,
     get rootValueTargetsByPath() {
       return rootValueTargets ??= rootValueTargetsByPath(
@@ -121575,15 +122309,17 @@ function lowerMemberDefaultSourcesV4(state, analysis, manifest, options = {}) {
           `Member default ${label} was classified as an owned literal graph but lowered as an initializer.`
         );
       }
-      if (storedDefault !== null && canonicallyEqual(seed.value, storedDefault.value) && (seed.classId ?? null) === (typeof storedDefaultClassId === "string" ? storedDefaultClassId : null) && (seed.values === void 0 || seed.values.length === 0) && (seed.bindingMembers === void 0 || seed.bindingMembers.length === 0) && (seed.localizedTexts === void 0 || seed.localizedTexts.length === 0)) {
+      const emptyInlineClassDefault = member.kind === "class" && isObjectRecord2(seed.value) && Object.keys(seed.value).length === 0 && (seed.constructorArgs === void 0 || Object.keys(seed.constructorArgs).length === 0) && seed.instanceConstructorId == null && seed.instanceVariantId == null && seed.instanceVariantRowValueId == null;
+      const matchesStoredDefault = storedDefault !== null && canonicallyEqual(seed.value, storedDefault.value) && (seed.classId ?? null) === (typeof storedDefaultClassId === "string" ? storedDefaultClassId : null);
+      if ((emptyInlineClassDefault || matchesStoredDefault) && (seed.values === void 0 || seed.values.length === 0) && (seed.bindingMembers === void 0 || seed.bindingMembers.length === 0) && (seed.localizedTexts === void 0 || seed.localizedTexts.length === 0)) {
         for (const id2 of context.pendingValues.keys()) {
           if (!pendingValueIdsBeforeSeed.has(id2)) {
             deletePendingValue(context, id2);
           }
         }
         memberDefaultValues.set(memberId, {
-          value: storedDefault.value,
-          classId: typeof storedDefaultClassId === "string" ? storedDefaultClassId : null
+          value: seed.value,
+          classId: seed.classId
         });
         continue;
       }
@@ -122280,24 +123016,21 @@ function lowerRowBackedDefault(context, member, backed, baseData3, binding) {
       throw new Error(`Default value ${binding.label} requires {...}.`);
     }
     const entryMember = requiredMember(context, member.entryMemberId);
+    const keyEnum = dictionaryKeyEnum(context, member);
     const baseBody = backed.body;
     const body = {};
     const entrySlices = topLevelEntrySlices(binding.initializer, "{", "}");
     let entryIndex = 0;
     for (const entry of expression.entries) {
-      if (entry.key.kind !== "litString") {
-        throw new Error(
-          `Default dictionary ${binding.label} requires string keys.`
-        );
-      }
-      const existingId = isObjectRecord2(baseBody) ? baseBody[entry.key.value] : void 0;
+      const key = lowerDictionaryKey(entry.key, keyEnum, binding.label);
+      const existingId = isObjectRecord2(baseBody) ? baseBody[key] : void 0;
       const entryId = typeof existingId === "string" ? existingId : annotatedValue(entry.value).id;
       if (entryId === null || entryId === void 0) {
         throw new Error(
-          `Default dictionary ${binding.label}[${JSON.stringify(entry.key.value)}] has no existing owned value row. Creating new default rows from source is not implemented by this slice.`
+          `Default dictionary ${binding.label}[${JSON.stringify(key)}] has no existing owned value row. Creating new default rows from source is not implemented by this slice.`
         );
       }
-      body[entry.key.value] = lowerValueRow(
+      body[key] = lowerValueRow(
         context,
         entryMember,
         entry.value,
@@ -122901,19 +123634,18 @@ function lowerSeedRow(context, member, sourceExpression, source, valueId, path,
       throw new Error(`Dictionary value ${path} requires {...}.`);
     }
     const entryMember = requiredMember(context, resolvedMember.entryMemberId);
+    const keyEnum = dictionaryKeyEnum(context, resolvedMember);
     const body = {};
     const entrySlices = authoredSlice === void 0 ? [] : topLevelEntrySlices(authoredSlice, "{", "}");
     let entryIndex = 0;
     for (const entry of expression.entries) {
-      if (entry.key.kind !== "litString") {
-        throw new Error(`Dictionary value ${path} requires string keys.`);
-      }
-      body[entry.key.value] = lowerSeedChild(
+      const key = lowerDictionaryKey(entry.key, keyEnum, path);
+      body[key] = lowerSeedChild(
         context,
         entryMember,
         entry.value,
         source,
-        `${path}[${JSON.stringify(entry.key.value)}]`,
+        `${path}[${JSON.stringify(key)}]`,
         rows,
         localizedTexts,
         void 0,
@@ -124532,32 +125264,31 @@ function lowerDictionaryValue(context, member, expression, base, source, inherit
     throw new Error("Dictionary values require {...}.");
   }
   const baseBody = isObjectRecord2(base.value) ? base.value : {};
+  const keyEnum = dictionaryKeyEnum(context, member);
   const entryMember = requiredMember(context, member.entryMemberId);
   const environment = valueGenericEnvironment(base, inheritedEnvironment);
   const body = {};
   for (const entry of expression.entries) {
-    if (entry.key.kind !== "litString") {
-      throw new Error("Dictionary source keys must be strings.");
-    }
-    const existingId = baseBody[entry.key.value];
+    const key = lowerDictionaryKey(entry.key, keyEnum, member.name);
+    const existingId = baseBody[key];
     const symbolId = sourceValueSymbol(context, entry.value);
     if (symbolId !== null) {
       if (symbolId !== existingId) {
         throw new Error(
-          `Dictionary ${member.name}[${JSON.stringify(entry.key.value)}] changes value placement from ${String(existingId)} to ${symbolId}. The atomic placement transaction is not implemented by this slice.`
+          `Dictionary ${member.name}[${JSON.stringify(key)}] changes value placement from ${String(existingId)} to ${symbolId}. The atomic placement transaction is not implemented by this slice.`
         );
       }
-      body[entry.key.value] = symbolId;
+      body[key] = symbolId;
       continue;
     }
     const explicitId = annotatedValue(entry.value).id;
     const valueId = explicitId ?? existingId;
     if (typeof valueId !== "string") {
       throw new Error(
-        `Dictionary ${member.name}[${JSON.stringify(entry.key.value)}] has no existing row. New dictionary entries are not implemented by this slice.`
+        `Dictionary ${member.name}[${JSON.stringify(key)}] has no existing row. New dictionary entries are not implemented by this slice.`
       );
     }
-    body[entry.key.value] = lowerValueRow(
+    body[key] = lowerValueRow(
       context,
       entryMember,
       entry.value,
@@ -125786,6 +126517,20 @@ function requiredMember(context, id2) {
   if (member === void 0) throw new Error(`Missing member ${id2}.`);
   return member;
 }
+function dictionaryKeyEnum(context, member) {
+  if (member.key.kind === "string") return null;
+  const name = context.enumNames.get(member.key.enumId);
+  const optionsByName = context.enumOptions.get(member.key.enumId);
+  if (name === void 0) {
+    throw new Error(`Unknown dictionary key enum ${member.key.enumId}.`);
+  }
+  if (optionsByName === void 0) {
+    throw new Error(
+      `Dictionary key enum ${member.key.enumId} has no option index.`
+    );
+  }
+  return { name, optionsByName };
+}
 function requiredClassByName(context, name) {
   const schemaClass2 = context.classesByName.get(name);
   if (schemaClass2 === void 0) throw new Error(`Unknown class ${name}.`);
@@ -126928,14 +127673,13 @@ ${ids.map(
       if (!isObjectRecord2(row.value)) {
         return storedRowIdentitySource(valueId, writeIdentity, "{}");
       }
-      const entries = Object.entries(row.value).sort(
-        ([left], [right]) => compareCodePoints(left, right)
-      );
+      const keyOptions = dictionaryOptions2(context, type.keyEnumId);
+      const entries = orderedDictionaryEntries(row.value, keyOptions);
       const expression = entries.length === 0 ? "{}" : `{
 ${entries.flatMap(
         ([key, id2]) => typeof id2 === "string" ? [
           indentNeoSourceNonEmptyLines(
-            `${quote5(key)}: ${storedTypedRowSource(
+            `${emitDictionaryKey(key, keyOptions)}: ${storedTypedRowSource(
               context,
               type.entryType,
               id2,
@@ -127359,22 +128103,29 @@ function dictionaryValue(context, member, value, visited, inheritedEnvironment)
   if (entryMember === void 0)
     throw new Error(`Dictionary entry member was not pulled.`);
   const environment = valueGenericEnvironment(value, inheritedEnvironment);
-  const entries = Object.entries(body).sort(
-    ([left], [right]) => compareCodePoints(left, right)
+  const keyOptions = dictionaryOptions2(
+    context,
+    typeof member.keyEnumId === "string" ? member.keyEnumId : null
   );
+  const entries = orderedDictionaryEntries(body, keyOptions);
   if (entries.length === 0) return "{}";
   return `{
 ${entries.flatMap(
     ([key, id2]) => typeof id2 === "string" ? [
       indentNeoSourceNonEmptyLines(
-        `${quote5(key)}: ${emitValue(context, entryMember, id2, {
-          environment,
-          definitionSite: !context.symbolsByValueId.has(id2),
-          // Dictionary keys, like class schema keys, recover entry
-          // identity from the owning row. Only list entries need an id.
-          writeIdentity: false,
-          visited
-        })}`,
+        `${emitDictionaryKey(key, keyOptions)}: ${emitValue(
+          context,
+          entryMember,
+          id2,
+          {
+            environment,
+            definitionSite: !context.symbolsByValueId.has(id2),
+            // Dictionary keys, like class schema keys, recover entry
+            // identity from the owning row. Only list entries need an id.
+            writeIdentity: false,
+            visited
+          }
+        )}`,
         2
       )
     ] : []
@@ -127681,6 +128432,32 @@ function enumOptionNames(value) {
   }
   return result;
 }
+function dictionaryOptions2(context, enumId) {
+  if (enumId === null) return null;
+  const cached = context.dictionaryKeyOptions.get(enumId);
+  if (cached !== void 0) return cached;
+  const schemaEnum = context.enums.get(enumId);
+  if (schemaEnum === void 0) {
+    throw new Error(`Dictionary key enum ${enumId} was not pulled.`);
+  }
+  const options = isObjectRecord2(schemaEnum.options) ? schemaEnum.options : {};
+  const keys = appendMissingKeys(
+    optionalStringArray(schemaEnum.optionKeyOrder),
+    Object.keys(options)
+  );
+  const result = /* @__PURE__ */ new Map();
+  for (const [order, key] of keys.entries()) {
+    const option = options[key];
+    if (!isObjectRecord2(option)) continue;
+    const id2 = typeof option.id === "string" ? option.id : key;
+    const name = typeof option.name === "string" ? option.name : key;
+    const entry = { name, order };
+    result.set(id2, entry);
+    result.set(key, entry);
+  }
+  context.dictionaryKeyOptions.set(enumId, result);
+  return result;
+}
 function dataById(records2, kind) {
   return new Map(
     [...records2.values()].flatMap(
@@ -127765,6 +128542,7 @@ var init_value_sources = __esm({
     init_local_values();
     init_initializer_reference_spellings();
     init_lower_members();
+    init_dictionary_enum_keys();
     init_lower_variants();
     init_member_kind_type_names();
     init_member_records();
@@ -130887,7 +131665,7 @@ function assignPendingIds(changes, authoredValueSeeds, reconstructed3, localInit
       const instanceRootId = isPendingId(pendingVirtual.instanceRootId) ? assign(pendingVirtual.instanceRootId) : pendingVirtual.instanceRootId;
       const derived = virtualValueId(
         instanceRootId,
-        pendingVirtual.sourceIdentity
+        rewriteVirtualSourceIdentity(pendingVirtual.sourceIdentity, assign)
       );
       assigned.set(pendingId2, derived);
       return derived;
@@ -132312,7 +133090,8 @@ async function prepareLocalPushArtifactsV4(workspace, status, onPhase = () => vo
   const localInitializerMaterialization = status.localInitializerMaterialization ?? materializeInitializersLocallyV4({
     workspace,
     changes: pendingTransportChanges,
-    authoredValueSeeds: pendingTransportSeeds
+    authoredValueSeeds: pendingTransportSeeds,
+    forceRecompile: options.forceRecompile
   });
   onPhase("Assigning pending value identities\u2026");
   const pendingAssignment = assignPendingIds(
@@ -132355,6 +133134,7 @@ async function prepareLocalPushArtifactsV4(workspace, status, onPhase = () => vo
       changes: transportChanges,
       authoredValueSeeds: transportSeeds,
       initializerMaterialization: pendingAssignment.localInitializerMaterialization ?? { roots: [] },
+      forceRecompile: options.forceRecompile,
       pendingIdAssignments: Object.fromEntries(pendingAssignment.assigned),
       stagedFiles: preparedFiles
     });
@@ -139485,7 +140265,7 @@ var init_registry2 = __esm({
   "schema-contract/registry.mjs"() {
     "use strict";
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
-      cliVersion: "0.56.0",
+      cliVersion: "0.57.0",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -147306,7 +148086,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.56.0");
+    console.log("0.57.0");
     return;
   }
   if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {