@neocompose/cli 0.58.3 → 0.59.0

package/dist/neo.mjs

@@ -6424,10 +6424,10 @@ var init_strict_resolver = __esm({
         this.project = projectIndex ?? createProjectIndex(context.project);
         this.source = syntax?.source.text;
         this.sourceTokens = syntax?.roots;
-        const unknown2 = { kind: "primitive", name: "unknown" };
+        const unknown = { kind: "primitive", name: "unknown" };
         this.thisVariable = variable(
           "__this__",
-          context.thisClass ?? unknown2,
+          context.thisClass ?? unknown,
           void 0,
           this.project
         );
@@ -6436,7 +6436,7 @@ var init_strict_resolver = __esm({
         );
         this.rootVariable = variable(
           "__root__",
-          rootSymbol?.type ?? unknown2,
+          rootSymbol?.type ?? unknown,
           void 0,
           this.project
         );
@@ -34352,13 +34352,13 @@ function spellingQuickFixes(document, diagnostic) {
 }
 function diagnosticMisspelling(diagnostic) {
   if (/to initialize\b/.test(diagnostic.message)) return null;
-  const unknown2 = /Unknown (identifier|function) '([^']+)'/.exec(
+  const unknown = /Unknown (identifier|function) '([^']+)'/.exec(
     diagnostic.message
   );
-  if (unknown2?.[2]) {
+  if (unknown?.[2]) {
     return {
-      name: unknown2[2],
-      kind: unknown2[1] === "function" ? "callable" : "value"
+      name: unknown[2],
+      kind: unknown[1] === "function" ? "callable" : "value"
     };
   }
   const member = /has no (?:static )?(?:callable )?member '([^']+)'/.exec(
@@ -35759,10 +35759,10 @@ function optionalTestConfig(value) {
     "maxWorkers",
     "forbidOnly"
   ]);
-  const unknown2 = Object.keys(config).find((key) => !allowed.has(key));
-  if (unknown2 !== void 0) {
+  const unknown = Object.keys(config).find((key) => !allowed.has(key));
+  if (unknown !== void 0) {
     throw new Error(
-      `"${NEO_CONFIG_FILE}" field "test.${unknown2}" is not recognized.`
+      `"${NEO_CONFIG_FILE}" field "test.${unknown}" is not recognized.`
     );
   }
   const stringArray2 = (field) => {
@@ -41696,6 +41696,50 @@ var init_record_adapters = __esm({
   }
 });
 
+// ../packages/manifest/src/value-graph.ts
+function encodeStoredValueNode(node) {
+  if (node.nodeType === "initializer") return { init: { code: node.code } };
+  return {
+    value: node.value,
+    classId: node.classId,
+    ...node.constructorArgs === void 0 ? {} : { constructorArgs: node.constructorArgs },
+    ...node.instanceConstructorId === void 0 ? {} : { instanceConstructorId: node.instanceConstructorId },
+    ...node.instanceVariantId === void 0 ? {} : { instanceVariantId: node.instanceVariantId },
+    ...node.instanceVariantRowValueId === void 0 ? {} : { instanceVariantRowValueId: node.instanceVariantRowValueId }
+  };
+}
+function encodeStoredValueRowFields(row) {
+  return {
+    ...encodeStoredValueNode(row),
+    ...row.containerId === void 0 ? {} : { containerId: row.containerId },
+    ...row.genericBindings === void 0 ? {} : { genericBindings: row.genericBindings },
+    ...row.sourceValueId === void 0 ? {} : { sourceValueId: row.sourceValueId }
+  };
+}
+function canonicalInstanceProvenanceViolation(value) {
+  const constructorArgs = "constructorArgs" in value ? value.constructorArgs : void 0;
+  const constructorId = "instanceConstructorId" in value ? value.instanceConstructorId : void 0;
+  const variantId = "instanceVariantId" in value ? value.instanceVariantId : void 0;
+  if (constructorArgs !== void 0 && constructorId === void 0 && typeof variantId !== "string") {
+    return "constructor-args-without-stamp";
+  }
+  if (typeof constructorId === "string" && constructorArgs === void 0) {
+    return "named-constructor-without-args";
+  }
+  if (constructorId === null && constructorArgs !== void 0 && typeof constructorArgs === "object" && constructorArgs !== null && !Array.isArray(constructorArgs) && Object.keys(constructorArgs).length > 0) {
+    return "implicit-constructor-with-args";
+  }
+  if ("instanceVariantRowValueId" in value && typeof value.instanceVariantRowValueId === "string" && typeof variantId !== "string") {
+    return "variant-row-without-variant";
+  }
+  return null;
+}
+var init_value_graph = __esm({
+  "../packages/manifest/src/value-graph.ts"() {
+    "use strict";
+  }
+});
+
 // node_modules/valibot/dist/index.mjs
 // @__NO_SIDE_EFFECTS__
 function getGlobalConfig(config$1) {
@@ -42408,23 +42452,6 @@ function union(options, message$1) {
   };
 }
 // @__NO_SIDE_EFFECTS__
-function unknown() {
-  return {
-    kind: "schema",
-    type: "unknown",
-    reference: unknown,
-    expects: "unknown",
-    async: false,
-    get "~standard"() {
-      return /* @__PURE__ */ _getStandardProps(this);
-    },
-    "~run"(dataset) {
-      dataset.typed = true;
-      return dataset;
-    }
-  };
-}
-// @__NO_SIDE_EFFECTS__
 function variant(key, options, message$1) {
   return {
     kind: "schema",
@@ -42539,108 +42566,6 @@ var init_dist = __esm({
   }
 });
 
-// ../packages/manifest/src/value-graph.ts
-function encodeStoredValueNode(node) {
-  if (node.nodeType === "initializer") return { init: { code: node.code } };
-  return {
-    value: node.value,
-    classId: node.classId,
-    ...node.constructorArgs === void 0 ? {} : { constructorArgs: node.constructorArgs },
-    ...node.instanceConstructorId === void 0 ? {} : { instanceConstructorId: node.instanceConstructorId },
-    ...node.instanceVariantId === void 0 ? {} : { instanceVariantId: node.instanceVariantId },
-    ...node.instanceVariantRowValueId === void 0 ? {} : { instanceVariantRowValueId: node.instanceVariantRowValueId }
-  };
-}
-function encodeStoredValueRowFields(row) {
-  return {
-    ...encodeStoredValueNode(row),
-    ...row.containerId === void 0 ? {} : { containerId: row.containerId },
-    ...row.genericBindings === void 0 ? {} : { genericBindings: row.genericBindings },
-    ...row.sourceValueId === void 0 ? {} : { sourceValueId: row.sourceValueId }
-  };
-}
-function canonicalInstanceProvenanceViolation(value) {
-  const constructorArgs = "constructorArgs" in value ? value.constructorArgs : void 0;
-  const constructorId = "instanceConstructorId" in value ? value.instanceConstructorId : void 0;
-  const variantId = "instanceVariantId" in value ? value.instanceVariantId : void 0;
-  if (constructorArgs !== void 0 && constructorId === void 0 && typeof variantId !== "string") {
-    return "constructor-args-without-stamp";
-  }
-  if (typeof constructorId === "string" && constructorArgs === void 0) {
-    return "named-constructor-without-args";
-  }
-  if (constructorId === null && constructorArgs !== void 0 && typeof constructorArgs === "object" && constructorArgs !== null && !Array.isArray(constructorArgs) && Object.keys(constructorArgs).length > 0) {
-    return "implicit-constructor-with-args";
-  }
-  if ("instanceVariantRowValueId" in value && typeof value.instanceVariantRowValueId === "string" && typeof variantId !== "string") {
-    return "variant-row-without-variant";
-  }
-  return null;
-}
-var nonEmptyString, nullableId, optionalNullableId, stringMap, unknownMap, instanceProvenanceEntries, literalValueNodeEntries, initializerValueNodeEntries, literalValueNodeSchema, initializerValueNodeSchema, valueRowEntries, AuthoredValueRowSchema, valueSeedEntries, AuthoredValueSeedSchema, BindingMemberSchema, LocalizedTextSchema;
-var init_value_graph = __esm({
-  "../packages/manifest/src/value-graph.ts"() {
-    "use strict";
-    init_dist();
-    nonEmptyString = pipe(string3(), nonEmpty());
-    nullableId = nullable(nonEmptyString);
-    optionalNullableId = optional(nullableId);
-    stringMap = record3(string3(), nonEmptyString);
-    unknownMap = record3(string3(), unknown());
-    instanceProvenanceEntries = {
-      constructorArgs: optional(unknownMap),
-      instanceConstructorId: optionalNullableId,
-      instanceVariantId: optionalNullableId,
-      instanceVariantRowValueId: optionalNullableId
-    };
-    literalValueNodeEntries = {
-      nodeType: literal2("literal"),
-      value: unknown(),
-      classId: nullable(string3()),
-      ...instanceProvenanceEntries
-    };
-    initializerValueNodeEntries = {
-      nodeType: literal2("initializer"),
-      code: nonEmptyString
-    };
-    literalValueNodeSchema = strictObject(literalValueNodeEntries);
-    initializerValueNodeSchema = strictObject(
-      initializerValueNodeEntries
-    );
-    valueRowEntries = {
-      id: nonEmptyString,
-      memberId: nonEmptyString,
-      containerId: optional(string3()),
-      genericBindings: optional(stringMap),
-      sourceValueId: optional(nonEmptyString)
-    };
-    AuthoredValueRowSchema = variant("nodeType", [
-      strictObject({ ...valueRowEntries, ...literalValueNodeEntries }),
-      strictObject({ ...valueRowEntries, ...initializerValueNodeEntries })
-    ]);
-    valueSeedEntries = {
-      memberId: nonEmptyString,
-      valueId: optional(nonEmptyString),
-      values: optional(unknown()),
-      bindingMembers: optional(unknown()),
-      localizedTexts: optional(unknown())
-    };
-    AuthoredValueSeedSchema = variant("nodeType", [
-      strictObject({ ...valueSeedEntries, ...literalValueNodeEntries }),
-      strictObject({ ...valueSeedEntries, ...initializerValueNodeEntries })
-    ]);
-    BindingMemberSchema = strictObject({
-      id: nonEmptyString,
-      classId: nonEmptyString
-    });
-    LocalizedTextSchema = strictObject({
-      id: nonEmptyString,
-      valueId: nonEmptyString,
-      value: string3()
-    });
-  }
-});
-
 // ../packages/manifest/src/schema-member.ts
 function jsonValueIssue(value, depth, path) {
   if (depth > 64) {
@@ -42728,34 +42653,34 @@ function schemaTypeOptionsAtDepth(depth) {
       nullable: boolean2()
     }),
     nullableTypeSchema("class", {
-      classId: nonEmptyString2,
-      classArguments: record3(nonEmptyString2, schemaTypeAtDepth(depth + 1))
+      classId: nonEmptyString,
+      classArguments: record3(nonEmptyString, schemaTypeAtDepth(depth + 1))
     }),
     nullableTypeSchema("interface", {
-      interfaceId: nonEmptyString2
+      interfaceId: nonEmptyString
     }),
     nullableTypeSchema("generic", {
-      ownerClassId: nonEmptyString2,
-      genericParamId: nonEmptyString2
+      ownerClassId: nonEmptyString,
+      genericParamId: nonEmptyString
     }),
     nullableTypeSchema("enum", {
-      enumId: nonEmptyString2
+      enumId: nonEmptyString
     }),
     nullableTypeSchema("list", {
       entryType: schemaTypeAtDepth(depth + 1),
-      listMemberId: nullableId2,
+      listMemberId: nullableId,
       readOnly: boolean2()
     }),
     nullableTypeSchema("dictionary", {
       entryType: schemaTypeAtDepth(depth + 1),
-      keyEnumId: nullableId2,
+      keyEnumId: nullableId,
       readOnly: boolean2()
     }),
     pipe(
       nullableTypeSchema("lookup", {
         entryType: schemaTypeAtDepth(depth + 1),
-        collectionMemberId: exactOptional(nonEmptyString2),
-        collectionValueId: exactOptional(nullableId2)
+        collectionMemberId: exactOptional(nonEmptyString),
+        collectionValueId: exactOptional(nullableId)
       }),
       check(
         (type) => type.collectionValueId == null || type.collectionMemberId !== void 0,
@@ -42968,14 +42893,14 @@ function assertMemberInvariants(member, path) {
       fail2("script", "is required for a concrete scripted member.");
   }
 }
-var nonEmptyString2, nullableString2, nullableId2, finiteNumber, nullableNumber, nullableInteger, jsonValueSchema, schemaSourcePositionSchema, schemaSourceSpanSchema, schemaSourceSymbolKinds, schemaSourceIdentitySchema, memberSourceIdentitySchema, systemProtectionKindSchema, worldSystemClassKindSchema, schemaSystemMetadataSchema, schemaGenericBindingSchema, schemaGenericBindingRecordSchema, genericConstraintSchema, schemaGenericParameterSchema, primitiveTypeKinds, schemaTypeCache, returnTypeCache, schemaTypeSchema, schemaFunctionReturnTypeSchema, schemaParameterDefaultSchema, schemaFunctionArgumentSchema, memberOwnerSchema, schemaDefaultValueSchema, propertyScriptSchema, functionScriptSchema, commonMemberEntries, schemaMemberCommonSchema, simpleMemberSchemas, dictionaryKeySchema, schemaListIndexSchema, schemaListColumnSchema, callableEntries, schemaMemberSchema, SchemaMemberContractError;
+var nonEmptyString, nullableString2, nullableId, finiteNumber, nullableNumber, nullableInteger, jsonValueSchema, schemaSourcePositionSchema, schemaSourceSpanSchema, schemaSourceSymbolKinds, schemaSourceIdentitySchema, memberSourceIdentitySchema, systemProtectionKindSchema, worldSystemClassKindSchema, schemaSystemMetadataSchema, schemaGenericBindingSchema, schemaGenericBindingRecordSchema, genericConstraintSchema, schemaGenericParameterSchema, primitiveTypeKinds, schemaTypeCache, returnTypeCache, schemaTypeSchema, schemaFunctionReturnTypeSchema, schemaParameterDefaultSchema, schemaFunctionArgumentSchema, memberOwnerSchema, schemaDefaultValueSchema, propertyScriptSchema, functionScriptSchema, commonMemberEntries, schemaMemberCommonSchema, simpleMemberSchemas, dictionaryKeySchema, schemaListIndexSchema, schemaListColumnSchema, callableEntries, schemaMemberSchema, SchemaMemberContractError;
 var init_schema_member = __esm({
   "../packages/manifest/src/schema-member.ts"() {
     "use strict";
     init_dist();
-    nonEmptyString2 = pipe(string3(), nonEmpty());
+    nonEmptyString = pipe(string3(), nonEmpty());
     nullableString2 = nullable(string3());
-    nullableId2 = nullable(nonEmptyString2);
+    nullableId = nullable(nonEmptyString);
     finiteNumber = pipe(number(), finite());
     nullableNumber = nullable(finiteNumber);
     nullableInteger = nullable(
@@ -42994,7 +42919,7 @@ var init_schema_member = __esm({
     });
     schemaSourceSpanSchema = pipe(
       strictObject({
-        path: nonEmptyString2,
+        path: nonEmptyString,
         start: schemaSourcePositionSchema,
         end: schemaSourcePositionSchema
       }),
@@ -43041,13 +42966,13 @@ var init_schema_member = __esm({
       "variantFolder"
     ];
     schemaSourceIdentitySchema = strictObject({
-      symbolId: nonEmptyString2,
+      symbolId: nonEmptyString,
       kind: picklist(schemaSourceSymbolKinds),
       span: schemaSourceSpanSchema,
       selectionSpan: schemaSourceSpanSchema
     });
     memberSourceIdentitySchema = strictObject({
-      symbolId: nonEmptyString2,
+      symbolId: nonEmptyString,
       kind: literal2("member"),
       span: schemaSourceSpanSchema,
       selectionSpan: schemaSourceSpanSchema
@@ -43102,25 +43027,25 @@ var init_schema_member = __esm({
     schemaGenericBindingSchema = variant("kind", [
       strictObject({
         kind: literal2("generic"),
-        genericParamId: nonEmptyString2
+        genericParamId: nonEmptyString
       }),
-      strictObject({ kind: literal2("member"), memberId: nonEmptyString2 })
+      strictObject({ kind: literal2("member"), memberId: nonEmptyString })
     ]);
     schemaGenericBindingRecordSchema = record3(
-      nonEmptyString2,
+      nonEmptyString,
       schemaGenericBindingSchema
     );
     genericConstraintSchema = variant("kind", [
       strictObject({
         kind: literal2("class"),
-        classId: nonEmptyString2,
+        classId: nonEmptyString,
         classArguments: optional(nullable(schemaGenericBindingRecordSchema))
       }),
-      strictObject({ kind: literal2("enum"), enumId: nonEmptyString2 })
+      strictObject({ kind: literal2("enum"), enumId: nonEmptyString })
     ]);
     schemaGenericParameterSchema = strictObject({
-      id: nonEmptyString2,
-      name: nonEmptyString2,
+      id: nonEmptyString,
+      name: nonEmptyString,
       constraint: nullable(genericConstraintSchema),
       source: schemaSourceSpanSchema,
       selectionSpan: schemaSourceSpanSchema
@@ -43150,7 +43075,7 @@ var init_schema_member = __esm({
       source: schemaSourceSpanSchema
     });
     schemaFunctionArgumentSchema = strictObject({
-      name: nonEmptyString2,
+      name: nonEmptyString,
       type: schemaTypeSchema,
       default: nullable(schemaParameterDefaultSchema),
       source: schemaSourceSpanSchema,
@@ -43159,41 +43084,41 @@ var init_schema_member = __esm({
     memberOwnerSchema = variant("kind", [
       strictObject({
         kind: literal2("classMember"),
-        classId: nonEmptyString2,
-        schemaKey: nonEmptyString2
+        classId: nonEmptyString,
+        schemaKey: nonEmptyString
       }),
       strictObject({
         kind: literal2("sharedClassMember"),
         members: pipe(
           array2(
-            strictObject({ classId: nonEmptyString2, schemaKey: nonEmptyString2 })
+            strictObject({ classId: nonEmptyString, schemaKey: nonEmptyString })
           ),
           minLength(2, "Must contain at least two shared declarations.")
         )
       }),
       strictObject({
         kind: literal2("collectionEntry"),
-        parentMemberId: nonEmptyString2
+        parentMemberId: nonEmptyString
       }),
       strictObject({
         kind: literal2("sharedCollectionEntry"),
         parentMemberIds: pipe(
-          array2(nonEmptyString2),
+          array2(nonEmptyString),
           minLength(2, "Must contain at least two shared collections.")
         )
       }),
       strictObject({
         kind: literal2("genericArgument"),
-        parentRecordId: nonEmptyString2,
-        genericParamId: nonEmptyString2
+        parentRecordId: nonEmptyString,
+        genericParamId: nonEmptyString
       }),
       strictObject({
         kind: literal2("sharedGenericArgument"),
         bindings: pipe(
           array2(
             strictObject({
-              parentRecordId: nonEmptyString2,
-              genericParamId: nonEmptyString2
+              parentRecordId: nonEmptyString,
+              genericParamId: nonEmptyString
             })
           ),
           minLength(2, "Must contain at least two shared bindings.")
@@ -43202,17 +43127,17 @@ var init_schema_member = __esm({
       strictObject({ kind: literal2("loose") })
     ]);
     schemaDefaultValueSchema = union([
-      strictObject({ serverValueId: nonEmptyString2 }),
-      strictObject({ init: strictObject({ code: nonEmptyString2 }) }),
-      strictObject({ value: jsonValueSchema, classId: nullableId2 })
+      strictObject({ serverValueId: nonEmptyString }),
+      strictObject({ init: strictObject({ code: nonEmptyString }) }),
+      strictObject({ value: jsonValueSchema, classId: nullableId })
     ]);
     propertyScriptSchema = pipe(
       strictObject({
         kind: literal2("property"),
-        path: nonEmptyString2,
+        path: nonEmptyString,
         sourceText: string3(),
         source: schemaSourceSpanSchema,
-        getterSource: nonEmptyString2,
+        getterSource: nonEmptyString,
         setterSource: nullableString2
       }),
       forward(
@@ -43226,7 +43151,7 @@ var init_schema_member = __esm({
     functionScriptSchema = pipe(
       strictObject({
         kind: literal2("function"),
-        path: nonEmptyString2,
+        path: nonEmptyString,
         sourceText: string3(),
         source: schemaSourceSpanSchema
       }),
@@ -43239,10 +43164,10 @@ var init_schema_member = __esm({
       )
     );
     commonMemberEntries = {
-      id: nonEmptyString2,
+      id: nonEmptyString,
       source: memberSourceIdentitySchema,
       owner: memberOwnerSchema,
-      name: nonEmptyString2,
+      name: nonEmptyString,
       docsText: optional(string3()),
       isReadOnly: boolean2(),
       accessModifier: picklist(["public", "protected", "private"]),
@@ -43257,11 +43182,11 @@ var init_schema_member = __esm({
       ]),
       required: boolean2(),
       defaultValue: nullable(schemaDefaultValueSchema),
-      overrideOf: nullableId2,
+      overrideOf: nullableId,
       system: nullable(schemaSystemMetadataSchema),
       storage: nullable(picklist(["immutable", "save", "session", "writable"])),
       distribution: nullable(picklist(["sparse", "packed"])),
-      storageKey: nullableId2
+      storageKey: nullableId
     };
     schemaMemberCommonSchema = strictObject(commonMemberEntries);
     simpleMemberSchemas = [
@@ -43276,14 +43201,14 @@ var init_schema_member = __esm({
     ];
     dictionaryKeySchema = variant("kind", [
       strictObject({ kind: literal2("string") }),
-      strictObject({ kind: literal2("enum"), enumId: nonEmptyString2 })
+      strictObject({ kind: literal2("enum"), enumId: nonEmptyString })
     ]);
     schemaListIndexSchema = strictObject({
-      schemaKey: nonEmptyString2,
+      schemaKey: nonEmptyString,
       unique: boolean2()
     });
     schemaListColumnSchema = strictObject({
-      memberKey: nonEmptyString2,
+      memberKey: nonEmptyString,
       width: nullableNumber,
       hidden: boolean2(),
       frozen: boolean2(),
@@ -43314,33 +43239,33 @@ var init_schema_member = __esm({
         decimalPoints: nullableInteger
       }),
       memberSchema("dictionary", {
-        entryMemberId: nonEmptyString2,
+        entryMemberId: nonEmptyString,
         key: dictionaryKeySchema
       }),
       memberSchema("list", {
-        entryMemberId: nonEmptyString2,
+        entryMemberId: nonEmptyString,
         listKind: picklist(["ordered", "unordered"]),
         indexes: array2(schemaListIndexSchema),
         columns: array2(schemaListColumnSchema)
       }),
       memberSchema("class", {
-        classId: nonEmptyString2,
+        classId: nonEmptyString,
         partial: optional(boolean2()),
-        schemaKeyOrder: nullable(array2(nonEmptyString2)),
+        schemaKeyOrder: nullable(array2(nonEmptyString)),
         classArguments: schemaGenericBindingRecordSchema
       }),
       memberSchema("enum", {
-        enumId: nonEmptyString2,
+        enumId: nonEmptyString,
         multiselect: boolean2()
       }),
       memberSchema("lookup", {
-        collectionMemberId: nonEmptyString2,
-        collectionValueId: nullableId2,
+        collectionMemberId: nonEmptyString,
+        collectionValueId: nullableId,
         multiselect: boolean2(),
         declaredType: nullable(schemaTypeSchema)
       }),
       memberSchema("dialogueLookup", {
-        dialogueGroupId: nullableId2,
+        dialogueGroupId: nullableId,
         multiselect: boolean2()
       }),
       memberSchema("computed", {
@@ -43348,10 +43273,10 @@ var init_schema_member = __esm({
         script: nullable(propertyScriptSchema)
       }),
       memberSchema("sprite", {
-        templateId: nullableId2
+        templateId: nullableId
       }),
       memberSchema("audio", {
-        templateId: nullableId2
+        templateId: nullableId
       }),
       memberSchema("function", {
         ...callableEntries,
@@ -43382,7 +43307,7 @@ var init_schema_member = __esm({
         valueType: nullable(schemaTypeSchema)
       }),
       memberSchema("generic", {
-        genericParamId: nonEmptyString2,
+        genericParamId: nonEmptyString,
         partial: optional(boolean2())
       })
     ]);
@@ -43441,7 +43366,7 @@ function assertProjectSchemaManifest(value) {
     "localizationStatuses",
     "internalRecordRelations"
   ]);
-  nonEmptyString3(manifest.namespace, "$.namespace");
+  nonEmptyString2(manifest.namespace, "$.namespace");
   arrayOf(manifest.classes, "$.classes", assertNeoSchemaClass);
   arrayOf(manifest.constructors, "$.constructors", assertConstructor2);
   arrayOf(manifest.variants, "$.variants", assertVariant);
@@ -43515,7 +43440,7 @@ function assertConstructorInvariants(manifest) {
     const requiredConstructorId2 = schemaClass2.requiredConstructorId;
     if (requiredConstructorId2 === void 0) return;
     const path = `$.classes[${index}].requiredConstructorId`;
-    nonEmptyString3(requiredConstructorId2, path);
+    nonEmptyString2(requiredConstructorId2, path);
     const id2 = String(requiredConstructorId2);
     if (listedIds.has(id2)) {
       invalid(path, `constructor ${JSON.stringify(id2)} is already owned.`);
@@ -43551,7 +43476,7 @@ function assertConstructorInvariants(manifest) {
       schemaClass2.constructorIds,
       `$.classes[${index}].constructorIds`
     ).map((entry, entryIndex) => {
-      nonEmptyString3(
+      nonEmptyString2(
         entry,
         `$.classes[${index}].constructorIds[${entryIndex}]`
       );
@@ -43593,7 +43518,7 @@ function assertConstructor2(value, path) {
   );
   assertIdentity2(declared, path, "constructor");
   assertOptionalDocsText2(declared.docsText, `${path}.docsText`);
-  nonEmptyString3(declared.classId, `${path}.classId`);
+  nonEmptyString2(declared.classId, `${path}.classId`);
   arrayOf(declared.arguments, `${path}.arguments`, assertFunctionArgument);
   if (declared.code !== null && typeof declared.code !== "string") {
     invalid(
@@ -43639,11 +43564,11 @@ function assertVariant(value, path) {
     "valueId"
   ]);
   assertIdentity2(variant2, path, "variant");
-  nonEmptyString3(variant2.classId, `${path}.classId`);
-  nonEmptyString3(variant2.name, `${path}.name`);
-  nonEmptyString3(variant2.valueId, `${path}.valueId`);
+  nonEmptyString2(variant2.classId, `${path}.classId`);
+  nonEmptyString2(variant2.name, `${path}.name`);
+  nonEmptyString2(variant2.valueId, `${path}.valueId`);
   if (variant2.folderId === null) return;
-  nonEmptyString3(variant2.folderId, `${path}.folderId`);
+  nonEmptyString2(variant2.folderId, `${path}.folderId`);
 }
 function assertVariantFolder(value, path) {
   const folder = objectAt(value, path, [
@@ -43654,30 +43579,30 @@ function assertVariantFolder(value, path) {
     "binding"
   ]);
   assertIdentity2(folder, path, "variantFolder");
-  nonEmptyString3(folder.classId, `${path}.classId`);
+  nonEmptyString2(folder.classId, `${path}.classId`);
   if (typeof folder.path !== "string")
     invalid(`${path}.path`, "must be a string.");
   if (folder.binding === null) {
-    nonEmptyString3(folder.path, `${path}.path`);
+    nonEmptyString2(folder.path, `${path}.path`);
     return;
   }
   const binding = objectAt(folder.binding, `${path}.binding`, [
     "collectionMemberId",
     "collectionValueId"
   ]);
-  nonEmptyString3(
+  nonEmptyString2(
     binding.collectionMemberId,
     `${path}.binding.collectionMemberId`
   );
-  nonEmptyString3(
+  nonEmptyString2(
     binding.collectionValueId,
     `${path}.binding.collectionValueId`
   );
 }
 function assertConstructorBaseArgument(value, path) {
   const argument2 = objectAt(value, path, ["name", "code"]);
-  nonEmptyString3(argument2.name, `${path}.name`);
-  nonEmptyString3(argument2.code, `${path}.code`);
+  nonEmptyString2(argument2.name, `${path}.name`);
+  nonEmptyString2(argument2.code, `${path}.code`);
 }
 function assertInternalRecordRelation(value, path) {
   const relation = objectAt(value, path, [
@@ -43690,13 +43615,13 @@ function assertInternalRecordRelation(value, path) {
     "targetRecordId",
     "order"
   ]);
-  nonEmptyString3(relation.id, `${path}.id`);
+  nonEmptyString2(relation.id, `${path}.id`);
   assertSourceIdentity(relation.source, `${path}.source`);
-  nonEmptyString3(relation.relationKind, `${path}.relationKind`);
+  nonEmptyString2(relation.relationKind, `${path}.relationKind`);
   projectRecordKind2(relation.sourceRecordKind, `${path}.sourceRecordKind`);
-  nonEmptyString3(relation.sourceRecordId, `${path}.sourceRecordId`);
+  nonEmptyString2(relation.sourceRecordId, `${path}.sourceRecordId`);
   projectRecordKind2(relation.targetRecordKind, `${path}.targetRecordKind`);
-  nonEmptyString3(relation.targetRecordId, `${path}.targetRecordId`);
+  nonEmptyString2(relation.targetRecordId, `${path}.targetRecordId`);
   if (relation.order !== null && (typeof relation.order !== "number" || !Number.isInteger(relation.order) || relation.order < 0)) {
     invalid(`${path}.order`, "expected null or a non-negative integer.");
   }
@@ -44002,8 +43927,8 @@ function assertStaticMemberInvariants(manifest) {
         `static member ${JSON.stringify(memberName)} (${memberId}) has owner kind ${JSON.stringify(ownerKind)}; expected exactly one direct Class owner.`
       );
     }
-    const ownerClassId = nonEmptyString3(owner.classId, `${path}.owner.classId`);
-    const schemaKey = nonEmptyString3(
+    const ownerClassId = nonEmptyString2(owner.classId, `${path}.owner.classId`);
+    const schemaKey = nonEmptyString2(
       owner.schemaKey,
       `${path}.owner.schemaKey`
     );
@@ -44201,7 +44126,7 @@ function assertStaticMemberInvariants(manifest) {
   }
 }
 function assertIdentity2(value, path, expectedKind) {
-  nonEmptyString3(value.id, `${path}.id`);
+  nonEmptyString2(value.id, `${path}.id`);
   assertSourceIdentity(value.source, `${path}.source`, expectedKind);
 }
 function assertSourceIdentity(value, path, expectedKind) {
@@ -44247,7 +44172,7 @@ function assertNeoSchemaClass(value, path) {
     ]
   );
   assertIdentity2(type, path, "class");
-  nonEmptyString3(type.name, `${path}.name`);
+  nonEmptyString2(type.name, `${path}.name`);
   assertOptionalDocsText2(type.docsText, `${path}.docsText`);
   stringIn(
     type.declarationModifier,
@@ -44275,7 +44200,7 @@ function assertNeoSchemaClass(value, path) {
   );
   nullableNonEmptyString(type.targetMemberId, `${path}.targetMemberId`);
   if (type.requiredConstructorId !== void 0) {
-    nonEmptyString3(type.requiredConstructorId, `${path}.requiredConstructorId`);
+    nonEmptyString2(type.requiredConstructorId, `${path}.requiredConstructorId`);
   }
 }
 function assertGenericParameter(value, path) {
@@ -44309,7 +44234,7 @@ function assertInterface(value, path) {
     ["docsText"]
   );
   assertIdentity2(neoInterface, path, "interface");
-  nonEmptyString3(neoInterface.name, `${path}.name`);
+  nonEmptyString2(neoInterface.name, `${path}.name`);
   assertOptionalDocsText2(neoInterface.docsText, `${path}.docsText`);
   arrayOf(neoInterface.members, `${path}.members`, assertInterfaceMember);
   stringArray(neoInterface.extendsInterfaceIds, `${path}.extendsInterfaceIds`);
@@ -44324,8 +44249,8 @@ function assertInterfaceMember(value, path) {
       ["id", "kind", "name", "type", "settable", "accessModifier", "source"],
       ["docsText"]
     );
-    nonEmptyString3(member.id, `${path}.id`);
-    nonEmptyString3(member.name, `${path}.name`);
+    nonEmptyString2(member.id, `${path}.id`);
+    nonEmptyString2(member.name, `${path}.name`);
     assertOptionalDocsText2(member.docsText, `${path}.docsText`);
     assertType2(member.type, `${path}.type`);
     booleanAt(member.settable, `${path}.settable`);
@@ -44349,8 +44274,8 @@ function assertInterfaceMember(value, path) {
       ],
       ["docsText"]
     );
-    nonEmptyString3(member.id, `${path}.id`);
-    nonEmptyString3(member.name, `${path}.name`);
+    nonEmptyString2(member.id, `${path}.id`);
+    nonEmptyString2(member.name, `${path}.name`);
     assertOptionalDocsText2(member.docsText, `${path}.docsText`);
     assertFunctionSignature(member, path);
     assertInterfaceMemberAccessModifier(member.accessModifier, path);
@@ -44370,7 +44295,7 @@ function assertEnum2(value, path) {
     ["docsText"]
   );
   assertIdentity2(neoEnum, path, "enum");
-  nonEmptyString3(neoEnum.name, `${path}.name`);
+  nonEmptyString2(neoEnum.name, `${path}.name`);
   assertOptionalDocsText2(neoEnum.docsText, `${path}.docsText`);
   arrayOf(neoEnum.options, `${path}.options`, assertEnumOption);
   assertSystem(neoEnum.system, `${path}.system`);
@@ -44378,7 +44303,7 @@ function assertEnum2(value, path) {
   const options = requireArray(neoEnum.options, `${path}.options`);
   options.forEach((entry, index) => {
     const option = requireRecord(entry, `${path}.options[${index}]`);
-    const key = nonEmptyString3(option.key, `${path}.options[${index}].key`);
+    const key = nonEmptyString2(option.key, `${path}.options[${index}].key`);
     if (seen.has(key))
       invalid(`${path}.options[${index}].key`, "is duplicated.");
     seen.add(key);
@@ -44391,9 +44316,9 @@ function assertEnumOption(value, path) {
     ["id", "name", "key", "text", "source"],
     ["docsText"]
   );
-  nonEmptyString3(option.id, `${path}.id`);
-  nonEmptyString3(option.name, `${path}.name`);
-  nonEmptyString3(option.key, `${path}.key`);
+  nonEmptyString2(option.id, `${path}.id`);
+  nonEmptyString2(option.name, `${path}.name`);
+  nonEmptyString2(option.key, `${path}.key`);
   stringAt(option.text, `${path}.text`);
   assertOptionalDocsText2(option.docsText, `${path}.docsText`);
   assertSourceIdentity(option.source, `${path}.source`, "enumOption");
@@ -44439,7 +44364,7 @@ function assertTextureTemplate(value, path) {
     "swizzle"
   ]);
   assertIdentity2(texture, path, "textureTemplate");
-  nonEmptyString3(texture.name, `${path}.name`);
+  nonEmptyString2(texture.name, `${path}.name`);
   exactValue(texture.type, "texture-2d", `${path}.type`);
   stringIn(texture.textureType, TEXTURE_TYPES, `${path}.textureType`);
   exactValue(texture.textureShape, "2d", `${path}.textureShape`);
@@ -44684,7 +44609,7 @@ function assertAudioTemplate(value, path) {
     "preloadAudioData"
   ]);
   assertIdentity2(audio, path, "audioTemplate");
-  nonEmptyString3(audio.name, `${path}.name`);
+  nonEmptyString2(audio.name, `${path}.name`);
   for (const field of [
     "forceToMono",
     "normalize",
@@ -44726,14 +44651,14 @@ function assertLocalization(value, path) {
     "mainLocaleDefaultStatusId"
   ]);
   assertIdentity2(localization, path, "localization");
-  nonEmptyString3(localization.mainLocale, `${path}.mainLocale`);
+  nonEmptyString2(localization.mainLocale, `${path}.mainLocale`);
   arrayOf(
     localization.supportedLocales,
     `${path}.supportedLocales`,
     assertLocale
   );
   stringArray(localization.sortedStatusIds, `${path}.sortedStatusIds`);
-  nonEmptyString3(
+  nonEmptyString2(
     localization.mainLocaleDefaultStatusId,
     `${path}.mainLocaleDefaultStatusId`
   );
@@ -44754,8 +44679,8 @@ function assertLocalizationStatus(value, path) {
     "system"
   ]);
   assertIdentity2(status, path, "localizationStatus");
-  nonEmptyString3(status.slug, `${path}.slug`);
-  nonEmptyString3(status.name, `${path}.name`);
+  nonEmptyString2(status.slug, `${path}.slug`);
+  nonEmptyString2(status.name, `${path}.name`);
   nullableString3(status.description, `${path}.description`);
   nullableString3(status.color, `${path}.color`);
   nullableString3(status.emoji, `${path}.emoji`);
@@ -44781,7 +44706,7 @@ function assertLocale(value, path) {
     "sortOrder",
     "archivedAt"
   ]);
-  nonEmptyString3(locale.locale, `${path}.locale`);
+  nonEmptyString2(locale.locale, `${path}.locale`);
   nullableNonEmptyString(locale.sourceLocale, `${path}.sourceLocale`);
   nullableString3(locale.name, `${path}.name`);
   finiteNumber2(locale.sortOrder, `${path}.sortOrder`);
@@ -44846,7 +44771,7 @@ function requireArray(value, path) {
 }
 function stringArray(value, path) {
   arrayOf(value, path, (entry, entryPath) => {
-    nonEmptyString3(entry, entryPath);
+    nonEmptyString2(entry, entryPath);
   });
 }
 function nullableStringArray(value, path) {
@@ -44856,8 +44781,8 @@ function nullableStringArray(value, path) {
 function stringRecord(value, path) {
   const record6 = requireRecord(value, path);
   for (const [key, entry] of Object.entries(record6)) {
-    nonEmptyString3(key, `${path} key`);
-    nonEmptyString3(entry, `${path}.${key}`);
+    nonEmptyString2(key, `${path} key`);
+    nonEmptyString2(entry, `${path}.${key}`);
   }
 }
 function uniqueIds(value, path) {
@@ -44865,7 +44790,7 @@ function uniqueIds(value, path) {
   const seen = /* @__PURE__ */ new Set();
   records2.forEach((entry, index) => {
     const record6 = requireRecord(entry, `${path}[${index}]`);
-    const id2 = nonEmptyString3(record6.id, `${path}[${index}].id`);
+    const id2 = nonEmptyString2(record6.id, `${path}[${index}].id`);
     if (seen.has(id2))
       invalid(`${path}[${index}].id`, `duplicates id ${JSON.stringify(id2)}.`);
     seen.add(id2);
@@ -44875,7 +44800,7 @@ function nullableObject(value, path, assertion) {
   if (value === null) return;
   assertion(value, path);
 }
-function nonEmptyString3(value, path) {
+function nonEmptyString2(value, path) {
   const result = stringAt(value, path);
   if (result.length === 0) invalid(path, "must not be empty.");
   return result;
@@ -44901,7 +44826,7 @@ function nullableString3(value, path) {
 }
 function nullableNonEmptyString(value, path) {
   if (value === null) return;
-  nonEmptyString3(value, path);
+  nonEmptyString2(value, path);
 }
 function finiteNumber2(value, path) {
   if (typeof value !== "number" || !Number.isFinite(value)) {
@@ -57976,12 +57901,12 @@ function lowerStructuredLeafComponents(kind, label, expression, lowering) {
 function structuredLeafPartialAssignments(kind, label, value, emit) {
   const stored = value[STRUCTURED_LEAF_PARTIAL_KEY];
   const declared = structuredLeafFields(kind);
-  const unknown2 = Object.keys(stored).find(
+  const unknown = Object.keys(stored).find(
     (key) => !declared.some((entry) => entry.key === key)
   );
-  if (unknown2 !== void 0) {
+  if (unknown !== void 0) {
     throw new Error(
-      `${label} stores unknown field ${JSON.stringify(unknown2)}. ${structuredLeafTypeName(kind)} accepts ${structuredLeafFieldNames(kind).join(", ")}.`
+      `${label} stores unknown field ${JSON.stringify(unknown)}. ${structuredLeafTypeName(kind)} accepts ${structuredLeafFieldNames(kind).join(", ")}.`
     );
   }
   const assignments = [];
@@ -88667,6 +88592,97 @@ function relationEndpointClassId(record6) {
   if (typeof record6.classId === "string") return record6.classId;
   return void 0;
 }
+function relationOrderMaintenanceNoopIds(currentRelations, changes) {
+  const currentById = new Map(
+    currentRelations.map((relation) => [relation.id, relation])
+  );
+  const currentByGroup = /* @__PURE__ */ new Map();
+  for (const relation of currentRelations) {
+    const group = relationOrderGroupKey(relation);
+    const grouped = currentByGroup.get(group) ?? /* @__PURE__ */ new Map();
+    grouped.set(relation.id, relation);
+    currentByGroup.set(group, grouped);
+  }
+  const changesByGroup = /* @__PURE__ */ new Map();
+  const candidatesByGroup = /* @__PURE__ */ new Map();
+  for (const change of changes) {
+    const before = currentById.get(change.recordId);
+    const groups = /* @__PURE__ */ new Set();
+    if (before !== void 0) groups.add(relationOrderGroupKey(before));
+    if (change.deleted !== true && change.operation !== "delete" && isInternalRecordRelation(change.nextData)) {
+      groups.add(relationOrderGroupKey(change.nextData));
+    }
+    for (const group of groups) {
+      const grouped = changesByGroup.get(group) ?? [];
+      grouped.push(change);
+      changesByGroup.set(group, grouped);
+    }
+    if (relationOrderOnlyChangeIsCandidate(before, change)) {
+      const group = relationOrderGroupKey(change.nextData);
+      const candidates = candidatesByGroup.get(group) ?? [];
+      candidates.push(change);
+      candidatesByGroup.set(group, candidates);
+    }
+  }
+  const noops = /* @__PURE__ */ new Set();
+  for (const [group, candidates] of candidatesByGroup) {
+    const groupChanges = changesByGroup.get(group) ?? [];
+    const candidateSet = new Set(candidates);
+    if (groupChanges.some((change) => !candidateSet.has(change))) continue;
+    const current = currentByGroup.get(group) ?? /* @__PURE__ */ new Map();
+    const projected = new Map(current);
+    for (const change of groupChanges) {
+      const before = currentById.get(change.recordId);
+      if (before !== void 0 && relationOrderGroupKey(before) === group) {
+        projected.delete(before.id);
+      }
+      if (change.deleted !== true && change.operation !== "delete" && isInternalRecordRelation(change.nextData) && relationOrderGroupKey(change.nextData) === group) {
+        projected.set(change.nextData.id, change.nextData);
+      }
+    }
+    if (!sameRelationIdSequence(current.values(), projected.values())) continue;
+    for (const candidate of candidates) noops.add(candidate.recordId);
+  }
+  return noops;
+}
+function relationOrderOnlyChangeIsCandidate(before, change) {
+  if (change.recordKind !== "internal-record-relation") return false;
+  if (change.operation !== "update" || change.deleted === true) return false;
+  if (before === void 0 || !isInternalRecordRelation(change.nextData)) {
+    return false;
+  }
+  const nextRelation = change.nextData;
+  const contract = INTERNAL_RECORD_RELATION_KIND_CONTRACTS.find(
+    (candidate) => candidate.relationKind === nextRelation.relationKind
+  );
+  if (contract?.merge !== "ordered-union") return false;
+  return projectRecordDataIsSemanticallyEqual(
+    relationWithoutOrderKey(before),
+    relationWithoutOrderKey(nextRelation)
+  );
+}
+function relationWithoutOrderKey(value) {
+  const semantic = projectRecordSemanticData(value);
+  if (!isPlainRecord3(semantic)) return semantic;
+  const result = { ...semantic };
+  delete result.orderKey;
+  return result;
+}
+function relationOrderGroupKey(relation) {
+  return [
+    relation.relationKind,
+    relation.sourceRecordKind,
+    relation.sourceRecordId
+  ].join("\0");
+}
+function sameRelationIdSequence(left, right) {
+  const sequence = (relations) => [...relations].sort(
+    (a, b) => (a.orderKey ?? "").localeCompare(b.orderKey ?? "") || a.id.localeCompare(b.id)
+  ).map((relation) => relation.id);
+  const leftIds = sequence(left);
+  const rightIds = sequence(right);
+  return leftIds.length === rightIds.length && leftIds.every((relationId, index) => relationId === rightIds[index]);
+}
 function isPlainRecord3(value) {
   if (value === null || typeof value !== "object") return false;
   return !Array.isArray(value);
@@ -97620,6 +97636,47 @@ function orderLocalizedTextWritesBesideLinks(prepared) {
   });
   return ordered;
 }
+function projectVersionBasePayloadBytes(document, changes) {
+  const targets = /* @__PURE__ */ new Map();
+  for (const change of changes) {
+    if (change.operation === "create") continue;
+    const bucket = PROJECT_RECORD_BUCKETS[change.recordKind];
+    let ids = targets.get(bucket);
+    if (ids === void 0) {
+      ids = /* @__PURE__ */ new Set();
+      targets.set(bucket, ids);
+    }
+    ids.add(change.recordId);
+  }
+  const sizes = /* @__PURE__ */ new Map();
+  const raw = {
+    ...document,
+    values: document.physicalValues ?? document.values
+  };
+  const encoder = new TextEncoder();
+  for (const [bucket, ids] of targets) {
+    const value = raw[bucket];
+    if (value == null) continue;
+    const rows = Array.isArray(value) ? value : [value];
+    for (const row of rows) {
+      if (typeof row !== "object" || row === null || !("id" in row) || typeof row.id !== "string")
+        throw new Error("Transaction base record has no ID in " + bucket);
+      if (ids.has(row.id))
+        sizes.set(
+          JSON.stringify([bucket, row.id]),
+          encoder.encode(canonicalJsonStringify(row)).byteLength
+        );
+    }
+  }
+  return changes.map(
+    (change) => sizes.get(
+      JSON.stringify([
+        PROJECT_RECORD_BUCKETS[change.recordKind],
+        change.recordId
+      ])
+    ) ?? 0
+  );
+}
 function addProjectVersionTransactionBudgets(left, right) {
   return {
     argumentBytes: left.argumentBytes + right.argumentBytes,
@@ -98491,13 +98548,6 @@ function* prepareServerOwnedSchemaCommitPasses(args) {
     prepared,
     contentHashHeads: args.contentHashHeads
   });
-  if (args.initializerMaterialization !== void 0) {
-    reconcileInitializerMaterializationTransport({
-      prepared,
-      transport: args.initializerMaterialization,
-      document: applyProjectVersionWriteChanges(args.document, prepared)
-    });
-  }
   drainConstructedGraphValidations({
     document: args.document,
     prepared,
@@ -98966,156 +99016,6 @@ function replayedCreationDataMatches(args) {
   }
   return true;
 }
-function reconcileInitializerMaterializationTransport(args) {
-  const roots = new Map(
-    args.transport.roots.map((root) => [root.sourceValueId, root])
-  );
-  if (roots.size !== args.transport.roots.length) {
-    throw new Error(
-      "Initializer materialization transport contains duplicate source roots."
-    );
-  }
-  const serverCreatedByRoot = /* @__PURE__ */ new Map();
-  for (const change of args.prepared) {
-    if (change.recordKind !== "value" || change.operation === "delete" || change.nextData === void 0) {
-      continue;
-    }
-    const details = change.intent.details;
-    if (typeof details !== "object" || details === null || Reflect.get(details, "source") !== "server-initializer-materialization") {
-      continue;
-    }
-    const sourceValueId = Reflect.get(details, "sourceValueId");
-    if (typeof sourceValueId !== "string") continue;
-    const grouped = serverCreatedByRoot.get(sourceValueId) ?? [];
-    grouped.push(change);
-    serverCreatedByRoot.set(sourceValueId, grouped);
-  }
-  const serverRootIds = new Set(serverCreatedByRoot.keys());
-  for (const sourceValueId of roots.keys()) serverRootIds.add(sourceValueId);
-  const preparedValueChangeById = /* @__PURE__ */ new Map();
-  for (const change of args.prepared) {
-    if (change.recordKind !== "value") continue;
-    if (change.operation === "delete") continue;
-    if (change.nextData !== void 0)
-      preparedValueChangeById.set(change.recordId, change);
-  }
-  const allServerIds = /* @__PURE__ */ new Set();
-  for (const sourceValueId of serverRootIds) {
-    allServerIds.add(sourceValueId);
-    for (const change of serverCreatedByRoot.get(sourceValueId) ?? []) {
-      allServerIds.add(change.recordId);
-    }
-  }
-  const graph = createVariantMaterializedValueGraphContext(
-    args.document,
-    args.document.variants ?? []
-  );
-  const serverOwners = graph.ownersForValues(allServerIds);
-  const effectiveValues = new EffectiveValueReader(args.document);
-  for (const sourceValueId of serverRootIds) {
-    const local = roots.get(sourceValueId);
-    const rootChange = preparedValueChangeById.get(sourceValueId);
-    if (local === void 0)
-      throw new Error(
-        `Initializer materialization parity failed for value "${sourceValueId}": client root is missing.`
-      );
-    if (rootChange === void 0)
-      throw new Error(
-        `Initializer materialization parity failed for value "${sourceValueId}": server root is missing.`
-      );
-    if (local.rows.length === 0)
-      throw new Error(
-        `Initializer materialization transport for value "${sourceValueId}" has no rows.`
-      );
-    if (local.rows[0]?.id !== sourceValueId) {
-      throw new Error(
-        `Initializer materialization transport for value "${sourceValueId}" must be root-first.`
-      );
-    }
-    const serverChanges = [
-      rootChange,
-      ...serverCreatedByRoot.get(sourceValueId) ?? []
-    ];
-    if (serverChanges.length !== local.rows.length) {
-      throw new Error(
-        `Initializer materialization parity failed for value "${sourceValueId}": client produced ${local.rows.length} rows and server produced ${serverChanges.length}.`
-      );
-    }
-    const identities = /* @__PURE__ */ new Set();
-    const serverIdToAssigned = /* @__PURE__ */ new Map();
-    for (let index = 0; index < local.rows.length; index += 1) {
-      const id2 = local.rows[index].id;
-      if (typeof id2 !== "string")
-        throw new Error(
-          `Initializer materialization transport for value "${sourceValueId}" contains an invalid row id at index ${index}.`
-        );
-      if (identities.has(id2))
-        throw new Error(
-          `Initializer materialization transport for value "${sourceValueId}" contains duplicate row id "${id2}".`
-        );
-      identities.add(id2);
-      serverIdToAssigned.set(serverChanges[index].recordId, id2);
-    }
-    const rootRow = graph.valuesById.get(sourceValueId);
-    const owner = effectiveValues.memberForValue(sourceValueId);
-    if (rootRow === void 0)
-      throw new Error(
-        `Initializer parity root "${sourceValueId}" has no value row.`
-      );
-    if (owner === void 0)
-      throw new Error(
-        `Initializer parity root "${sourceValueId}" has no member placement.`
-      );
-    const env = graph.genericEnvironmentForRow(rootRow, owner);
-    const type = graph.typeInfoForMember(owner, env);
-    if (type === null)
-      throw new Error(
-        `Initializer parity root "${sourceValueId}" has no concrete type.`
-      );
-    const assignedServerRows = [];
-    const serverRowsById = /* @__PURE__ */ new Map();
-    for (const change of serverChanges) {
-      if (!isMemberValue(change.nextData))
-        throw new Error(
-          `Initializer materialization server row "${change.recordId}" is invalid.`
-        );
-      const row = graph.rewriteReferences({
-        row: change.nextData,
-        replacements: serverIdToAssigned,
-        ownerValueId: change.recordId,
-        owner: serverOwners.get(change.recordId)
-      });
-      assignedServerRows.push(row);
-      serverRowsById.set(row.id, row);
-    }
-    const normalizedServer = effectiveValues.withRowOverrides(serverRowsById).normalizeTypedRow(sourceValueId, type, owner, env, identities);
-    const localRows = /* @__PURE__ */ new Map();
-    for (const row of local.rows) {
-      if (!isMemberValue(row))
-        throw new Error(
-          `Initializer materialization transport for value "${sourceValueId}" contains an invalid value row.`
-        );
-      localRows.set(row.id, row);
-    }
-    const normalizedLocal = effectiveValues.withRowOverrides(localRows).normalizeTypedRow(sourceValueId, type, owner, env, identities);
-    if (!effectiveValuesEqual(normalizedServer, normalizedLocal)) {
-      throw new Error(
-        `Initializer materialization parity failed for value "${sourceValueId}": CLI and server graphs differ.`
-      );
-    }
-    for (const [index, change] of serverChanges.entries()) {
-      const assignedRow = assignedServerRows[index];
-      change.recordId = assignedRow.id;
-      change.nextData = assignedRow;
-    }
-    roots.delete(sourceValueId);
-  }
-  if (roots.size > 0) {
-    throw new Error(
-      `Initializer materialization transport names roots the server did not materialize: ${[...roots.keys()].join(", ")}.`
-    );
-  }
-}
 function constructorArgumentsSemanticallyEqual(args) {
   const current = args.currentReader;
   const replayRows = /* @__PURE__ */ new Map([
@@ -99873,9 +99773,9 @@ function materializeAuthoredValueSeeds(args) {
       member: materializationMember,
       // P61 must leave a computed static root as an init-backed prepared
       // row until `materializePreparedInstanceInitializers` runs. The
-      // default builder evaluates it immediately, which bypasses both
-      // the server-initializer-materialization grouping and the CLI's
-      // parity/identity transport for evaluator-created interior rows.
+      // default builder evaluates it immediately, which bypasses the
+      // initializer-materialization grouping for evaluator-created
+      // interior rows.
       seed: { ...seed, values: seed.values ?? [] }
     });
     const { createdValues, localizedTexts, storageKeyDeclarations, rootValue } = materialized;
@@ -113037,12 +112937,12 @@ function lowerGenericRelations(context, analysis) {
       );
     }
     const args = expressionArguments(expression);
-    const unknown2 = [...args.keys()].find(
+    const unknown = [...args.keys()].find(
       (name) => !["kind", "source", "target", "order"].includes(name)
     );
-    if (unknown2 !== void 0) {
+    if (unknown !== void 0) {
       throw new Error(
-        `ProjectRelations[${index}] has unknown argument ${JSON.stringify(unknown2)}.`
+        `ProjectRelations[${index}] has unknown argument ${JSON.stringify(unknown)}.`
       );
     }
     const kind = args.get("kind");
@@ -117585,7 +117485,7 @@ function materializeInitializersLocallyV4(args) {
       },
       // §4: a call-site field is an explicit override even when it equals the
       // class default, so the evaluated construction's own field list is what
-      // pins rows against collapse. The server commit pins the same set.
+      // pins rows against collapse. Push preparation pins the same set.
       pinnedRootSchemaKeys,
       virtualValueIdForSource: (instanceRootId, sourceIdentity3) => isPendingId(instanceRootId) || hasPendingVirtualSourceIdentity(sourceIdentity3) ? pendingVirtualValueId(instanceRootId, sourceIdentity3) : virtualValueId(instanceRootId, sourceIdentity3)
     });
@@ -117902,6 +117802,25 @@ function compareWorkspacePaths(left, right) {
   if (left > right) return 1;
   return 0;
 }
+function materializeWorkspaceStatusInitializers(workspace, status, forceRecompile) {
+  return materializeInitializersLocallyV4({
+    workspace,
+    forceRecompile,
+    changes: status.changes.map((change) => ({
+      recordKind: change.recordKind,
+      recordId: change.recordId,
+      operation: change.kind,
+      nextData: change.kind === "delete" ? void 0 : change.nextData,
+      deleted: change.kind === "delete" ? true : void 0,
+      intent: createNeoCliPushIntent(change),
+      expectedBaseContentHash: change.kind === "create" ? null : change.casBaseHash ?? null
+    })),
+    authoredValueSeeds: Array.from(
+      status.authoredValueSeeds,
+      ([memberId, seed]) => ({ memberId, ...seed })
+    )
+  });
+}
 function computeWorkspaceStatus(workspace, options) {
   let phaseStarted = performance.now();
   options.onPhase?.("Reading project schema\u2026");
@@ -118649,39 +118568,25 @@ function computeWorkspaceStatus(workspace, options) {
       )
     );
   }
-  let localInitializerMaterialization;
-  try {
-    localInitializerMaterialization = materializeInitializersLocallyV4({
-      workspace,
-      forceRecompile: options.forceRecompile,
-      changes: changes.map((change) => ({
-        recordKind: change.recordKind,
-        recordId: change.recordId,
-        operation: change.kind,
-        nextData: change.kind === "delete" ? void 0 : change.nextData,
-        deleted: change.kind === "delete" ? true : void 0,
-        intent: createNeoCliPushIntent(change),
-        expectedBaseContentHash: change.kind === "create" ? null : change.casBaseHash ?? null
-      })),
-      authoredValueSeeds: Array.from(
-        authoredValueSeeds,
-        ([memberId, seed]) => ({
-          memberId,
-          ...seed
-        })
-      )
-    });
-  } catch (error) {
-    parseErrors.push(
-      new SchemaSourceError(
-        error instanceof Error ? error.message : String(error),
-        "<initializer-materialization>",
-        1,
-        1
-      )
-    );
+  if (options.skipInitializerMaterialization !== true) {
+    try {
+      materializeWorkspaceStatusInitializers(
+        workspace,
+        { changes, authoredValueSeeds },
+        options.forceRecompile
+      );
+    } catch (error) {
+      parseErrors.push(
+        new SchemaSourceError(
+          error instanceof Error ? error.message : String(error),
+          "<initializer-materialization>",
+          1,
+          1
+        )
+      );
+    }
+    reportPhase("initializer-materialization");
   }
-  reportPhase("initializer-materialization");
   return {
     ...projectAnalysisV4 === null ? {} : {
       sourceSnapshot: {
@@ -118697,7 +118602,6 @@ function computeWorkspaceStatus(workspace, options) {
     reconstructed: reconstructed3,
     authoredValueSeeds,
     pendingValueIdentitySites: valueLowerRegistry.pendingValueIdentitySites,
-    localInitializerMaterialization,
     binaryChanges,
     binaryFiles,
     initConversions: collectInitDefaultConversions(
@@ -119779,6 +119683,7 @@ function verifyProjectSourceCommitAgainstStateV4(args) {
   const status = computeWorkspaceStatus(workspace, {
     forceRecompile: args.forceRecompile,
     skipProjectBinaryInspection: true,
+    skipInitializerMaterialization: true,
     useBuildCaches: false,
     writeProjectAnalysisCache: () => void 0,
     trustedPendingProjectFiles,
@@ -119824,9 +119729,6 @@ function verifyProjectSourceCommitAgainstStateV4(args) {
       ...rewrite(seed)
     })
   );
-  const expectedInitializerMaterialization = rewrite(
-    status.localInitializerMaterialization ?? { roots: [] }
-  );
   for (const pendingId2 of assignments.keys()) {
     if (!usedAssignments.has(pendingId2)) {
       throw new ProjectSourceCommitVerificationError(
@@ -119845,10 +119747,6 @@ function verifyProjectSourceCommitAgainstStateV4(args) {
   });
   compareChanges(expectedChanges, verifiableChanges);
   compareSeeds(expectedSeeds, args.authoredValueSeeds);
-  compareInitializerMaterialization(
-    expectedInitializerMaterialization,
-    args.initializerMaterialization ?? { roots: [] }
-  );
 }
 function isDerivedOnlyRefresh(change, stateRecords) {
   if (change.operation !== "update") return false;
@@ -120242,33 +120140,6 @@ function compareSeeds(expected, received) {
     );
   }
 }
-function compareInitializerMaterialization(expected, received) {
-  const normalize = (transport) => ({
-    roots: transport.roots.map((root) => ({
-      sourceValueId: root.sourceValueId,
-      rows: [...root.rows].map((row) => {
-        const normalized = { ...row };
-        delete normalized.createdAt;
-        delete normalized.updatedAt;
-        return normalized;
-      }).sort(
-        (left, right) => String(left.id ?? "").localeCompare(String(right.id ?? ""))
-      )
-    })).sort(
-      (left, right) => left.sourceValueId.localeCompare(right.sourceValueId)
-    )
-  });
-  const normalizedExpected = normalize(expected);
-  const normalizedReceived = normalize(received);
-  if (canonicalStringify(normalizedExpected) !== canonicalStringify(normalizedReceived)) {
-    const difference = firstDifference(normalizedExpected, normalizedReceived);
-    const rootIndex = difference === null ? null : /^\$\.roots\[(\d+)\]/u.exec(difference.path)?.[1];
-    const sourceValueId = rootIndex === null || rootIndex === void 0 ? void 0 : normalizedExpected.roots[Number(rootIndex)]?.sourceValueId;
-    throw new ProjectSourceCommitVerificationError(
-      `Source commit initializer materialization does not match trusted evaluation${difference === null ? "." : `${sourceValueId === void 0 ? "" : ` for root ${JSON.stringify(sourceValueId)}`} at ${difference.path}: trusted ${formatDifferenceValue(difference.trusted)}, submitted ${formatDifferenceValue(difference.submitted)}.`}`
-    );
-  }
-}
 function normalizeSeedForComparison(seed) {
   const normalized = { ...seed };
   if (seed.values !== void 0) {
@@ -120376,7 +120247,7 @@ var init_trusted_commit_verification = __esm({
 });
 
 // src/project-source/server-preparation-preflight.ts
-function assertServerPreparationSucceeds(args) {
+function prepareClientPush(args) {
   for (const change of args.changes) {
     if (change.recordKind !== "value" || change.operation !== "update") {
       continue;
@@ -120388,14 +120259,40 @@ function assertServerPreparationSucceeds(args) {
     });
     if (refusal !== null) throw new ServerPreparationPreflightError(refusal);
   }
+  const base = readPulledPreparationBase(args);
+  let prepared;
   try {
-    return prepareServerPreparationChanges({
-      ...args,
-      initializerMaterialization: args.localInitializerMaterialization
-    });
+    prepared = prepareAgainstPulledBase(args, base);
   } catch (error) {
     throw locateBodyCompileFailure(error, args.sourceByRecord);
   }
+  const relationOrderNoopIds = relationOrderMaintenanceNoopIds(
+    base.document.internalRecordRelations ?? [],
+    prepared
+  );
+  const changes = [];
+  for (const change of prepared) {
+    if (change.recordKind === "internal-record-relation" && relationOrderNoopIds.has(change.recordId)) {
+      continue;
+    }
+    changes.push({
+      ...change,
+      expectedBaseContentHash: change.expectedBaseContentHash === void 0 ? pulledCasBaseHash(
+        change,
+        args.workspace.state.records[`${change.recordKind}:${change.recordId}`]
+      ) : change.expectedBaseContentHash
+    });
+  }
+  return {
+    changes,
+    basePayloadBytes: projectVersionBasePayloadBytes(base.document, changes)
+  };
+}
+function pulledCasBaseHash(change, record6) {
+  if (change.operation === "create") return null;
+  if (record6 === void 0) return null;
+  if (record6.conflictServerHash !== void 0) return record6.conflictServerHash;
+  return record6.contentHash;
 }
 function assertDerivedEdgeCompatibility(workspace) {
   const localVersion = PROJECT_SNAPSHOT_DERIVED_EDGE_EXTRACTOR_VERSION;
@@ -120460,15 +120357,22 @@ function prepareWithScopedSafetyValve(args) {
   args.validate(full);
   return full;
 }
-function prepareServerPreparationChanges(args) {
+function readPulledPreparationBase(args) {
   const serverTimestamp = args.serverTimestamp ?? Date.now();
   const rawDocument = pulledProjectDocumentRaw(args.workspace);
-  const document = withReplayValueIdFactory(
-    withStoredValueBase(readProjectDocument(rawDocument)),
-    args.createValueId,
+  return {
+    rawDocument,
+    document: withReplayValueIdFactory(
+      withStoredValueBase(readProjectDocument(rawDocument)),
+      args.createValueId,
+      serverTimestamp
+    ),
+    contentHashHeads: readProjectDocumentContentHashHeads(rawDocument),
     serverTimestamp
-  );
-  const contentHashHeads = readProjectDocumentContentHashHeads(rawDocument);
+  };
+}
+function prepareAgainstPulledBase(args, base) {
+  const { rawDocument, document, contentHashHeads, serverTimestamp } = base;
   const changes = args.changes.map((change) => ({
     ...change,
     recordKind: narrowRecordKind(
@@ -120520,7 +120424,6 @@ function prepareServerPreparationChanges(args) {
     contentHashHeads,
     changes: trustedChanges,
     authoredValueSeeds: args.authoredValueSeeds,
-    initializerMaterialization: args.initializerMaterialization,
     // A CLI push is always a trusted-source commit, so the server always
     // expands read-only source conversions for it.
     expandReadOnlySourceConversions: true,
@@ -120886,6 +120789,8 @@ var init_server_preparation_preflight = __esm({
     init_project_document_read();
     init_project_snapshot_derived_edges();
     init_project_version_schema_commit();
+    init_project_version_relation_sweep_trigger();
+    init_project_version_transaction_planning();
     init_project_version_whole_graph_validation();
     init_project_world_placement_bindings();
     init_build_default_member_value();
@@ -130626,18 +130531,28 @@ async function createConvexPushConnection(workspace) {
       const bytes = Buffer2.from(json);
       if (bytes.byteLength > SCHEMA_COMMIT_HTTP_MAX_DECODED_BYTES)
         throw new NeoApiError(
-          "Schema commit requires the large-payload route.",
+          `Schema commit is ${bytes.byteLength} bytes decoded; the limit is ${SCHEMA_COMMIT_HTTP_MAX_DECODED_BYTES}.`,
           413,
-          { error: "schema-commit-route-required" }
+          {
+            error: "schema-commit-too-large",
+            measure: "decoded",
+            bytes: bytes.byteLength,
+            limitBytes: SCHEMA_COMMIT_HTTP_MAX_DECODED_BYTES
+          }
         );
       const compressed = bytes.byteLength >= 1024 ? gzipSync(bytes) : bytes;
       const gzip = compressed.byteLength < bytes.byteLength;
       const payload = gzip ? compressed : bytes;
       if (payload.byteLength > SCHEMA_COMMIT_HTTP_MAX_BYTES)
         throw new NeoApiError(
-          "Schema commit exceeds the HTTP body limit.",
+          `Schema commit is ${payload.byteLength} bytes encoded; the limit is ${SCHEMA_COMMIT_HTTP_MAX_BYTES}.`,
           413,
-          { error: "schema-commit-route-required" }
+          {
+            error: "schema-commit-too-large",
+            measure: "encoded",
+            bytes: payload.byteLength,
+            limitBytes: SCHEMA_COMMIT_HTTP_MAX_BYTES
+          }
         );
       const client = new NeoApiClient(siteUrl, await tokenCache.getToken());
       const path = `${SCHEMA_COMMIT_HTTP_PATH}?${new URLSearchParams({ projectId: workspace.config.projectId, versionId: workspace.config.versionId })}`;
@@ -132103,7 +132018,7 @@ import {
   statSync
 } from "node:fs";
 import { join as join11, relative as relative6, sep as sep6 } from "node:path";
-function assignPendingIds(changes, authoredValueSeeds, reconstructed3, localInitializerMaterialization) {
+function assignPendingIds(changes, authoredValueSeeds, reconstructed3) {
   const assigned = /* @__PURE__ */ new Map();
   const assign = (pendingId2) => {
     const existing = assigned.get(pendingId2);
@@ -132178,9 +132093,6 @@ function assignPendingIds(changes, authoredValueSeeds, reconstructed3, localInit
       collect(record6.fullData);
     }
   }
-  if (localInitializerMaterialization !== void 0) {
-    collect(localInitializerMaterialization);
-  }
   const rewriteString = createIdentityRewriter(assigned);
   const rewrite = (value) => {
     if (assigned.size === 0) return value;
@@ -132290,16 +132202,7 @@ function assignPendingIds(changes, authoredValueSeeds, reconstructed3, localInit
       reconstructed3.set(key, record6);
     }
   }
-  const rewrittenLocalInitializerMaterialization = localInitializerMaterialization === void 0 ? void 0 : rewrite(
-    localInitializerMaterialization
-  );
-  return {
-    assigned,
-    authoredValueSeeds: rewrittenSeeds,
-    ...rewrittenLocalInitializerMaterialization === void 0 ? {} : {
-      localInitializerMaterialization: rewrittenLocalInitializerMaterialization
-    }
-  };
+  return { assigned, authoredValueSeeds: rewrittenSeeds };
 }
 function pendingInterfaceMemberSymbolOwner(value) {
   const marker = ":member:";
@@ -132315,11 +132218,14 @@ function pendingInterfaceMemberSymbolOwner(value) {
 }
 async function commitProjectVersionChanges(args) {
   const { workspace } = args;
-  const body = {
+  const body = clientPreparedCommitBody({
+    workspace,
     operation: args.operation,
-    changes: args.changes,
-    authoredValueSeeds: [],
-    initializerMaterialization: { roots: [] },
+    prepared: prepareClientPush({
+      workspace,
+      changes: args.changes,
+      authoredValueSeeds: []
+    }),
     stagedFiles: [],
     stagedUploadSessionId: null,
     // The asynchronous path keys reconnects on this identity; the rows name
@@ -132330,11 +132236,8 @@ async function commitProjectVersionChanges(args) {
       )
     ).digest("hex"),
     pendingIdAssignments: {},
-    summary: args.summary,
-    headTransactionHash: workspace.state.headTransactionHash ?? null,
-    derivedEdgeExtractorVersion: PROJECT_SNAPSHOT_DERIVED_EDGE_EXTRACTOR_VERSION,
-    forceRecompile: false
-  };
+    summary: args.summary
+  });
   const reporter = createPushProgressReporter(args.json, args.progressLabel);
   reporter.report({
     type: "project-transaction-progress",
@@ -132349,19 +132252,7 @@ async function commitProjectVersionChanges(args) {
   });
   try {
     const connection = await createConvexPushConnection(workspace);
-    let response;
-    try {
-      response = await connection.submit(body, false);
-    } catch (error) {
-      if (!(error instanceof NeoApiError) || error.status !== 413 || !isObjectRecord2(error.body) || error.body.error !== "schema-commit-route-required")
-        throw error;
-      response = await NeoApiClient.forBaseUrl(
-        workspace.config.apiBaseUrl
-      ).post(
-        `/api/projects/${workspace.config.projectId}/versions/${workspace.config.versionId}/schema/commit`,
-        body
-      );
-    }
+    const response = await connection.submit(body, false);
     const accepted = readAcceptedProjectVersionCommitResponse(response);
     if (accepted === null) {
       if (!isObjectRecord2(response) || typeof response.kind !== "string") {
@@ -132388,6 +132279,23 @@ async function commitProjectVersionChanges(args) {
     reporter.stop();
   }
 }
+function clientPreparedCommitBody(args) {
+  return {
+    operation: args.operation,
+    changes: args.prepared.changes,
+    basePayloadBytes: args.prepared.basePayloadBytes,
+    stagedFiles: args.stagedFiles,
+    stagedUploadSessionId: args.stagedUploadSessionId,
+    sourceHash: args.sourceHash,
+    pendingIdAssignments: args.pendingIdAssignments,
+    summary: args.summary,
+    // P43 §4. Preparation ran against the pulled snapshot, so the server
+    // refuses the push unless that snapshot is still the project head.
+    headTransactionHash: args.workspace.state.headTransactionHash ?? null,
+    derivedEdgeExtractorVersion: PROJECT_SNAPSHOT_DERIVED_EDGE_EXTRACTOR_VERSION,
+    compilerRevision: NEOSCRIPT_COMPILER_REVISION
+  };
+}
 function readAcceptedProjectVersionCommitResponse(value) {
   if (!isObjectRecord2(value) || value.kind !== "accepted") return null;
   if (typeof value.transactionId !== "string") {
@@ -132929,7 +132837,8 @@ async function preparePushStatus(workspace, options, onPhase = () => void 0) {
   onPhase("Analyzing working copy\u2026");
   const status = computeWorkspaceStatus2(workspace, {
     onPhase,
-    forceRecompile: options.forceRecompile
+    forceRecompile: options.forceRecompile,
+    skipInitializerMaterialization: true
   });
   if (status.conflictedFiles.length > 0) {
     throw new Error(
@@ -132967,11 +132876,6 @@ ${blockingErrors.map((error) => `  ${error.message}`).join("\n")}`
   }
   const blockedConversions = describeBlockingInitConversions(initConversions);
   if (blockedConversions !== null) throw new Error(blockedConversions);
-  if (!options.acceptBump && (workspace.state.headTransactionHash === void 0 || workspace.state.headTransactionHash === null)) {
-    throw new Error(
-      'This workspace has no recorded project head, so a push cannot be proven to be a fast-forward. Run "neo pull" first, or re-run with "neo push --accept-bump" to force the write.'
-    );
-  }
   prepareNSPropertySetterChanges(workspace, status);
   prepareNSFunctionBodyChanges(workspace, status);
   const needsNeoScriptCompilation = status.changes.some(
@@ -133250,41 +133154,24 @@ async function runPush(workspace, options, preparationOverride) {
     pendingAssignment,
     transactionOperation,
     client,
-    transportChanges,
-    transportSeeds,
+    clientPrepared,
     stagedUploadSessionId
   } = preparedPush;
   const { stagedFiles } = preparedPush;
   let pushConnection;
   const commit = async (force) => {
-    const body = {
+    const body = clientPreparedCommitBody({
+      workspace,
       operation: transactionOperation,
-      changes: transportChanges,
-      authoredValueSeeds: transportSeeds,
-      initializerMaterialization: pendingAssignment.localInitializerMaterialization ?? { roots: [] },
+      prepared: clientPrepared,
       stagedFiles,
       stagedUploadSessionId,
       sourceHash: source.sourceHash,
       pendingIdAssignments: Object.fromEntries(pendingAssignment.assigned),
-      summary: options.summary ?? "neo push",
-      // P43 §4. The local evaluator computes against the pulled snapshot, so
-      // the server rejects a push whose base is not the project head.
-      headTransactionHash: workspace.state.headTransactionHash ?? null,
-      derivedEdgeExtractorVersion: PROJECT_SNAPSHOT_DERIVED_EDGE_EXTRACTOR_VERSION,
-      forceRecompile: options.forceRecompile === true
-    };
+      summary: options.summary ?? "neo push"
+    });
     pushConnection ??= await createConvexPushConnection(workspace);
-    try {
-      return await pushConnection.submit(body, force);
-    } catch (error) {
-      if (!(error instanceof NeoApiError) || error.status !== 413 || !isObjectRecord2(error.body) || error.body.error !== "schema-commit-route-required")
-        throw error;
-    }
-    return await client.post(
-      `/api/projects/${workspace.config.projectId}/versions/${workspace.config.versionId}/schema/commit`,
-      body,
-      force ? { "x-neo-force-project-version-write": "true" } : void 0
-    );
+    return await pushConnection.submit(body, force);
   };
   const finishCommitResponse = async (response, reporter) => {
     let accepted;
@@ -133322,7 +133209,7 @@ async function runPush(workspace, options, preparationOverride) {
         errorMessage: null
       });
       reporter.stop();
-      reportAdditionalServerChanges(
+      reportDerivedChanges(
         committedChangeCount,
         status.changes.length,
         options.json === true
@@ -133410,7 +133297,7 @@ async function runPush(workspace, options, preparationOverride) {
       errorMessage: null
     });
     reporter.stop();
-    reportAdditionalServerChanges(
+    reportDerivedChanges(
       completed.totalChangeCount,
       status.changes.length,
       options.json === true
@@ -133512,7 +133399,7 @@ async function runPush(workspace, options, preparationOverride) {
   await finishCommitResponse(result, progress);
 }
 function isDefinitiveSchemaCommitRejection(error) {
-  return error.status === 400 || error.status === 401 || error.status === 403 || error.status === 404 || error.status === 409;
+  return error.status === 400 || error.status === 401 || error.status === 403 || error.status === 404 || error.status === 409 || error.status === 413;
 }
 async function prepareLocalPushArtifactsV4(workspace, status, onPhase = () => void 0, options = {
   fullValidation: true,
@@ -133531,22 +133418,11 @@ async function prepareLocalPushArtifactsV4(workspace, status, onPhase = () => vo
     status,
     status.authoredValueSeeds
   ) : null;
-  const pendingTransportChanges = transportChangesForStatus(status);
-  const pendingTransportSeeds = [...status.authoredValueSeeds].map(
-    ([memberId, seed]) => ({ memberId, ...seed })
-  );
-  const localInitializerMaterialization = status.localInitializerMaterialization ?? materializeInitializersLocallyV4({
-    workspace,
-    changes: pendingTransportChanges,
-    authoredValueSeeds: pendingTransportSeeds,
-    forceRecompile: options.forceRecompile
-  });
   onPhase("Assigning pending value identities\u2026");
   const pendingAssignment = assignPendingIds(
     status.changes,
     status.authoredValueSeeds,
-    status.reconstructed,
-    localInitializerMaterialization
+    status.reconstructed
   );
   const operations = new Set(status.changes.map((change) => change.kind));
   const transactionOperation = operations.size === 1 ? status.changes[0].kind : "update";
@@ -133560,11 +133436,11 @@ async function prepareLocalPushArtifactsV4(workspace, status, onPhase = () => vo
     binaryChanges: status.binaryChanges ?? [],
     assignedIds: pendingAssignment.assigned
   });
+  const stagedRecordIds = new Set(preparedFiles.map((file) => file.recordId));
   assertPushedRecordsPassDomainGuards(
     status.changes,
     localizedTextCreateEnvelopeConfig2(workspace, status.changes)
   );
-  let preparedChanges = null;
   if (verificationSource !== null) {
     onPhase("Verifying the assigned-id source rewrite\u2026");
     materializeAssignedSchemaIdsInAuthoredSource(
@@ -133581,36 +133457,47 @@ async function prepareLocalPushArtifactsV4(workspace, status, onPhase = () => vo
       files: verificationSource.files,
       changes: transportChanges,
       authoredValueSeeds: transportSeeds,
-      initializerMaterialization: pendingAssignment.localInitializerMaterialization ?? { roots: [] },
       forceRecompile: options.forceRecompile,
       pendingIdAssignments: Object.fromEntries(pendingAssignment.assigned),
       stagedFiles: preparedFiles
     });
-    onPhase(
-      `Rehearsing server validation for ${transportChanges.length.toLocaleString("en-US")} change(s)\u2026`
-    );
-    preparedChanges = assertServerPreparationSucceeds({
+  }
+  onPhase(
+    `Preparing ${transportChanges.length.toLocaleString("en-US")} change(s)\u2026`
+  );
+  const finishPreparation = startPerformanceSpan("client-preparation");
+  let prepared;
+  try {
+    prepared = prepareClientPush({
       workspace,
       changes: completeLocallyStagedProjectFileChanges({
         projectId: workspace.config.projectId,
         changes: transportChanges,
-        stagedRecordIds: new Set(preparedFiles.map((file) => file.recordId))
+        stagedRecordIds
       }),
       authoredValueSeeds: transportSeeds,
       sourceByRecord: status.reconstructed,
-      localInitializerMaterialization: pendingAssignment.localInitializerMaterialization,
       forceRecompile: options.forceRecompile
     });
+  } finally {
+    finishPreparation();
   }
   return {
     source,
     submittedStatus,
     pendingAssignment,
     transactionOperation,
-    transportChanges,
-    transportSeeds,
     preparedFiles,
-    preparedChanges
+    /** The prepared graph with local stand-ins for staged file storage. */
+    preparedChanges: prepared.changes,
+    clientPrepared: {
+      changes: restoreStagedProjectFileStorage(
+        prepared.changes,
+        transportChanges,
+        stagedRecordIds
+      ),
+      basePayloadBytes: prepared.basePayloadBytes
+    }
   };
 }
 async function prepareLocalCandidateV4(workspace, options = {}) {
@@ -133735,14 +133622,50 @@ function completeLocallyStagedProjectFileChanges(args) {
         ...change.nextData,
         id: change.recordId,
         projectId: args.projectId,
-        status: "uploaded",
-        storageKey: `local-candidate/${change.recordId}`,
-        storageETag: "local-candidate"
+        ...localStagedProjectFileStorage(change.recordId)
       }
     };
     return completed;
   });
 }
+function localStagedProjectFileStorage(recordId) {
+  return {
+    status: "uploaded",
+    storageKey: `local-candidate/${recordId}`,
+    storageETag: "local-candidate"
+  };
+}
+function restoreStagedProjectFileStorage(prepared, transportChanges, stagedRecordIds) {
+  if (stagedRecordIds.size === 0) return prepared;
+  const authoredById = /* @__PURE__ */ new Map();
+  for (const change of transportChanges) {
+    if (!stagedRecordIds.has(change.recordId)) continue;
+    if (change.nextData === void 0) {
+      throw new Error(
+        `Staged project file ${change.recordId} has no local source record.`
+      );
+    }
+    authoredById.set(change.recordId, change.nextData);
+  }
+  return prepared.map((change) => {
+    if (change.recordKind !== "project-file") return change;
+    const authored = authoredById.get(change.recordId);
+    if (authored === void 0) return change;
+    if (!isObjectRecord2(change.nextData)) {
+      throw new Error(
+        `Prepared staged project file ${change.recordId} has no record data.`
+      );
+    }
+    const nextData = { ...change.nextData };
+    for (const field of Object.keys(
+      localStagedProjectFileStorage(change.recordId)
+    )) {
+      if (authored[field] === void 0) delete nextData[field];
+      else nextData[field] = authored[field];
+    }
+    return { ...change, nextData };
+  });
+}
 function transportChangesForStatus(status) {
   return status.changes.map((change) => ({
     recordKind: change.recordKind,
@@ -134107,6 +134030,12 @@ function reportPushRejection(status, body) {
     );
     return;
   }
+  if (isObjectRecord2(body) && body.error === "schema-commit-too-large") {
+    console.error(
+      typeof body.bytes === "number" && typeof body.limitBytes === "number" ? `Push rejected: the prepared commit is ${body.bytes.toLocaleString("en-US")} bytes ${String(body.measure)}, over the ${body.limitBytes.toLocaleString("en-US")}-byte limit.` : "Push rejected: the prepared commit is over the server's body limit."
+    );
+    return;
+  }
   console.error(`Push rejected (${status}): ${JSON.stringify(body)}`);
 }
 function applyCommittedHeadTransactionHash(workspace, result) {
@@ -134142,11 +134071,11 @@ function immediateCommittedChangeCount(result) {
   }
   return result.changedRecords.length;
 }
-function reportAdditionalServerChanges(totalChangeCount, authoredChangeCount, json) {
+function reportDerivedChanges(totalChangeCount, authoredChangeCount, json) {
   if (json || totalChangeCount <= authoredChangeCount) return;
   console.log(
     color.dim(
-      `Server prepared ${totalChangeCount - authoredChangeCount} additional derived record change(s) (${totalChangeCount} total).`
+      `Push preparation added ${totalChangeCount - authoredChangeCount} derived record change(s) (${totalChangeCount} total).`
     )
   );
 }
@@ -135514,7 +135443,6 @@ var init_push = __esm({
     init_project_file_push();
     init_trusted_commit_verification();
     init_server_preparation_preflight();
-    init_local_initializer_materialization();
     init_initializer_replay();
     init_project_version_validation();
     init_project2();
@@ -140824,7 +140752,7 @@ var init_registry2 = __esm({
   "schema-contract/registry.mjs"() {
     "use strict";
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
-      cliVersion: "0.58.3",
+      cliVersion: "0.59.0",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -148539,7 +148467,7 @@ ${h("Usage")}
 
 ${h("Flags")}
   --dry-run         ${d("Preview the change set; commit nothing.")}
-  --force-recompile ${d("Exhaustively recompile every stored NeoScript body through the durable server path (parity/recovery; slower, and may surface unrelated invalid bodies).")}
+  --force-recompile ${d("Exhaustively recompile every stored NeoScript body during push preparation (parity/recovery; slower, and may surface unrelated invalid bodies).")}
   --summary <text>  ${d("Attach a summary message to the transaction.")}
   --accept-bump     ${d("Accept a server-required version bump instead of aborting.")}
   --json            ${d("Emit machine-readable plan and transaction progress events.")}
@@ -148645,7 +148573,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.58.3");
+    console.log("0.59.0");
     return;
   }
   if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {