@neocompose/cli 0.58.3 → 0.59.1

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 })}`;
@@ -131239,9 +131154,286 @@ var init_concurrency = __esm({
   }
 });
 
+// src/project-source/project-file-pull.ts
+import {
+  existsSync as existsSync8,
+  mkdtempSync,
+  readFileSync as readFileSync11,
+  rmSync as rmSync5,
+  writeFileSync as writeFileSync8
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join as join9 } from "node:path";
+async function pullProjectBinariesV4(args) {
+  const resolvePath = createWorkspaceSourcePathResolver(args.workspace.root);
+  const plans = /* @__PURE__ */ new Map();
+  const downloads = [];
+  const localById = new Map(
+    (args.localBinaries ?? []).map((binary) => [binary.fileId, binary])
+  );
+  const states = /* @__PURE__ */ new Map();
+  const conflicts = [];
+  let downloaded = 0;
+  let conflicted = 0;
+  for (const record6 of args.document.records.values()) {
+    if (record6.deleted || record6.recordKind !== "project-file") continue;
+    if (!isObjectRecord2(record6.data)) {
+      throw new Error(`project-file:${record6.recordId} must be an object.`);
+    }
+    if (record6.data.status !== "uploaded") continue;
+    const existing = plans.get(record6.recordId);
+    if (existing !== void 0) {
+      if (existing.contentHash !== record6.contentHash)
+        throw new Error(
+          `Project file ${record6.recordId} appears with conflicting content hashes in the pulled document.`
+        );
+      continue;
+    }
+    const key = `project-file:${record6.recordId}`;
+    const previous = args.previousRecords[key];
+    const localStatus = localById.get(record6.recordId);
+    const declarationPresent = args.destructive === true || args.localBinaries === void 0 || previous === void 0 || localStatus !== void 0;
+    const path = localStatus?.path ?? previous?.projectBinary?.path ?? canonicalProjectBinaryPathV42(record6.data);
+    const absolute = resolvePath(path);
+    const localDigest = existsSync8(absolute) ? sha256File(absolute) : null;
+    const baseDigest = previous?.projectBinary?.sha256 ?? readSha256(previous?.data) ?? null;
+    const remoteDigest = requiredSha256(
+      record6.data,
+      `project-file:${record6.recordId} metadata`
+    );
+    let action = planBinaryMergeV4({
+      baseDigest,
+      localDigest,
+      remoteDigest,
+      declarationPresent,
+      hadLocalBytes: previous?.projectBinary !== void 0
+    });
+    if (args.destructive === true) {
+      action = localDigest === remoteDigest ? "unchanged" : "download";
+    }
+    const plan = {
+      key,
+      fileId: record6.recordId,
+      contentHash: record6.contentHash,
+      data: record6.data,
+      previous,
+      path,
+      baseDigest,
+      remoteDigest,
+      action
+    };
+    plans.set(record6.recordId, plan);
+    if (action === "download" || action === "conflict") downloads.push(plan);
+  }
+  let stagingDirectory;
+  try {
+    const stagedPaths = /* @__PURE__ */ new Map();
+    if (downloads.length > 0) {
+      stagingDirectory = mkdtempSync(join9(tmpdir(), "neo-pull-files-"));
+      const directory = stagingDirectory;
+      const client = args.client ?? NeoApiClient.forBaseUrl(args.workspace.config.apiBaseUrl);
+      await mapWithConcurrency(
+        downloads,
+        DOWNLOAD_CONCURRENCY,
+        async (plan, index) => {
+          const response = await download(
+            plan.data,
+            plan.fileId,
+            client,
+            args.workspace
+          );
+          if (response.sha256 !== plan.remoteDigest) {
+            throw new Error(
+              `Project file ${plan.fileId} content changed while pull was in progress (${plan.remoteDigest} -> ${response.sha256}). Pull again against a stable version head.`
+            );
+          }
+          const stagedPath = join9(directory, String(index));
+          writeFileSync8(stagedPath, response.bytes);
+          stagedPaths.set(plan.fileId, stagedPath);
+        }
+      );
+    }
+    for (const plan of plans.values()) {
+      const {
+        key,
+        fileId,
+        data,
+        previous,
+        path,
+        baseDigest,
+        remoteDigest,
+        action
+      } = plan;
+      const absolute = resolvePath(path);
+      const stagedPath = stagedPaths.get(fileId);
+      const remoteBytes = stagedPath === void 0 ? null : readFileSync11(stagedPath);
+      if (action === "download") {
+        if (remoteBytes === null) {
+          throw new Error(
+            `Project file ${fileId} download plan has no verified remote bytes.`
+          );
+        }
+        writeVerifiedBinaryDownloadV4(absolute, remoteBytes, remoteDigest);
+        downloaded += 1;
+        states.set(key, binaryState(path, remoteDigest, data));
+        continue;
+      }
+      if (action === "conflict") {
+        if (remoteBytes === null) {
+          throw new Error(
+            `Project file ${fileId} conflict plan has no verified remote bytes.`
+          );
+        }
+        const artifactPath = writeBinaryConflictArtifactV4(
+          args.workspace.root,
+          fileId,
+          fileName(data),
+          remoteBytes,
+          remoteDigest
+        );
+        const state = binaryState(path, baseDigest, data);
+        states.set(key, {
+          ...state,
+          conflict: {
+            action: "conflict",
+            remoteSha256: remoteDigest,
+            artifactPath
+          }
+        });
+        conflicts.push(path);
+        conflicted += 1;
+        continue;
+      }
+      if (action === "converged" || action === "unchanged") {
+        states.set(key, binaryState(path, remoteDigest, data));
+        removePreviousConflict(args.workspace.root, previous?.projectBinary);
+        continue;
+      }
+      states.set(key, binaryState(path, baseDigest, data));
+    }
+    for (const [key, previous] of Object.entries(args.previousRecords)) {
+      if (previous.recordKind !== "project-file") continue;
+      if (args.document.records.has(key)) continue;
+      const localStatus = localById.get(previous.recordId);
+      const path = localStatus?.path ?? previous.projectBinary?.path ?? canonicalProjectBinaryPathV42(previous.data);
+      const absolute = resolvePath(path);
+      const localDigest = existsSync8(absolute) ? sha256File(absolute) : null;
+      const baseDigest = previous.projectBinary?.sha256 ?? readSha256(previous.data) ?? null;
+      const action = planBinaryMergeV4({
+        baseDigest,
+        localDigest,
+        remoteDigest: null,
+        declarationPresent: localStatus !== void 0,
+        hadLocalBytes: previous.projectBinary !== void 0
+      });
+      if (action === "delete-modify") {
+        const data = isObjectRecord2(previous.data) ? previous.data : {};
+        states.set(key, {
+          ...binaryState(path, baseDigest, data),
+          conflict: {
+            action: "delete-modify",
+            remoteSha256: null
+          }
+        });
+        conflicts.push(path);
+        conflicted += 1;
+        continue;
+      }
+      rmSync5(absolute, { force: true });
+      removePreviousConflict(args.workspace.root, previous.projectBinary);
+    }
+    return { states, downloaded, conflicted, conflicts };
+  } finally {
+    if (stagingDirectory !== void 0)
+      rmSync5(stagingDirectory, { recursive: true, force: true });
+  }
+}
+async function download(data, fileId, client, workspace) {
+  const version = typeof data.storageETag === "string" ? `?v=${encodeURIComponent(data.storageETag)}` : "";
+  const path = `/api/projects/${workspace.config.projectId}/versions/${workspace.config.versionId}/files/${fileId}/content${version}`;
+  const response = await client.getBytes(path);
+  const computed = sha256Bytes(response.bytes);
+  const metadataDigest = requiredSha256(
+    data,
+    `project-file:${fileId} metadata`
+  );
+  const headerDigest = normalizeSha256V4(
+    response.contentSha256,
+    `download response for project file ${fileId}`
+  );
+  if (headerDigest !== null && metadataDigest !== headerDigest) {
+    throw new Error(
+      `Project file ${fileId} metadata SHA-256 ${metadataDigest} did not match authenticated content response ${headerDigest}.`
+    );
+  }
+  if (computed !== metadataDigest) {
+    throw new Error(
+      `Downloaded project file ${fileId} SHA-256 ${computed} did not match expected ${metadataDigest}.`
+    );
+  }
+  if (typeof data.byteLength === "number" && response.bytes.byteLength !== data.byteLength) {
+    throw new Error(
+      `Downloaded project file ${fileId} has ${response.bytes.byteLength} bytes; metadata requires ${data.byteLength}.`
+    );
+  }
+  if (typeof data.mimeType === "string" && response.contentType !== null && response.contentType !== data.mimeType) {
+    throw new Error(
+      `Downloaded project file ${fileId} content type ${response.contentType} did not match metadata ${data.mimeType}.`
+    );
+  }
+  return { bytes: response.bytes, sha256: computed };
+}
+function committedProjectBinaryStateV4(previous, data) {
+  return isObjectRecord2(data) ? binaryState(previous.path, readSha256(data), data) : previous;
+}
+function binaryState(path, sha256, data) {
+  return {
+    path,
+    sha256,
+    byteLength: typeof data.byteLength === "number" ? data.byteLength : 0,
+    mimeType: typeof data.mimeType === "string" ? data.mimeType : "application/octet-stream"
+  };
+}
+function readSha256(data) {
+  if (!isObjectRecord2(data)) return null;
+  return normalizeSha256V4(data.contentSha256, "project file metadata");
+}
+function requiredSha256(data, source) {
+  if (!isObjectRecord2(data)) {
+    throw new Error(`${source} must be an object.`);
+  }
+  const digest = normalizeSha256V4(data.contentSha256, source);
+  if (digest === null) {
+    throw new Error(`${source} is missing required contentSha256.`);
+  }
+  return digest;
+}
+function fileName(data) {
+  if (typeof data.name !== "string") {
+    throw new Error("Project file metadata has no filename.");
+  }
+  return data.name;
+}
+function removePreviousConflict(root, state) {
+  if (state?.conflict?.artifactPath === void 0) return;
+  rmSync5(join9(root, state.conflict.artifactPath), { force: true });
+}
+var DOWNLOAD_CONCURRENCY;
+var init_project_file_pull = __esm({
+  "src/project-source/project-file-pull.ts"() {
+    "use strict";
+    init_workspace_source_path();
+    init_concurrency();
+    init_http();
+    init_projection();
+    init_project_files();
+    DOWNLOAD_CONCURRENCY = 8;
+  }
+});
+
 // src/project-source/project-file-push.ts
-import { basename as basename2, join as join9 } from "node:path";
-import { readFileSync as readFileSync11 } from "node:fs";
+import { basename as basename2, join as join10 } from "node:path";
+import { readFileSync as readFileSync12 } from "node:fs";
 import { randomUUID as randomUUID4 } from "node:crypto";
 async function cleanupRejectedProjectFilePushesV4(args) {
   if (args.stagedUploadSessionId === null) return;
@@ -131297,8 +131489,8 @@ function prepareProjectFilePushesV4(args) {
         `Project file ${recordId} has upload bytes but its source change has no record data.`
       );
     }
-    const absolute = join9(args.workspace.root, binary.path);
-    const bytes = new Uint8Array(readFileSync11(absolute));
+    const absolute = join10(args.workspace.root, binary.path);
+    const bytes = new Uint8Array(readFileSync12(absolute));
     const digest = sha256Bytes(bytes);
     if (binary.localSha256 !== null && digest !== binary.localSha256) {
       throw new Error(
@@ -131914,8 +132106,8 @@ var init_project_version_validation = __esm({
 });
 
 // src/commands/push-body-diagnostics.ts
-import { existsSync as existsSync8, readFileSync as readFileSync12 } from "node:fs";
-import { join as join10 } from "node:path";
+import { existsSync as existsSync9, readFileSync as readFileSync13 } from "node:fs";
+import { join as join11 } from "node:path";
 function createNeoScriptBodySourceLocator(workspace, status) {
   const textByFile = /* @__PURE__ */ new Map();
   return {
@@ -131937,8 +132129,8 @@ function createNeoScriptBodySourceLocator(workspace, status) {
     textOf(file) {
       const cached = textByFile.get(file);
       if (cached !== void 0) return cached;
-      const path = join10(workspace.root, file);
-      const text = existsSync8(path) ? readFileSync12(path, "utf8") : null;
+      const path = join11(workspace.root, file);
+      const text = existsSync9(path) ? readFileSync13(path, "utf8") : null;
       textByFile.set(file, text);
       return text;
     }
@@ -132096,14 +132288,14 @@ __export(push_exports, {
 import { createHash as createHash10, randomUUID as randomUUID5 } from "node:crypto";
 import {
   mkdirSync as mkdirSync8,
-  writeFileSync as writeFileSync8,
-  rmSync as rmSync5,
-  existsSync as existsSync9,
-  readFileSync as readFileSync13,
+  writeFileSync as writeFileSync9,
+  rmSync as rmSync6,
+  existsSync as existsSync10,
+  readFileSync as readFileSync14,
   statSync
 } from "node:fs";
-import { join as join11, relative as relative6, sep as sep6 } from "node:path";
-function assignPendingIds(changes, authoredValueSeeds, reconstructed3, localInitializerMaterialization) {
+import { join as join12, relative as relative6, sep as sep6 } from "node:path";
+function assignPendingIds(changes, authoredValueSeeds, reconstructed3) {
   const assigned = /* @__PURE__ */ new Map();
   const assign = (pendingId2) => {
     const existing = assigned.get(pendingId2);
@@ -132178,9 +132370,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 +132479,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 +132495,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 +132513,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 +132529,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 +132556,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 +133114,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 +133153,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(
@@ -133080,7 +133261,7 @@ async function runPush(workspace, options, preparationOverride) {
     );
   }
   if (options.noVerify !== true) {
-    const preparedBuildDir = configuredHook === void 0 ? void 0 : join11(
+    const preparedBuildDir = configuredHook === void 0 ? void 0 : join12(
       workspace.root,
       ".neo",
       "test-build",
@@ -133096,8 +133277,8 @@ async function runPush(workspace, options, preparationOverride) {
       }
       const documentJson = JSON.stringify(candidate.document);
       mkdirSync8(preparedBuildDir, { recursive: true });
-      writeFileSync8(
-        join11(preparedBuildDir, "candidate.json"),
+      writeFileSync9(
+        join12(preparedBuildDir, "candidate.json"),
         `${JSON.stringify({
           version: 1,
           projectFingerprint: `sha256:${preparedLocal.source.sourceHash}`,
@@ -133119,7 +133300,7 @@ async function runPush(workspace, options, preparationOverride) {
       });
     } finally {
       if (preparedBuildDir !== void 0) {
-        rmSync5(preparedBuildDir, { recursive: true, force: true });
+        rmSync6(preparedBuildDir, { recursive: true, force: true });
       }
     }
   } else {
@@ -133250,41 +133431,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 +133486,7 @@ async function runPush(workspace, options, preparationOverride) {
         errorMessage: null
       });
       reporter.stop();
-      reportAdditionalServerChanges(
+      reportDerivedChanges(
         committedChangeCount,
         status.changes.length,
         options.json === true
@@ -133410,7 +133574,7 @@ async function runPush(workspace, options, preparationOverride) {
       errorMessage: null
     });
     reporter.stop();
-    reportAdditionalServerChanges(
+    reportDerivedChanges(
       completed.totalChangeCount,
       status.changes.length,
       options.json === true
@@ -133512,7 +133676,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 +133695,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 +133713,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 +133734,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 +133899,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 +134307,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 +134348,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).`
     )
   );
 }
@@ -134324,7 +134530,7 @@ function statusForPushResult(workspace, submitted) {
     const input = snapshot.inputs[index];
     if (input?.uri !== relative6(workspace.root, path).split(sep6).join("/"))
       return computeWorkspaceStatus2(workspace);
-    if (input.text !== readFileSync13(path, "utf8"))
+    if (input.text !== readFileSync14(path, "utf8"))
       return computeWorkspaceStatus2(workspace);
   }
   const binaries = inspectProjectBinaryStatusV4(
@@ -134493,13 +134699,14 @@ function foldChangedRecords(previous, changedRecords) {
         `Changed record "${key}" response is missing its snapshot content hash.`
       );
     }
+    const projectBinary = records2[key]?.projectBinary;
     records2[key] = {
       recordKind,
       recordId,
       contentHash: snapshot.contentHash,
       data: changed.data,
       file: records2[key]?.file,
-      projectBinary: records2[key]?.projectBinary
+      projectBinary: projectBinary && committedProjectBinaryStateV4(projectBinary, changed.data)
     };
   }
   return records2;
@@ -134530,8 +134737,8 @@ function authoredMemberFormsByFile(root, alternates) {
   for (const alternate of alternates) {
     let existing = contents.get(alternate.path);
     if (existing === void 0) {
-      const absolute = join11(root, alternate.path);
-      existing = existsSync9(absolute) ? readFileSync13(absolute, "utf8") : null;
+      const absolute = join12(root, alternate.path);
+      existing = existsSync10(absolute) ? readFileSync14(absolute, "utf8") : null;
       contents.set(alternate.path, existing);
     }
     if (existing === null || !existing.includes(alternate.block)) continue;
@@ -134640,7 +134847,7 @@ function rewriteFilesFromState(workspace, records2 = new Map(
   ];
   for (const path of previousPaths) {
     const absolute = resolveSourcePath(path);
-    if (!existsSync9(absolute) || emittedEntries.has(fileSystemEntryKey(absolute)))
+    if (!existsSync10(absolute) || emittedEntries.has(fileSystemEntryKey(absolute)))
       continue;
     output.set(normalizeWorkspaceSourcePath(path), null);
   }
@@ -134648,7 +134855,7 @@ function rewriteFilesFromState(workspace, records2 = new Map(
     const absolute = resolveSourcePath(path);
     return {
       path,
-      before: existsSync9(absolute) ? readFileSync13(absolute, "utf8") : null,
+      before: existsSync10(absolute) ? readFileSync14(absolute, "utf8") : null,
       after
     };
   });
@@ -134700,7 +134907,7 @@ function materializeAssignedSchemaIdsInAuthoredSource(workspace, replacements, p
   if (pendingIdsByUri.size === 0) return /* @__PURE__ */ new Map();
   const inputs = options.sourceSnapshot?.inputs ?? listProjectSourceFilesV4(workspace.root).map((absolutePath) => {
     const uri = relative6(workspace.root, absolutePath).split(sep6).join("/");
-    const text = readFileSync13(absolutePath, "utf8");
+    const text = readFileSync14(absolutePath, "utf8");
     const kind = neoProjectSourceKind(uri, text);
     if (kind === null || !isNeoProjectProductionSourceKind(kind)) {
       throw new Error(
@@ -135504,6 +135711,7 @@ var init_push = __esm({
     init_project_documents();
     init_project_document_cache();
     init_project_files();
+    init_project_file_pull();
     init_workspace_status();
     init_lower_support();
     init_init_conversion();
@@ -135514,7 +135722,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();
@@ -136262,13 +136469,13 @@ var init_source_record_comparison = __esm({
 
 // src/project-source/reset.ts
 import {
-  existsSync as existsSync10,
+  existsSync as existsSync11,
   mkdirSync as mkdirSync9,
-  readFileSync as readFileSync14,
-  rmSync as rmSync6,
-  writeFileSync as writeFileSync9
+  readFileSync as readFileSync15,
+  rmSync as rmSync7,
+  writeFileSync as writeFileSync10
 } from "node:fs";
-import { dirname as dirname8, join as join12, relative as relative7, sep as sep7 } from "node:path";
+import { dirname as dirname8, join as join13, relative as relative7, sep as sep7 } from "node:path";
 function prepareWorkspaceResetV4(workspace, document, options = {}) {
   const emissionRecords = options.regenerateSourceNames ? regenerateDialogueSourceNamesV4(document.records) : document.records;
   const layoutWorkspace = workspaceForSourceLayoutV4(workspace, document);
@@ -136298,21 +136505,21 @@ function resetWorkspaceToProjectSourcesV4(workspace, document, options = {}) {
   }
   for (const file of emitted.files) obsolete.delete(file.path);
   for (const path of obsolete) {
-    rmSync6(resolveSourcePath(path), { force: true });
+    rmSync7(resolveSourcePath(path), { force: true });
   }
   for (const file of LEGACY_ROOT_FILES) {
-    rmSync6(join12(workspace.root, file), { force: true });
+    rmSync7(join13(workspace.root, file), { force: true });
   }
   for (const privatePath of LEGACY_PRIVATE_PATHS) {
-    rmSync6(join12(workspace.root, privatePath), { recursive: true, force: true });
+    rmSync7(join13(workspace.root, privatePath), { recursive: true, force: true });
   }
   for (const file of emitted.files) {
     const absolute = resolveSourcePath(file.path);
     mkdirSync9(dirname8(absolute), { recursive: true });
-    if (existsSync10(absolute) && readFileSync14(absolute, "utf8") === file.content) {
+    if (existsSync11(absolute) && readFileSync15(absolute, "utf8") === file.content) {
       continue;
     }
-    writeFileSync9(absolute, file.content, "utf8");
+    writeFileSync10(absolute, file.content, "utf8");
   }
   writeProjectSourceAnalysisCacheV4(workspace.root, emitted.analysis);
   const records2 = {};
@@ -136353,7 +136560,7 @@ function trackedProductionSourcesBeforeReset(workspace, resolveSourcePath) {
       continue;
     }
     const absolute = resolveSourcePath(path);
-    if (existsSync10(absolute)) paths.add(path);
+    if (existsSync11(absolute)) paths.add(path);
   }
   return paths;
 }
@@ -136397,280 +136604,6 @@ var init_reset = __esm({
   }
 });
 
-// src/project-source/project-file-pull.ts
-import {
-  existsSync as existsSync11,
-  mkdtempSync,
-  readFileSync as readFileSync15,
-  rmSync as rmSync7,
-  writeFileSync as writeFileSync10
-} from "node:fs";
-import { tmpdir } from "node:os";
-import { join as join13 } from "node:path";
-async function pullProjectBinariesV4(args) {
-  const resolvePath = createWorkspaceSourcePathResolver(args.workspace.root);
-  const plans = /* @__PURE__ */ new Map();
-  const downloads = [];
-  const localById = new Map(
-    (args.localBinaries ?? []).map((binary) => [binary.fileId, binary])
-  );
-  const states = /* @__PURE__ */ new Map();
-  const conflicts = [];
-  let downloaded = 0;
-  let conflicted = 0;
-  for (const record6 of args.document.records.values()) {
-    if (record6.deleted || record6.recordKind !== "project-file") continue;
-    if (!isObjectRecord2(record6.data)) {
-      throw new Error(`project-file:${record6.recordId} must be an object.`);
-    }
-    if (record6.data.status !== "uploaded") continue;
-    const existing = plans.get(record6.recordId);
-    if (existing !== void 0) {
-      if (existing.contentHash !== record6.contentHash)
-        throw new Error(
-          `Project file ${record6.recordId} appears with conflicting content hashes in the pulled document.`
-        );
-      continue;
-    }
-    const key = `project-file:${record6.recordId}`;
-    const previous = args.previousRecords[key];
-    const localStatus = localById.get(record6.recordId);
-    const declarationPresent = args.destructive === true || args.localBinaries === void 0 || previous === void 0 || localStatus !== void 0;
-    const path = localStatus?.path ?? previous?.projectBinary?.path ?? canonicalProjectBinaryPathV42(record6.data);
-    const absolute = resolvePath(path);
-    const localDigest = existsSync11(absolute) ? sha256File(absolute) : null;
-    const baseDigest = previous?.projectBinary?.sha256 ?? readSha256(previous?.data) ?? null;
-    const remoteDigest = requiredSha256(
-      record6.data,
-      `project-file:${record6.recordId} metadata`
-    );
-    let action = planBinaryMergeV4({
-      baseDigest,
-      localDigest,
-      remoteDigest,
-      declarationPresent,
-      hadLocalBytes: previous?.projectBinary !== void 0
-    });
-    if (args.destructive === true) {
-      action = localDigest === remoteDigest ? "unchanged" : "download";
-    }
-    const plan = {
-      key,
-      fileId: record6.recordId,
-      contentHash: record6.contentHash,
-      data: record6.data,
-      previous,
-      path,
-      baseDigest,
-      remoteDigest,
-      action
-    };
-    plans.set(record6.recordId, plan);
-    if (action === "download" || action === "conflict") downloads.push(plan);
-  }
-  let stagingDirectory;
-  try {
-    const stagedPaths = /* @__PURE__ */ new Map();
-    if (downloads.length > 0) {
-      stagingDirectory = mkdtempSync(join13(tmpdir(), "neo-pull-files-"));
-      const directory = stagingDirectory;
-      const client = args.client ?? NeoApiClient.forBaseUrl(args.workspace.config.apiBaseUrl);
-      await mapWithConcurrency(
-        downloads,
-        DOWNLOAD_CONCURRENCY,
-        async (plan, index) => {
-          const response = await download(
-            plan.data,
-            plan.fileId,
-            client,
-            args.workspace
-          );
-          if (response.sha256 !== plan.remoteDigest) {
-            throw new Error(
-              `Project file ${plan.fileId} content changed while pull was in progress (${plan.remoteDigest} -> ${response.sha256}). Pull again against a stable version head.`
-            );
-          }
-          const stagedPath = join13(directory, String(index));
-          writeFileSync10(stagedPath, response.bytes);
-          stagedPaths.set(plan.fileId, stagedPath);
-        }
-      );
-    }
-    for (const plan of plans.values()) {
-      const {
-        key,
-        fileId,
-        data,
-        previous,
-        path,
-        baseDigest,
-        remoteDigest,
-        action
-      } = plan;
-      const absolute = resolvePath(path);
-      const stagedPath = stagedPaths.get(fileId);
-      const remoteBytes = stagedPath === void 0 ? null : readFileSync15(stagedPath);
-      if (action === "download") {
-        if (remoteBytes === null) {
-          throw new Error(
-            `Project file ${fileId} download plan has no verified remote bytes.`
-          );
-        }
-        writeVerifiedBinaryDownloadV4(absolute, remoteBytes, remoteDigest);
-        downloaded += 1;
-        states.set(key, binaryState(path, remoteDigest, data));
-        continue;
-      }
-      if (action === "conflict") {
-        if (remoteBytes === null) {
-          throw new Error(
-            `Project file ${fileId} conflict plan has no verified remote bytes.`
-          );
-        }
-        const artifactPath = writeBinaryConflictArtifactV4(
-          args.workspace.root,
-          fileId,
-          fileName(data),
-          remoteBytes,
-          remoteDigest
-        );
-        const state = binaryState(path, baseDigest, data);
-        states.set(key, {
-          ...state,
-          conflict: {
-            action: "conflict",
-            remoteSha256: remoteDigest,
-            artifactPath
-          }
-        });
-        conflicts.push(path);
-        conflicted += 1;
-        continue;
-      }
-      if (action === "converged" || action === "unchanged") {
-        states.set(key, binaryState(path, remoteDigest, data));
-        removePreviousConflict(args.workspace.root, previous?.projectBinary);
-        continue;
-      }
-      states.set(key, binaryState(path, baseDigest, data));
-    }
-    for (const [key, previous] of Object.entries(args.previousRecords)) {
-      if (previous.recordKind !== "project-file") continue;
-      if (args.document.records.has(key)) continue;
-      const localStatus = localById.get(previous.recordId);
-      const path = localStatus?.path ?? previous.projectBinary?.path ?? canonicalProjectBinaryPathV42(previous.data);
-      const absolute = resolvePath(path);
-      const localDigest = existsSync11(absolute) ? sha256File(absolute) : null;
-      const baseDigest = previous.projectBinary?.sha256 ?? readSha256(previous.data) ?? null;
-      const action = planBinaryMergeV4({
-        baseDigest,
-        localDigest,
-        remoteDigest: null,
-        declarationPresent: localStatus !== void 0,
-        hadLocalBytes: previous.projectBinary !== void 0
-      });
-      if (action === "delete-modify") {
-        const data = isObjectRecord2(previous.data) ? previous.data : {};
-        states.set(key, {
-          ...binaryState(path, baseDigest, data),
-          conflict: {
-            action: "delete-modify",
-            remoteSha256: null
-          }
-        });
-        conflicts.push(path);
-        conflicted += 1;
-        continue;
-      }
-      rmSync7(absolute, { force: true });
-      removePreviousConflict(args.workspace.root, previous.projectBinary);
-    }
-    return { states, downloaded, conflicted, conflicts };
-  } finally {
-    if (stagingDirectory !== void 0)
-      rmSync7(stagingDirectory, { recursive: true, force: true });
-  }
-}
-async function download(data, fileId, client, workspace) {
-  const version = typeof data.storageETag === "string" ? `?v=${encodeURIComponent(data.storageETag)}` : "";
-  const path = `/api/projects/${workspace.config.projectId}/versions/${workspace.config.versionId}/files/${fileId}/content${version}`;
-  const response = await client.getBytes(path);
-  const computed = sha256Bytes(response.bytes);
-  const metadataDigest = requiredSha256(
-    data,
-    `project-file:${fileId} metadata`
-  );
-  const headerDigest = normalizeSha256V4(
-    response.contentSha256,
-    `download response for project file ${fileId}`
-  );
-  if (headerDigest !== null && metadataDigest !== headerDigest) {
-    throw new Error(
-      `Project file ${fileId} metadata SHA-256 ${metadataDigest} did not match authenticated content response ${headerDigest}.`
-    );
-  }
-  if (computed !== metadataDigest) {
-    throw new Error(
-      `Downloaded project file ${fileId} SHA-256 ${computed} did not match expected ${metadataDigest}.`
-    );
-  }
-  if (typeof data.byteLength === "number" && response.bytes.byteLength !== data.byteLength) {
-    throw new Error(
-      `Downloaded project file ${fileId} has ${response.bytes.byteLength} bytes; metadata requires ${data.byteLength}.`
-    );
-  }
-  if (typeof data.mimeType === "string" && response.contentType !== null && response.contentType !== data.mimeType) {
-    throw new Error(
-      `Downloaded project file ${fileId} content type ${response.contentType} did not match metadata ${data.mimeType}.`
-    );
-  }
-  return { bytes: response.bytes, sha256: computed };
-}
-function binaryState(path, sha256, data) {
-  return {
-    path,
-    sha256,
-    byteLength: typeof data.byteLength === "number" ? data.byteLength : 0,
-    mimeType: typeof data.mimeType === "string" ? data.mimeType : "application/octet-stream"
-  };
-}
-function readSha256(data) {
-  if (!isObjectRecord2(data)) return null;
-  return normalizeSha256V4(data.contentSha256, "project file metadata");
-}
-function requiredSha256(data, source) {
-  if (!isObjectRecord2(data)) {
-    throw new Error(`${source} must be an object.`);
-  }
-  const digest = normalizeSha256V4(data.contentSha256, source);
-  if (digest === null) {
-    throw new Error(`${source} is missing required contentSha256.`);
-  }
-  return digest;
-}
-function fileName(data) {
-  if (typeof data.name !== "string") {
-    throw new Error("Project file metadata has no filename.");
-  }
-  return data.name;
-}
-function removePreviousConflict(root, state) {
-  if (state?.conflict?.artifactPath === void 0) return;
-  rmSync7(join13(root, state.conflict.artifactPath), { force: true });
-}
-var DOWNLOAD_CONCURRENCY;
-var init_project_file_pull = __esm({
-  "src/project-source/project-file-pull.ts"() {
-    "use strict";
-    init_workspace_source_path();
-    init_concurrency();
-    init_http();
-    init_projection();
-    init_project_files();
-    DOWNLOAD_CONCURRENCY = 8;
-  }
-});
-
 // src/project-source/static-value-seed-records.ts
 function staticValueSeedEmitRecords(status, present, projectId, mainLocale) {
   const records2 = /* @__PURE__ */ new Map();
@@ -140824,7 +140757,7 @@ var init_registry2 = __esm({
   "schema-contract/registry.mjs"() {
     "use strict";
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
-      cliVersion: "0.58.3",
+      cliVersion: "0.59.1",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -148539,7 +148472,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 +148578,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.1");
     return;
   }
   if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {