@neocompose/cli 0.58.2 → 0.59.0

package/dist/neo.mjs

@@ -6424,10 +6424,10 @@ var init_strict_resolver = __esm({
         this.project = projectIndex ?? createProjectIndex(context.project);
         this.source = syntax?.source.text;
         this.sourceTokens = syntax?.roots;
-        const unknown2 = { kind: "primitive", name: "unknown" };
+        const unknown = { kind: "primitive", name: "unknown" };
         this.thisVariable = variable(
           "__this__",
-          context.thisClass ?? unknown2,
+          context.thisClass ?? unknown,
           void 0,
           this.project
         );
@@ -6436,7 +6436,7 @@ var init_strict_resolver = __esm({
         );
         this.rootVariable = variable(
           "__root__",
-          rootSymbol?.type ?? unknown2,
+          rootSymbol?.type ?? unknown,
           void 0,
           this.project
         );
@@ -34352,13 +34352,13 @@ function spellingQuickFixes(document, diagnostic) {
 }
 function diagnosticMisspelling(diagnostic) {
   if (/to initialize\b/.test(diagnostic.message)) return null;
-  const unknown2 = /Unknown (identifier|function) '([^']+)'/.exec(
+  const unknown = /Unknown (identifier|function) '([^']+)'/.exec(
     diagnostic.message
   );
-  if (unknown2?.[2]) {
+  if (unknown?.[2]) {
     return {
-      name: unknown2[2],
-      kind: unknown2[1] === "function" ? "callable" : "value"
+      name: unknown[2],
+      kind: unknown[1] === "function" ? "callable" : "value"
     };
   }
   const member = /has no (?:static )?(?:callable )?member '([^']+)'/.exec(
@@ -35759,10 +35759,10 @@ function optionalTestConfig(value) {
     "maxWorkers",
     "forbidOnly"
   ]);
-  const unknown2 = Object.keys(config).find((key) => !allowed.has(key));
-  if (unknown2 !== void 0) {
+  const unknown = Object.keys(config).find((key) => !allowed.has(key));
+  if (unknown !== void 0) {
     throw new Error(
-      `"${NEO_CONFIG_FILE}" field "test.${unknown2}" is not recognized.`
+      `"${NEO_CONFIG_FILE}" field "test.${unknown}" is not recognized.`
     );
   }
   const stringArray2 = (field) => {
@@ -41696,6 +41696,50 @@ var init_record_adapters = __esm({
   }
 });
 
+// ../packages/manifest/src/value-graph.ts
+function encodeStoredValueNode(node) {
+  if (node.nodeType === "initializer") return { init: { code: node.code } };
+  return {
+    value: node.value,
+    classId: node.classId,
+    ...node.constructorArgs === void 0 ? {} : { constructorArgs: node.constructorArgs },
+    ...node.instanceConstructorId === void 0 ? {} : { instanceConstructorId: node.instanceConstructorId },
+    ...node.instanceVariantId === void 0 ? {} : { instanceVariantId: node.instanceVariantId },
+    ...node.instanceVariantRowValueId === void 0 ? {} : { instanceVariantRowValueId: node.instanceVariantRowValueId }
+  };
+}
+function encodeStoredValueRowFields(row) {
+  return {
+    ...encodeStoredValueNode(row),
+    ...row.containerId === void 0 ? {} : { containerId: row.containerId },
+    ...row.genericBindings === void 0 ? {} : { genericBindings: row.genericBindings },
+    ...row.sourceValueId === void 0 ? {} : { sourceValueId: row.sourceValueId }
+  };
+}
+function canonicalInstanceProvenanceViolation(value) {
+  const constructorArgs = "constructorArgs" in value ? value.constructorArgs : void 0;
+  const constructorId = "instanceConstructorId" in value ? value.instanceConstructorId : void 0;
+  const variantId = "instanceVariantId" in value ? value.instanceVariantId : void 0;
+  if (constructorArgs !== void 0 && constructorId === void 0 && typeof variantId !== "string") {
+    return "constructor-args-without-stamp";
+  }
+  if (typeof constructorId === "string" && constructorArgs === void 0) {
+    return "named-constructor-without-args";
+  }
+  if (constructorId === null && constructorArgs !== void 0 && typeof constructorArgs === "object" && constructorArgs !== null && !Array.isArray(constructorArgs) && Object.keys(constructorArgs).length > 0) {
+    return "implicit-constructor-with-args";
+  }
+  if ("instanceVariantRowValueId" in value && typeof value.instanceVariantRowValueId === "string" && typeof variantId !== "string") {
+    return "variant-row-without-variant";
+  }
+  return null;
+}
+var init_value_graph = __esm({
+  "../packages/manifest/src/value-graph.ts"() {
+    "use strict";
+  }
+});
+
 // node_modules/valibot/dist/index.mjs
 // @__NO_SIDE_EFFECTS__
 function getGlobalConfig(config$1) {
@@ -42408,23 +42452,6 @@ function union(options, message$1) {
   };
 }
 // @__NO_SIDE_EFFECTS__
-function unknown() {
-  return {
-    kind: "schema",
-    type: "unknown",
-    reference: unknown,
-    expects: "unknown",
-    async: false,
-    get "~standard"() {
-      return /* @__PURE__ */ _getStandardProps(this);
-    },
-    "~run"(dataset) {
-      dataset.typed = true;
-      return dataset;
-    }
-  };
-}
-// @__NO_SIDE_EFFECTS__
 function variant(key, options, message$1) {
   return {
     kind: "schema",
@@ -42539,108 +42566,6 @@ var init_dist = __esm({
   }
 });
 
-// ../packages/manifest/src/value-graph.ts
-function encodeStoredValueNode(node) {
-  if (node.nodeType === "initializer") return { init: { code: node.code } };
-  return {
-    value: node.value,
-    classId: node.classId,
-    ...node.constructorArgs === void 0 ? {} : { constructorArgs: node.constructorArgs },
-    ...node.instanceConstructorId === void 0 ? {} : { instanceConstructorId: node.instanceConstructorId },
-    ...node.instanceVariantId === void 0 ? {} : { instanceVariantId: node.instanceVariantId },
-    ...node.instanceVariantRowValueId === void 0 ? {} : { instanceVariantRowValueId: node.instanceVariantRowValueId }
-  };
-}
-function encodeStoredValueRowFields(row) {
-  return {
-    ...encodeStoredValueNode(row),
-    ...row.containerId === void 0 ? {} : { containerId: row.containerId },
-    ...row.genericBindings === void 0 ? {} : { genericBindings: row.genericBindings },
-    ...row.sourceValueId === void 0 ? {} : { sourceValueId: row.sourceValueId }
-  };
-}
-function canonicalInstanceProvenanceViolation(value) {
-  const constructorArgs = "constructorArgs" in value ? value.constructorArgs : void 0;
-  const constructorId = "instanceConstructorId" in value ? value.instanceConstructorId : void 0;
-  const variantId = "instanceVariantId" in value ? value.instanceVariantId : void 0;
-  if (constructorArgs !== void 0 && constructorId === void 0 && typeof variantId !== "string") {
-    return "constructor-args-without-stamp";
-  }
-  if (typeof constructorId === "string" && constructorArgs === void 0) {
-    return "named-constructor-without-args";
-  }
-  if (constructorId === null && constructorArgs !== void 0 && typeof constructorArgs === "object" && constructorArgs !== null && !Array.isArray(constructorArgs) && Object.keys(constructorArgs).length > 0) {
-    return "implicit-constructor-with-args";
-  }
-  if ("instanceVariantRowValueId" in value && typeof value.instanceVariantRowValueId === "string" && typeof variantId !== "string") {
-    return "variant-row-without-variant";
-  }
-  return null;
-}
-var nonEmptyString, nullableId, optionalNullableId, stringMap, unknownMap, instanceProvenanceEntries, literalValueNodeEntries, initializerValueNodeEntries, literalValueNodeSchema, initializerValueNodeSchema, valueRowEntries, AuthoredValueRowSchema, valueSeedEntries, AuthoredValueSeedSchema, BindingMemberSchema, LocalizedTextSchema;
-var init_value_graph = __esm({
-  "../packages/manifest/src/value-graph.ts"() {
-    "use strict";
-    init_dist();
-    nonEmptyString = pipe(string3(), nonEmpty());
-    nullableId = nullable(nonEmptyString);
-    optionalNullableId = optional(nullableId);
-    stringMap = record3(string3(), nonEmptyString);
-    unknownMap = record3(string3(), unknown());
-    instanceProvenanceEntries = {
-      constructorArgs: optional(unknownMap),
-      instanceConstructorId: optionalNullableId,
-      instanceVariantId: optionalNullableId,
-      instanceVariantRowValueId: optionalNullableId
-    };
-    literalValueNodeEntries = {
-      nodeType: literal2("literal"),
-      value: unknown(),
-      classId: nullable(string3()),
-      ...instanceProvenanceEntries
-    };
-    initializerValueNodeEntries = {
-      nodeType: literal2("initializer"),
-      code: nonEmptyString
-    };
-    literalValueNodeSchema = strictObject(literalValueNodeEntries);
-    initializerValueNodeSchema = strictObject(
-      initializerValueNodeEntries
-    );
-    valueRowEntries = {
-      id: nonEmptyString,
-      memberId: nonEmptyString,
-      containerId: optional(string3()),
-      genericBindings: optional(stringMap),
-      sourceValueId: optional(nonEmptyString)
-    };
-    AuthoredValueRowSchema = variant("nodeType", [
-      strictObject({ ...valueRowEntries, ...literalValueNodeEntries }),
-      strictObject({ ...valueRowEntries, ...initializerValueNodeEntries })
-    ]);
-    valueSeedEntries = {
-      memberId: nonEmptyString,
-      valueId: optional(nonEmptyString),
-      values: optional(unknown()),
-      bindingMembers: optional(unknown()),
-      localizedTexts: optional(unknown())
-    };
-    AuthoredValueSeedSchema = variant("nodeType", [
-      strictObject({ ...valueSeedEntries, ...literalValueNodeEntries }),
-      strictObject({ ...valueSeedEntries, ...initializerValueNodeEntries })
-    ]);
-    BindingMemberSchema = strictObject({
-      id: nonEmptyString,
-      classId: nonEmptyString
-    });
-    LocalizedTextSchema = strictObject({
-      id: nonEmptyString,
-      valueId: nonEmptyString,
-      value: string3()
-    });
-  }
-});
-
 // ../packages/manifest/src/schema-member.ts
 function jsonValueIssue(value, depth, path) {
   if (depth > 64) {
@@ -42728,34 +42653,34 @@ function schemaTypeOptionsAtDepth(depth) {
       nullable: boolean2()
     }),
     nullableTypeSchema("class", {
-      classId: nonEmptyString2,
-      classArguments: record3(nonEmptyString2, schemaTypeAtDepth(depth + 1))
+      classId: nonEmptyString,
+      classArguments: record3(nonEmptyString, schemaTypeAtDepth(depth + 1))
     }),
     nullableTypeSchema("interface", {
-      interfaceId: nonEmptyString2
+      interfaceId: nonEmptyString
     }),
     nullableTypeSchema("generic", {
-      ownerClassId: nonEmptyString2,
-      genericParamId: nonEmptyString2
+      ownerClassId: nonEmptyString,
+      genericParamId: nonEmptyString
     }),
     nullableTypeSchema("enum", {
-      enumId: nonEmptyString2
+      enumId: nonEmptyString
     }),
     nullableTypeSchema("list", {
       entryType: schemaTypeAtDepth(depth + 1),
-      listMemberId: nullableId2,
+      listMemberId: nullableId,
       readOnly: boolean2()
     }),
     nullableTypeSchema("dictionary", {
       entryType: schemaTypeAtDepth(depth + 1),
-      keyEnumId: nullableId2,
+      keyEnumId: nullableId,
       readOnly: boolean2()
     }),
     pipe(
       nullableTypeSchema("lookup", {
         entryType: schemaTypeAtDepth(depth + 1),
-        collectionMemberId: exactOptional(nonEmptyString2),
-        collectionValueId: exactOptional(nullableId2)
+        collectionMemberId: exactOptional(nonEmptyString),
+        collectionValueId: exactOptional(nullableId)
       }),
       check(
         (type) => type.collectionValueId == null || type.collectionMemberId !== void 0,
@@ -42968,14 +42893,14 @@ function assertMemberInvariants(member, path) {
       fail2("script", "is required for a concrete scripted member.");
   }
 }
-var nonEmptyString2, nullableString2, nullableId2, finiteNumber, nullableNumber, nullableInteger, jsonValueSchema, schemaSourcePositionSchema, schemaSourceSpanSchema, schemaSourceSymbolKinds, schemaSourceIdentitySchema, memberSourceIdentitySchema, systemProtectionKindSchema, worldSystemClassKindSchema, schemaSystemMetadataSchema, schemaGenericBindingSchema, schemaGenericBindingRecordSchema, genericConstraintSchema, schemaGenericParameterSchema, primitiveTypeKinds, schemaTypeCache, returnTypeCache, schemaTypeSchema, schemaFunctionReturnTypeSchema, schemaParameterDefaultSchema, schemaFunctionArgumentSchema, memberOwnerSchema, schemaDefaultValueSchema, propertyScriptSchema, functionScriptSchema, commonMemberEntries, schemaMemberCommonSchema, simpleMemberSchemas, dictionaryKeySchema, schemaListIndexSchema, schemaListColumnSchema, callableEntries, schemaMemberSchema, SchemaMemberContractError;
+var nonEmptyString, nullableString2, nullableId, finiteNumber, nullableNumber, nullableInteger, jsonValueSchema, schemaSourcePositionSchema, schemaSourceSpanSchema, schemaSourceSymbolKinds, schemaSourceIdentitySchema, memberSourceIdentitySchema, systemProtectionKindSchema, worldSystemClassKindSchema, schemaSystemMetadataSchema, schemaGenericBindingSchema, schemaGenericBindingRecordSchema, genericConstraintSchema, schemaGenericParameterSchema, primitiveTypeKinds, schemaTypeCache, returnTypeCache, schemaTypeSchema, schemaFunctionReturnTypeSchema, schemaParameterDefaultSchema, schemaFunctionArgumentSchema, memberOwnerSchema, schemaDefaultValueSchema, propertyScriptSchema, functionScriptSchema, commonMemberEntries, schemaMemberCommonSchema, simpleMemberSchemas, dictionaryKeySchema, schemaListIndexSchema, schemaListColumnSchema, callableEntries, schemaMemberSchema, SchemaMemberContractError;
 var init_schema_member = __esm({
   "../packages/manifest/src/schema-member.ts"() {
     "use strict";
     init_dist();
-    nonEmptyString2 = pipe(string3(), nonEmpty());
+    nonEmptyString = pipe(string3(), nonEmpty());
     nullableString2 = nullable(string3());
-    nullableId2 = nullable(nonEmptyString2);
+    nullableId = nullable(nonEmptyString);
     finiteNumber = pipe(number(), finite());
     nullableNumber = nullable(finiteNumber);
     nullableInteger = nullable(
@@ -42994,7 +42919,7 @@ var init_schema_member = __esm({
     });
     schemaSourceSpanSchema = pipe(
       strictObject({
-        path: nonEmptyString2,
+        path: nonEmptyString,
         start: schemaSourcePositionSchema,
         end: schemaSourcePositionSchema
       }),
@@ -43041,13 +42966,13 @@ var init_schema_member = __esm({
       "variantFolder"
     ];
     schemaSourceIdentitySchema = strictObject({
-      symbolId: nonEmptyString2,
+      symbolId: nonEmptyString,
       kind: picklist(schemaSourceSymbolKinds),
       span: schemaSourceSpanSchema,
       selectionSpan: schemaSourceSpanSchema
     });
     memberSourceIdentitySchema = strictObject({
-      symbolId: nonEmptyString2,
+      symbolId: nonEmptyString,
       kind: literal2("member"),
       span: schemaSourceSpanSchema,
       selectionSpan: schemaSourceSpanSchema
@@ -43102,25 +43027,25 @@ var init_schema_member = __esm({
     schemaGenericBindingSchema = variant("kind", [
       strictObject({
         kind: literal2("generic"),
-        genericParamId: nonEmptyString2
+        genericParamId: nonEmptyString
       }),
-      strictObject({ kind: literal2("member"), memberId: nonEmptyString2 })
+      strictObject({ kind: literal2("member"), memberId: nonEmptyString })
     ]);
     schemaGenericBindingRecordSchema = record3(
-      nonEmptyString2,
+      nonEmptyString,
       schemaGenericBindingSchema
     );
     genericConstraintSchema = variant("kind", [
       strictObject({
         kind: literal2("class"),
-        classId: nonEmptyString2,
+        classId: nonEmptyString,
         classArguments: optional(nullable(schemaGenericBindingRecordSchema))
       }),
-      strictObject({ kind: literal2("enum"), enumId: nonEmptyString2 })
+      strictObject({ kind: literal2("enum"), enumId: nonEmptyString })
     ]);
     schemaGenericParameterSchema = strictObject({
-      id: nonEmptyString2,
-      name: nonEmptyString2,
+      id: nonEmptyString,
+      name: nonEmptyString,
       constraint: nullable(genericConstraintSchema),
       source: schemaSourceSpanSchema,
       selectionSpan: schemaSourceSpanSchema
@@ -43150,7 +43075,7 @@ var init_schema_member = __esm({
       source: schemaSourceSpanSchema
     });
     schemaFunctionArgumentSchema = strictObject({
-      name: nonEmptyString2,
+      name: nonEmptyString,
       type: schemaTypeSchema,
       default: nullable(schemaParameterDefaultSchema),
       source: schemaSourceSpanSchema,
@@ -43159,41 +43084,41 @@ var init_schema_member = __esm({
     memberOwnerSchema = variant("kind", [
       strictObject({
         kind: literal2("classMember"),
-        classId: nonEmptyString2,
-        schemaKey: nonEmptyString2
+        classId: nonEmptyString,
+        schemaKey: nonEmptyString
       }),
       strictObject({
         kind: literal2("sharedClassMember"),
         members: pipe(
           array2(
-            strictObject({ classId: nonEmptyString2, schemaKey: nonEmptyString2 })
+            strictObject({ classId: nonEmptyString, schemaKey: nonEmptyString })
           ),
           minLength(2, "Must contain at least two shared declarations.")
         )
       }),
       strictObject({
         kind: literal2("collectionEntry"),
-        parentMemberId: nonEmptyString2
+        parentMemberId: nonEmptyString
       }),
       strictObject({
         kind: literal2("sharedCollectionEntry"),
         parentMemberIds: pipe(
-          array2(nonEmptyString2),
+          array2(nonEmptyString),
           minLength(2, "Must contain at least two shared collections.")
         )
       }),
       strictObject({
         kind: literal2("genericArgument"),
-        parentRecordId: nonEmptyString2,
-        genericParamId: nonEmptyString2
+        parentRecordId: nonEmptyString,
+        genericParamId: nonEmptyString
       }),
       strictObject({
         kind: literal2("sharedGenericArgument"),
         bindings: pipe(
           array2(
             strictObject({
-              parentRecordId: nonEmptyString2,
-              genericParamId: nonEmptyString2
+              parentRecordId: nonEmptyString,
+              genericParamId: nonEmptyString
             })
           ),
           minLength(2, "Must contain at least two shared bindings.")
@@ -43202,17 +43127,17 @@ var init_schema_member = __esm({
       strictObject({ kind: literal2("loose") })
     ]);
     schemaDefaultValueSchema = union([
-      strictObject({ serverValueId: nonEmptyString2 }),
-      strictObject({ init: strictObject({ code: nonEmptyString2 }) }),
-      strictObject({ value: jsonValueSchema, classId: nullableId2 })
+      strictObject({ serverValueId: nonEmptyString }),
+      strictObject({ init: strictObject({ code: nonEmptyString }) }),
+      strictObject({ value: jsonValueSchema, classId: nullableId })
     ]);
     propertyScriptSchema = pipe(
       strictObject({
         kind: literal2("property"),
-        path: nonEmptyString2,
+        path: nonEmptyString,
         sourceText: string3(),
         source: schemaSourceSpanSchema,
-        getterSource: nonEmptyString2,
+        getterSource: nonEmptyString,
         setterSource: nullableString2
       }),
       forward(
@@ -43226,7 +43151,7 @@ var init_schema_member = __esm({
     functionScriptSchema = pipe(
       strictObject({
         kind: literal2("function"),
-        path: nonEmptyString2,
+        path: nonEmptyString,
         sourceText: string3(),
         source: schemaSourceSpanSchema
       }),
@@ -43239,10 +43164,10 @@ var init_schema_member = __esm({
       )
     );
     commonMemberEntries = {
-      id: nonEmptyString2,
+      id: nonEmptyString,
       source: memberSourceIdentitySchema,
       owner: memberOwnerSchema,
-      name: nonEmptyString2,
+      name: nonEmptyString,
       docsText: optional(string3()),
       isReadOnly: boolean2(),
       accessModifier: picklist(["public", "protected", "private"]),
@@ -43257,11 +43182,11 @@ var init_schema_member = __esm({
       ]),
       required: boolean2(),
       defaultValue: nullable(schemaDefaultValueSchema),
-      overrideOf: nullableId2,
+      overrideOf: nullableId,
       system: nullable(schemaSystemMetadataSchema),
       storage: nullable(picklist(["immutable", "save", "session", "writable"])),
       distribution: nullable(picklist(["sparse", "packed"])),
-      storageKey: nullableId2
+      storageKey: nullableId
     };
     schemaMemberCommonSchema = strictObject(commonMemberEntries);
     simpleMemberSchemas = [
@@ -43276,14 +43201,14 @@ var init_schema_member = __esm({
     ];
     dictionaryKeySchema = variant("kind", [
       strictObject({ kind: literal2("string") }),
-      strictObject({ kind: literal2("enum"), enumId: nonEmptyString2 })
+      strictObject({ kind: literal2("enum"), enumId: nonEmptyString })
     ]);
     schemaListIndexSchema = strictObject({
-      schemaKey: nonEmptyString2,
+      schemaKey: nonEmptyString,
       unique: boolean2()
     });
     schemaListColumnSchema = strictObject({
-      memberKey: nonEmptyString2,
+      memberKey: nonEmptyString,
       width: nullableNumber,
       hidden: boolean2(),
       frozen: boolean2(),
@@ -43314,33 +43239,33 @@ var init_schema_member = __esm({
         decimalPoints: nullableInteger
       }),
       memberSchema("dictionary", {
-        entryMemberId: nonEmptyString2,
+        entryMemberId: nonEmptyString,
         key: dictionaryKeySchema
       }),
       memberSchema("list", {
-        entryMemberId: nonEmptyString2,
+        entryMemberId: nonEmptyString,
         listKind: picklist(["ordered", "unordered"]),
         indexes: array2(schemaListIndexSchema),
         columns: array2(schemaListColumnSchema)
       }),
       memberSchema("class", {
-        classId: nonEmptyString2,
+        classId: nonEmptyString,
         partial: optional(boolean2()),
-        schemaKeyOrder: nullable(array2(nonEmptyString2)),
+        schemaKeyOrder: nullable(array2(nonEmptyString)),
         classArguments: schemaGenericBindingRecordSchema
       }),
       memberSchema("enum", {
-        enumId: nonEmptyString2,
+        enumId: nonEmptyString,
         multiselect: boolean2()
       }),
       memberSchema("lookup", {
-        collectionMemberId: nonEmptyString2,
-        collectionValueId: nullableId2,
+        collectionMemberId: nonEmptyString,
+        collectionValueId: nullableId,
         multiselect: boolean2(),
         declaredType: nullable(schemaTypeSchema)
       }),
       memberSchema("dialogueLookup", {
-        dialogueGroupId: nullableId2,
+        dialogueGroupId: nullableId,
         multiselect: boolean2()
       }),
       memberSchema("computed", {
@@ -43348,10 +43273,10 @@ var init_schema_member = __esm({
         script: nullable(propertyScriptSchema)
       }),
       memberSchema("sprite", {
-        templateId: nullableId2
+        templateId: nullableId
       }),
       memberSchema("audio", {
-        templateId: nullableId2
+        templateId: nullableId
       }),
       memberSchema("function", {
         ...callableEntries,
@@ -43382,7 +43307,7 @@ var init_schema_member = __esm({
         valueType: nullable(schemaTypeSchema)
       }),
       memberSchema("generic", {
-        genericParamId: nonEmptyString2,
+        genericParamId: nonEmptyString,
         partial: optional(boolean2())
       })
     ]);
@@ -43441,7 +43366,7 @@ function assertProjectSchemaManifest(value) {
     "localizationStatuses",
     "internalRecordRelations"
   ]);
-  nonEmptyString3(manifest.namespace, "$.namespace");
+  nonEmptyString2(manifest.namespace, "$.namespace");
   arrayOf(manifest.classes, "$.classes", assertNeoSchemaClass);
   arrayOf(manifest.constructors, "$.constructors", assertConstructor2);
   arrayOf(manifest.variants, "$.variants", assertVariant);
@@ -43515,7 +43440,7 @@ function assertConstructorInvariants(manifest) {
     const requiredConstructorId2 = schemaClass2.requiredConstructorId;
     if (requiredConstructorId2 === void 0) return;
     const path = `$.classes[${index}].requiredConstructorId`;
-    nonEmptyString3(requiredConstructorId2, path);
+    nonEmptyString2(requiredConstructorId2, path);
     const id2 = String(requiredConstructorId2);
     if (listedIds.has(id2)) {
       invalid(path, `constructor ${JSON.stringify(id2)} is already owned.`);
@@ -43551,7 +43476,7 @@ function assertConstructorInvariants(manifest) {
       schemaClass2.constructorIds,
       `$.classes[${index}].constructorIds`
     ).map((entry, entryIndex) => {
-      nonEmptyString3(
+      nonEmptyString2(
         entry,
         `$.classes[${index}].constructorIds[${entryIndex}]`
       );
@@ -43593,7 +43518,7 @@ function assertConstructor2(value, path) {
   );
   assertIdentity2(declared, path, "constructor");
   assertOptionalDocsText2(declared.docsText, `${path}.docsText`);
-  nonEmptyString3(declared.classId, `${path}.classId`);
+  nonEmptyString2(declared.classId, `${path}.classId`);
   arrayOf(declared.arguments, `${path}.arguments`, assertFunctionArgument);
   if (declared.code !== null && typeof declared.code !== "string") {
     invalid(
@@ -43639,11 +43564,11 @@ function assertVariant(value, path) {
     "valueId"
   ]);
   assertIdentity2(variant2, path, "variant");
-  nonEmptyString3(variant2.classId, `${path}.classId`);
-  nonEmptyString3(variant2.name, `${path}.name`);
-  nonEmptyString3(variant2.valueId, `${path}.valueId`);
+  nonEmptyString2(variant2.classId, `${path}.classId`);
+  nonEmptyString2(variant2.name, `${path}.name`);
+  nonEmptyString2(variant2.valueId, `${path}.valueId`);
   if (variant2.folderId === null) return;
-  nonEmptyString3(variant2.folderId, `${path}.folderId`);
+  nonEmptyString2(variant2.folderId, `${path}.folderId`);
 }
 function assertVariantFolder(value, path) {
   const folder = objectAt(value, path, [
@@ -43654,30 +43579,30 @@ function assertVariantFolder(value, path) {
     "binding"
   ]);
   assertIdentity2(folder, path, "variantFolder");
-  nonEmptyString3(folder.classId, `${path}.classId`);
+  nonEmptyString2(folder.classId, `${path}.classId`);
   if (typeof folder.path !== "string")
     invalid(`${path}.path`, "must be a string.");
   if (folder.binding === null) {
-    nonEmptyString3(folder.path, `${path}.path`);
+    nonEmptyString2(folder.path, `${path}.path`);
     return;
   }
   const binding = objectAt(folder.binding, `${path}.binding`, [
     "collectionMemberId",
     "collectionValueId"
   ]);
-  nonEmptyString3(
+  nonEmptyString2(
     binding.collectionMemberId,
     `${path}.binding.collectionMemberId`
   );
-  nonEmptyString3(
+  nonEmptyString2(
     binding.collectionValueId,
     `${path}.binding.collectionValueId`
   );
 }
 function assertConstructorBaseArgument(value, path) {
   const argument2 = objectAt(value, path, ["name", "code"]);
-  nonEmptyString3(argument2.name, `${path}.name`);
-  nonEmptyString3(argument2.code, `${path}.code`);
+  nonEmptyString2(argument2.name, `${path}.name`);
+  nonEmptyString2(argument2.code, `${path}.code`);
 }
 function assertInternalRecordRelation(value, path) {
   const relation = objectAt(value, path, [
@@ -43690,13 +43615,13 @@ function assertInternalRecordRelation(value, path) {
     "targetRecordId",
     "order"
   ]);
-  nonEmptyString3(relation.id, `${path}.id`);
+  nonEmptyString2(relation.id, `${path}.id`);
   assertSourceIdentity(relation.source, `${path}.source`);
-  nonEmptyString3(relation.relationKind, `${path}.relationKind`);
+  nonEmptyString2(relation.relationKind, `${path}.relationKind`);
   projectRecordKind2(relation.sourceRecordKind, `${path}.sourceRecordKind`);
-  nonEmptyString3(relation.sourceRecordId, `${path}.sourceRecordId`);
+  nonEmptyString2(relation.sourceRecordId, `${path}.sourceRecordId`);
   projectRecordKind2(relation.targetRecordKind, `${path}.targetRecordKind`);
-  nonEmptyString3(relation.targetRecordId, `${path}.targetRecordId`);
+  nonEmptyString2(relation.targetRecordId, `${path}.targetRecordId`);
   if (relation.order !== null && (typeof relation.order !== "number" || !Number.isInteger(relation.order) || relation.order < 0)) {
     invalid(`${path}.order`, "expected null or a non-negative integer.");
   }
@@ -44002,8 +43927,8 @@ function assertStaticMemberInvariants(manifest) {
         `static member ${JSON.stringify(memberName)} (${memberId}) has owner kind ${JSON.stringify(ownerKind)}; expected exactly one direct Class owner.`
       );
     }
-    const ownerClassId = nonEmptyString3(owner.classId, `${path}.owner.classId`);
-    const schemaKey = nonEmptyString3(
+    const ownerClassId = nonEmptyString2(owner.classId, `${path}.owner.classId`);
+    const schemaKey = nonEmptyString2(
       owner.schemaKey,
       `${path}.owner.schemaKey`
     );
@@ -44201,7 +44126,7 @@ function assertStaticMemberInvariants(manifest) {
   }
 }
 function assertIdentity2(value, path, expectedKind) {
-  nonEmptyString3(value.id, `${path}.id`);
+  nonEmptyString2(value.id, `${path}.id`);
   assertSourceIdentity(value.source, `${path}.source`, expectedKind);
 }
 function assertSourceIdentity(value, path, expectedKind) {
@@ -44247,7 +44172,7 @@ function assertNeoSchemaClass(value, path) {
     ]
   );
   assertIdentity2(type, path, "class");
-  nonEmptyString3(type.name, `${path}.name`);
+  nonEmptyString2(type.name, `${path}.name`);
   assertOptionalDocsText2(type.docsText, `${path}.docsText`);
   stringIn(
     type.declarationModifier,
@@ -44275,7 +44200,7 @@ function assertNeoSchemaClass(value, path) {
   );
   nullableNonEmptyString(type.targetMemberId, `${path}.targetMemberId`);
   if (type.requiredConstructorId !== void 0) {
-    nonEmptyString3(type.requiredConstructorId, `${path}.requiredConstructorId`);
+    nonEmptyString2(type.requiredConstructorId, `${path}.requiredConstructorId`);
   }
 }
 function assertGenericParameter(value, path) {
@@ -44309,7 +44234,7 @@ function assertInterface(value, path) {
     ["docsText"]
   );
   assertIdentity2(neoInterface, path, "interface");
-  nonEmptyString3(neoInterface.name, `${path}.name`);
+  nonEmptyString2(neoInterface.name, `${path}.name`);
   assertOptionalDocsText2(neoInterface.docsText, `${path}.docsText`);
   arrayOf(neoInterface.members, `${path}.members`, assertInterfaceMember);
   stringArray(neoInterface.extendsInterfaceIds, `${path}.extendsInterfaceIds`);
@@ -44324,8 +44249,8 @@ function assertInterfaceMember(value, path) {
       ["id", "kind", "name", "type", "settable", "accessModifier", "source"],
       ["docsText"]
     );
-    nonEmptyString3(member.id, `${path}.id`);
-    nonEmptyString3(member.name, `${path}.name`);
+    nonEmptyString2(member.id, `${path}.id`);
+    nonEmptyString2(member.name, `${path}.name`);
     assertOptionalDocsText2(member.docsText, `${path}.docsText`);
     assertType2(member.type, `${path}.type`);
     booleanAt(member.settable, `${path}.settable`);
@@ -44349,8 +44274,8 @@ function assertInterfaceMember(value, path) {
       ],
       ["docsText"]
     );
-    nonEmptyString3(member.id, `${path}.id`);
-    nonEmptyString3(member.name, `${path}.name`);
+    nonEmptyString2(member.id, `${path}.id`);
+    nonEmptyString2(member.name, `${path}.name`);
     assertOptionalDocsText2(member.docsText, `${path}.docsText`);
     assertFunctionSignature(member, path);
     assertInterfaceMemberAccessModifier(member.accessModifier, path);
@@ -44370,7 +44295,7 @@ function assertEnum2(value, path) {
     ["docsText"]
   );
   assertIdentity2(neoEnum, path, "enum");
-  nonEmptyString3(neoEnum.name, `${path}.name`);
+  nonEmptyString2(neoEnum.name, `${path}.name`);
   assertOptionalDocsText2(neoEnum.docsText, `${path}.docsText`);
   arrayOf(neoEnum.options, `${path}.options`, assertEnumOption);
   assertSystem(neoEnum.system, `${path}.system`);
@@ -44378,7 +44303,7 @@ function assertEnum2(value, path) {
   const options = requireArray(neoEnum.options, `${path}.options`);
   options.forEach((entry, index) => {
     const option = requireRecord(entry, `${path}.options[${index}]`);
-    const key = nonEmptyString3(option.key, `${path}.options[${index}].key`);
+    const key = nonEmptyString2(option.key, `${path}.options[${index}].key`);
     if (seen.has(key))
       invalid(`${path}.options[${index}].key`, "is duplicated.");
     seen.add(key);
@@ -44391,9 +44316,9 @@ function assertEnumOption(value, path) {
     ["id", "name", "key", "text", "source"],
     ["docsText"]
   );
-  nonEmptyString3(option.id, `${path}.id`);
-  nonEmptyString3(option.name, `${path}.name`);
-  nonEmptyString3(option.key, `${path}.key`);
+  nonEmptyString2(option.id, `${path}.id`);
+  nonEmptyString2(option.name, `${path}.name`);
+  nonEmptyString2(option.key, `${path}.key`);
   stringAt(option.text, `${path}.text`);
   assertOptionalDocsText2(option.docsText, `${path}.docsText`);
   assertSourceIdentity(option.source, `${path}.source`, "enumOption");
@@ -44439,7 +44364,7 @@ function assertTextureTemplate(value, path) {
     "swizzle"
   ]);
   assertIdentity2(texture, path, "textureTemplate");
-  nonEmptyString3(texture.name, `${path}.name`);
+  nonEmptyString2(texture.name, `${path}.name`);
   exactValue(texture.type, "texture-2d", `${path}.type`);
   stringIn(texture.textureType, TEXTURE_TYPES, `${path}.textureType`);
   exactValue(texture.textureShape, "2d", `${path}.textureShape`);
@@ -44684,7 +44609,7 @@ function assertAudioTemplate(value, path) {
     "preloadAudioData"
   ]);
   assertIdentity2(audio, path, "audioTemplate");
-  nonEmptyString3(audio.name, `${path}.name`);
+  nonEmptyString2(audio.name, `${path}.name`);
   for (const field of [
     "forceToMono",
     "normalize",
@@ -44726,14 +44651,14 @@ function assertLocalization(value, path) {
     "mainLocaleDefaultStatusId"
   ]);
   assertIdentity2(localization, path, "localization");
-  nonEmptyString3(localization.mainLocale, `${path}.mainLocale`);
+  nonEmptyString2(localization.mainLocale, `${path}.mainLocale`);
   arrayOf(
     localization.supportedLocales,
     `${path}.supportedLocales`,
     assertLocale
   );
   stringArray(localization.sortedStatusIds, `${path}.sortedStatusIds`);
-  nonEmptyString3(
+  nonEmptyString2(
     localization.mainLocaleDefaultStatusId,
     `${path}.mainLocaleDefaultStatusId`
   );
@@ -44754,8 +44679,8 @@ function assertLocalizationStatus(value, path) {
     "system"
   ]);
   assertIdentity2(status, path, "localizationStatus");
-  nonEmptyString3(status.slug, `${path}.slug`);
-  nonEmptyString3(status.name, `${path}.name`);
+  nonEmptyString2(status.slug, `${path}.slug`);
+  nonEmptyString2(status.name, `${path}.name`);
   nullableString3(status.description, `${path}.description`);
   nullableString3(status.color, `${path}.color`);
   nullableString3(status.emoji, `${path}.emoji`);
@@ -44781,7 +44706,7 @@ function assertLocale(value, path) {
     "sortOrder",
     "archivedAt"
   ]);
-  nonEmptyString3(locale.locale, `${path}.locale`);
+  nonEmptyString2(locale.locale, `${path}.locale`);
   nullableNonEmptyString(locale.sourceLocale, `${path}.sourceLocale`);
   nullableString3(locale.name, `${path}.name`);
   finiteNumber2(locale.sortOrder, `${path}.sortOrder`);
@@ -44846,7 +44771,7 @@ function requireArray(value, path) {
 }
 function stringArray(value, path) {
   arrayOf(value, path, (entry, entryPath) => {
-    nonEmptyString3(entry, entryPath);
+    nonEmptyString2(entry, entryPath);
   });
 }
 function nullableStringArray(value, path) {
@@ -44856,8 +44781,8 @@ function nullableStringArray(value, path) {
 function stringRecord(value, path) {
   const record6 = requireRecord(value, path);
   for (const [key, entry] of Object.entries(record6)) {
-    nonEmptyString3(key, `${path} key`);
-    nonEmptyString3(entry, `${path}.${key}`);
+    nonEmptyString2(key, `${path} key`);
+    nonEmptyString2(entry, `${path}.${key}`);
   }
 }
 function uniqueIds(value, path) {
@@ -44865,7 +44790,7 @@ function uniqueIds(value, path) {
   const seen = /* @__PURE__ */ new Set();
   records2.forEach((entry, index) => {
     const record6 = requireRecord(entry, `${path}[${index}]`);
-    const id2 = nonEmptyString3(record6.id, `${path}[${index}].id`);
+    const id2 = nonEmptyString2(record6.id, `${path}[${index}].id`);
     if (seen.has(id2))
       invalid(`${path}[${index}].id`, `duplicates id ${JSON.stringify(id2)}.`);
     seen.add(id2);
@@ -44875,7 +44800,7 @@ function nullableObject(value, path, assertion) {
   if (value === null) return;
   assertion(value, path);
 }
-function nonEmptyString3(value, path) {
+function nonEmptyString2(value, path) {
   const result = stringAt(value, path);
   if (result.length === 0) invalid(path, "must not be empty.");
   return result;
@@ -44901,7 +44826,7 @@ function nullableString3(value, path) {
 }
 function nullableNonEmptyString(value, path) {
   if (value === null) return;
-  nonEmptyString3(value, path);
+  nonEmptyString2(value, path);
 }
 function finiteNumber2(value, path) {
   if (typeof value !== "number" || !Number.isFinite(value)) {
@@ -57976,12 +57901,12 @@ function lowerStructuredLeafComponents(kind, label, expression, lowering) {
 function structuredLeafPartialAssignments(kind, label, value, emit) {
   const stored = value[STRUCTURED_LEAF_PARTIAL_KEY];
   const declared = structuredLeafFields(kind);
-  const unknown2 = Object.keys(stored).find(
+  const unknown = Object.keys(stored).find(
     (key) => !declared.some((entry) => entry.key === key)
   );
-  if (unknown2 !== void 0) {
+  if (unknown !== void 0) {
     throw new Error(
-      `${label} stores unknown field ${JSON.stringify(unknown2)}. ${structuredLeafTypeName(kind)} accepts ${structuredLeafFieldNames(kind).join(", ")}.`
+      `${label} stores unknown field ${JSON.stringify(unknown)}. ${structuredLeafTypeName(kind)} accepts ${structuredLeafFieldNames(kind).join(", ")}.`
     );
   }
   const assignments = [];
@@ -86570,6 +86495,54 @@ var init_materialize_values = __esm({
   }
 });
 
+// ../convex/convexValues.ts
+function decodeConvexOpaqueJson(value, context) {
+  if (typeof value !== "string") {
+    throw new Error(`${context} must be an encoded JSON string.`);
+  }
+  try {
+    return JSON.parse(value);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`${context} could not be parsed as JSON: ${message}`);
+  }
+}
+var CONVEX_DOCUMENT_WARNING_BYTES, CONVEX_DOCUMENT_MAX_BYTES;
+var init_convexValues = __esm({
+  "../convex/convexValues.ts"() {
+    "use strict";
+    CONVEX_DOCUMENT_WARNING_BYTES = 750 * 1024;
+    CONVEX_DOCUMENT_MAX_BYTES = 1024 * 1024;
+  }
+});
+
+// ../convex/projectRecordSnapshotStorage.ts
+function decodeProjectRecordSnapshotData(snapshot, context = `Project record snapshot for ${snapshot.recordKind} "${snapshot.recordId}" dataJson`) {
+  const decoded = decodeConvexOpaqueJson(snapshot.dataJson, context);
+  if (!isPlainRecord(decoded)) return decoded;
+  const hydratedData = { ...decoded };
+  if (snapshot.recordKind === "enum" && !Object.hasOwn(hydratedData, "optionKeyOrder") && isPlainRecord(hydratedData.options)) {
+    hydratedData.optionKeyOrder = Object.keys(hydratedData.options);
+  }
+  hydratedData.id = snapshot.recordId;
+  if (snapshot.recordKind !== "project") {
+    hydratedData.projectId = snapshot.projectId;
+  }
+  if (!Object.hasOwn(hydratedData, "updatedAt")) {
+    hydratedData.updatedAt = snapshot.createdAt;
+  }
+  return hydratedData;
+}
+function isPlainRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var init_projectRecordSnapshotStorage = __esm({
+  "../convex/projectRecordSnapshotStorage.ts"() {
+    "use strict";
+    init_convexValues();
+  }
+});
+
 // ../src/database/project-read-base.ts
 import { ConvexError } from "convex/values";
 function readProjectReadBase(value) {
@@ -86887,6 +86860,7 @@ var project_document_read_exports = {};
 __export(project_document_read_exports, {
   DOCUMENT_MANIFEST_PAGE_SIZE: () => DOCUMENT_MANIFEST_PAGE_SIZE,
   assembleProjectDocumentRaw: () => assembleProjectDocumentRaw,
+  createDocumentPageReader: () => createDocumentPageReader,
   fetchProjectDocumentPartitionRecords: () => fetchProjectDocumentPartitionRecords,
   fetchProjectDocumentRawChunked: () => fetchProjectDocumentRawChunked,
   fetchProjectDocumentRawChunkedOnce: () => fetchProjectDocumentRawChunkedOnce,
@@ -86944,46 +86918,14 @@ async function fetchProjectDocumentRawChunkedOnce(runner, options = {}) {
   };
   try {
     await rememberRecords(firstPage);
-    const fetchRemainingPages = async (mapKey, initialCursor) => {
-      let cursor = initialCursor;
-      while (cursor !== null) {
-        const pageResult = await runner.fetchPage(
-          {
-            numItems: DOCUMENT_MANIFEST_PAGE_SIZE,
-            cursor
-          },
-          mapKey,
-          readBase
-        );
-        if (pageResult === null) {
-          throw new Error(
-            "Convex project document manifest returned null for a continuation page."
-          );
-        }
-        const page = readProjectDocumentPage(pageResult);
-        assertProjectReadBase(readBase, page.readBase);
-        await rememberRecords(page);
-        cursor = page.continueCursor;
-      }
-    };
-    await fetchRemainingPages(firstMapKey, firstPage.continueCursor);
-    for (const mapKey of mapKeys.slice(1)) {
-      const pageResult = await runner.fetchPage(
-        { numItems: DOCUMENT_MANIFEST_PAGE_SIZE, cursor: null },
-        mapKey,
-        readBase,
-        "omit"
-      );
-      if (pageResult === null) {
-        throw new Error(
-          `Convex project document manifest returned null for partition "${mapKey ?? "all"}".`
-        );
-      }
-      const page = readProjectDocumentPage(pageResult);
-      assertProjectReadBase(readBase, page.readBase);
-      await rememberRecords(page);
-      await fetchRemainingPages(mapKey, page.continueCursor);
-    }
+    const pages = createDocumentPageReader(runner, firstPage.readConcurrency);
+    await drainDocumentReads([
+      pages.remaining(firstPage, firstMapKey, readBase, rememberRecords),
+      ...mapKeys.slice(1).map(async (mapKey) => {
+        const page = await pages.first(mapKey, readBase, rememberRecords);
+        await pages.remaining(page, mapKey, readBase, rememberRecords);
+      })
+    ]);
     const snapshotsById = await snapshots.finish();
     if (options.mapKeys !== void 0 && !options.mapKeys.includes("all")) {
       const members = [];
@@ -87043,28 +86985,15 @@ async function fetchProjectDocumentPartitionRecords(runner, mapKey, readBase) {
     (ids) => fetchScopedSnapshotBatch(runner, ids, readBase)
   );
   try {
-    let cursor = null;
-    do {
-      const pageResult = await runner.fetchPage(
-        { numItems: DOCUMENT_MANIFEST_PAGE_SIZE, cursor },
-        mapKey,
-        readBase,
-        "omit"
-      );
-      if (pageResult === null) {
-        throw new Error(
-          `Convex project document manifest returned null for partition "${mapKey}".`
-        );
-      }
-      const page = readProjectDocumentPage(pageResult);
-      assertProjectReadBase(readBase, page.readBase);
-      for (const record6 of page.records) {
+    const pages = createDocumentPageReader(runner);
+    const remember = async (page) => {
+      for (const record6 of page.records)
         recordsByKey.set(`${record6.recordKind} ${record6.recordId}`, record6);
-      }
       if (page.snapshots !== void 0) snapshots.seed(page.snapshots);
       await snapshots.enqueue(page.records.map((record6) => record6.snapshotId));
-      cursor = page.continueCursor;
-    } while (cursor !== null);
+    };
+    const first = await pages.first(mapKey, readBase, remember);
+    await pages.remaining(first, mapKey, readBase, remember);
     const snapshotsById = await snapshots.finish();
     await runner.validateReadBase(readBase);
     return [...recordsByKey.values()].map((record6) => {
@@ -87086,6 +87015,84 @@ async function fetchProjectDocumentPartitionRecords(runner, mapKey, readBase) {
     await snapshots.stop();
   }
 }
+function createDocumentPageReader(runner, concurrency) {
+  let active = 0;
+  let nextWaiter = 0;
+  let waiters = [];
+  let failure;
+  const readPage = async (pagination, mapKey, readBase, remember) => {
+    if (active >= (concurrency ?? 1))
+      await new Promise((resolve5) => waiters.push(resolve5));
+    else active++;
+    try {
+      if (failure !== void 0) throw failure.error;
+      const raw = await runner.fetchPage(pagination, mapKey, readBase, "omit");
+      if (raw === null)
+        throw new Error(
+          `Missing document page for partition "${mapKey ?? "all"}".`
+        );
+      const page = readProjectDocumentPage(raw);
+      assertProjectReadBase(readBase, page.readBase);
+      concurrency ??= page.readConcurrency ?? 1;
+      if (pagination.cursor !== null && page.continueCursor === pagination.cursor)
+        throw new Error("Document continuation made no progress.");
+      if (pagination.endCursor != null && page.continueCursor === null)
+        throw new Error("Document range ended before its endpoint.");
+      await remember(page, pagination.cursor);
+      return page;
+    } catch (error) {
+      failure ??= { error };
+      throw error;
+    } finally {
+      const next = waiters[nextWaiter++];
+      if (next !== void 0) next();
+      else {
+        active--;
+        nextWaiter = 0;
+        waiters = [];
+      }
+    }
+  };
+  return {
+    first(mapKey, readBase, remember) {
+      return readPage(
+        { numItems: DOCUMENT_MANIFEST_PAGE_SIZE, cursor: null },
+        mapKey,
+        readBase,
+        remember
+      );
+    },
+    async remaining(first, mapKey, readBase, remember) {
+      if (first.continueCursor === null) return;
+      const ranges = first.remainingRanges ?? [
+        { cursor: first.continueCursor, endCursor: null }
+      ];
+      await drainDocumentReads(
+        ranges.map(async (range2) => {
+          let cursor = range2.cursor;
+          while (cursor !== null && cursor !== range2.endCursor) {
+            const page = await readPage(
+              {
+                numItems: DOCUMENT_MANIFEST_PAGE_SIZE,
+                cursor,
+                endCursor: range2.endCursor
+              },
+              mapKey,
+              readBase,
+              remember
+            );
+            cursor = page.continueCursor;
+          }
+        })
+      );
+    }
+  };
+}
+async function drainDocumentReads(reads) {
+  const results = await Promise.allSettled(reads);
+  for (const result of results)
+    if (result.status === "rejected") throw result.reason;
+}
 async function fetchProjectDocumentValueRecords(runner, valueIds, readBase) {
   if (runner.fetchValueSnapshotsPage === void 0) {
     throw new Error(
@@ -87151,6 +87158,41 @@ function readProjectDocumentPage(value) {
       "Convex project document manifest page continueCursor must be a string or null."
     );
   }
+  let remainingRanges;
+  if (value.remainingRanges !== void 0) {
+    if (!Array.isArray(value.remainingRanges))
+      throw new Error("Snapshot remaining ranges must be an array.");
+    remainingRanges = [];
+    let expectedCursor = continueCursor;
+    for (const range2 of value.remainingRanges) {
+      if (!isObject4(range2))
+        throw new Error("Snapshot range must be an object.");
+      if (typeof range2.cursor !== "string")
+        throw new Error("Snapshot range cursor must be a string.");
+      if (range2.endCursor !== null && typeof range2.endCursor !== "string")
+        throw new Error("Snapshot range end cursor must be a string or null.");
+      if (range2.cursor !== expectedCursor)
+        throw new Error("Snapshot ranges must form a contiguous continuation.");
+      if (range2.cursor === range2.endCursor)
+        throw new Error("Snapshot range must make progress.");
+      remainingRanges.push({
+        cursor: range2.cursor,
+        endCursor: range2.endCursor
+      });
+      expectedCursor = range2.endCursor;
+    }
+    if (expectedCursor !== null)
+      throw new Error("Snapshot ranges must cover the entire remaining tail.");
+  }
+  const readConcurrency = value.readConcurrency;
+  if (readConcurrency !== void 0) {
+    if (typeof readConcurrency !== "number")
+      throw new Error("Document read concurrency must be a number.");
+    if (!Number.isSafeInteger(readConcurrency))
+      throw new Error("Document read concurrency must be a safe integer.");
+    if (readConcurrency < 1)
+      throw new Error("Document read concurrency must be positive.");
+  }
   const metadata = value.metadata ?? null;
   if (metadata !== null && !isObject4(metadata)) {
     throw new Error(
@@ -87167,6 +87209,8 @@ function readProjectDocumentPage(value) {
       releaseChannels: metadata.releaseChannels,
       documentRevision: metadata.documentRevision
     },
+    ...remainingRanges === void 0 ? {} : { remainingRanges },
+    ...readConcurrency === void 0 ? {} : { readConcurrency },
     ...snapshots === void 0 ? {} : { snapshots },
     records: snapshots === void 0 ? readProjectDocumentManifestRecords(value.records) : snapshots.map((snapshot) => ({
       recordKind: snapshot.recordKind,
@@ -87220,7 +87264,21 @@ function readProjectDocumentManifestPageRecords(value) {
   if (!isObject4(value)) {
     throw new Error("Convex project document manifest page must be an object.");
   }
-  return readProjectDocumentPage(value).records;
+  if (value.snapshots === void 0)
+    return readProjectDocumentManifestRecords(value.records);
+  if (!Array.isArray(value.snapshots))
+    throw new Error("Snapshot page snapshots must be an array.");
+  return readProjectDocumentManifestRecords(
+    value.snapshots.map((snapshot) => {
+      if (!isObject4(snapshot))
+        throw new Error("Snapshot page entry must be an object.");
+      return {
+        recordKind: snapshot.recordKind,
+        recordId: snapshot.recordId,
+        snapshotId: snapshot.id
+      };
+    })
+  );
 }
 async function fetchProjectDocumentSnapshots(fetchBatch, snapshotIds) {
   const loader = createProjectDocumentSnapshotLoader(fetchBatch);
@@ -87236,6 +87294,7 @@ function createProjectDocumentSnapshotLoader(fetchBatch) {
   const snapshotsById = /* @__PURE__ */ new Map();
   const active = /* @__PURE__ */ new Set();
   let pending = [];
+  let enqueued = Promise.resolve();
   let stopped = false;
   let failure;
   const checkFailure = () => {
@@ -87272,17 +87331,21 @@ function createProjectDocumentSnapshotLoader(fetchBatch) {
         snapshotsById.set(snapshot.id, snapshot);
       }
     },
-    async enqueue(snapshotIds) {
-      checkFailure();
-      for (const id2 of snapshotIds) {
-        if (seen.has(id2)) continue;
-        seen.add(id2);
-        pending.push(id2);
-        if (pending.length === DOCUMENT_SNAPSHOT_FETCH_CHUNK_SIZE)
-          await flush();
-      }
+    enqueue(snapshotIds) {
+      enqueued = enqueued.then(async () => {
+        checkFailure();
+        for (const id2 of snapshotIds) {
+          if (seen.has(id2)) continue;
+          seen.add(id2);
+          pending.push(id2);
+          if (pending.length === DOCUMENT_SNAPSHOT_FETCH_CHUNK_SIZE)
+            await flush();
+        }
+      });
+      return enqueued;
     },
     async finish() {
+      await enqueued;
       await flush();
       await Promise.all(active);
       checkFailure();
@@ -87290,6 +87353,8 @@ function createProjectDocumentSnapshotLoader(fetchBatch) {
     },
     async stop() {
       stopped = true;
+      await enqueued.catch(() => {
+      });
       await Promise.all(active);
     }
   };
@@ -87361,6 +87426,30 @@ function readProjectDocumentSnapshotBatch(value, requestedIds) {
         `Convex project record snapshot "${snapshot.id}" is missing a content hash.`
       );
     }
+    let data = snapshot.data;
+    if ("dataJson" in snapshot) {
+      if (typeof snapshot.dataJson !== "string")
+        throw new Error(`Snapshot "${snapshot.id}" dataJson must be a string.`);
+      if (typeof snapshot.projectId !== "string")
+        throw new Error(
+          `Snapshot "${snapshot.id}" projectId must be a string.`
+        );
+      if (typeof snapshot.createdAt !== "number")
+        throw new Error(
+          `Snapshot "${snapshot.id}" createdAt must be a number.`
+        );
+      if (!Number.isFinite(snapshot.createdAt))
+        throw new Error(
+          `Snapshot "${snapshot.id}" createdAt must be finite milliseconds.`
+        );
+      data = decodeProjectRecordSnapshotData({
+        projectId: snapshot.projectId,
+        recordKind,
+        recordId: snapshot.recordId,
+        createdAt: snapshot.createdAt,
+        dataJson: snapshot.dataJson
+      });
+    }
     return {
       id: snapshot.id,
       recordKind,
@@ -87371,7 +87460,7 @@ function readProjectDocumentSnapshotBatch(value, requestedIds) {
       data: readCurrentProjectRecordData({
         recordKind,
         dataSchemaVersion: snapshot.dataSchemaVersion,
-        data: snapshot.data
+        data
       })
     };
   });
@@ -87693,6 +87782,7 @@ var DOCUMENT_MANIFEST_PAGE_SIZE, DOCUMENT_SNAPSHOT_FETCH_CHUNK_SIZE, DOCUMENT_SN
 var init_project_document_read = __esm({
   "../src/database/project-document-read.ts"() {
     "use strict";
+    init_projectRecordSnapshotStorage();
     init_project_read_base();
     init_project2();
     init_members();
@@ -87711,7 +87801,7 @@ var init_project_document_read = __esm({
     init_projectRecordBuckets();
     init_project_record_migrations();
     init_member_default_reference_ids();
-    DOCUMENT_MANIFEST_PAGE_SIZE = 2048;
+    DOCUMENT_MANIFEST_PAGE_SIZE = 8192;
     DOCUMENT_SNAPSHOT_FETCH_CHUNK_SIZE = 128;
     DOCUMENT_SNAPSHOT_FETCH_CONCURRENCY = 4;
   }
@@ -88394,7 +88484,7 @@ var init_commit_preparation_scope_planner = __esm({
 
 // ../src/database/project-record-semantics.ts
 function projectRecordSemanticData(value) {
-  if (!isPlainRecord(value)) return value;
+  if (!isPlainRecord2(value)) return value;
   const semantic = {};
   for (const [key, child] of Object.entries(value)) {
     if (SERVER_MANAGED_PROJECT_RECORD_FIELDS.has(key)) continue;
@@ -88431,7 +88521,7 @@ function toCanonicalJsonValue2(value) {
   if (Array.isArray(value)) {
     return value.map((item) => toCanonicalJsonValue2(item) ?? null);
   }
-  if (!isPlainRecord(value)) {
+  if (!isPlainRecord2(value)) {
     throw new Error("Cannot canonicalize a non-plain object.");
   }
   const canonical = {};
@@ -88445,7 +88535,7 @@ function toCanonicalJsonValue2(value) {
   }
   return canonical;
 }
-function isPlainRecord(value) {
+function isPlainRecord2(value) {
   if (value === null || typeof value !== "object") return false;
   const prototype = Object.getPrototypeOf(value);
   return prototype === Object.prototype || prototype === null;
@@ -88479,7 +88569,7 @@ function stagedChangesAffectClassRelations(current, changes) {
       const before2 = classesById.get(change.recordId);
       if (before2 === void 0) return true;
       const after = change.nextData;
-      if (!isPlainRecord2(after)) return true;
+      if (!isPlainRecord3(after)) return true;
       if (before2.extendsClassId !== after.extendsClassId) return true;
       continue;
     }
@@ -88498,11 +88588,102 @@ function valueCreateCannotAffectClassRelations(change, before) {
   return before === void 0;
 }
 function relationEndpointClassId(record6) {
-  if (!isPlainRecord2(record6)) return void 0;
+  if (!isPlainRecord3(record6)) return void 0;
   if (typeof record6.classId === "string") return record6.classId;
   return void 0;
 }
-function isPlainRecord2(value) {
+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);
 }
@@ -88558,7 +88739,7 @@ function assertWorldFootprintEntryTypes(document, changes) {
     if (change.recordKind !== "value" || change.operation === "delete" || change.deleted)
       continue;
     referencedIds2.add(change.recordId);
-    if (isPlainRecord3(change.nextData) && Array.isArray(change.nextData.value)) {
+    if (isPlainRecord4(change.nextData) && Array.isArray(change.nextData.value)) {
       for (const id2 of change.nextData.value)
         if (typeof id2 === "string") referencedIds2.add(id2);
     }
@@ -88595,14 +88776,14 @@ function createdWorldPlacementIds(changes, worldKinds) {
 }
 function hasWorldPlacementBinding(value, worldKinds) {
   if (hasWorldPlacementSidecar(value)) return true;
-  if (!isPlainRecord3(value) || typeof value.containerId !== "string")
+  if (!isPlainRecord4(value) || typeof value.containerId !== "string")
     return false;
   if (typeof value.classId !== "string") return false;
   const kind = worldKinds?.get(value.classId);
   return kind === NeoWorldSystemClassKind.Tile;
 }
 function hasWorldPlacementSidecar(value) {
-  if (!isPlainRecord3(value) || !isPlainRecord3(value.value)) return false;
+  if (!isPlainRecord4(value) || !isPlainRecord4(value.value)) return false;
   const body = value.value;
   if (typeof body.assetClassId === "string") return true;
   if (typeof body.assetValueId === "string") return true;
@@ -88616,7 +88797,7 @@ function worldPlacementBindingChanged(before, after) {
   );
 }
 function worldPlacementBindingSlice(value) {
-  if (!isPlainRecord3(value) || !isPlainRecord3(value.value)) return null;
+  if (!isPlainRecord4(value) || !isPlainRecord4(value.value)) return null;
   return {
     classId: value.classId ?? null,
     containerId: value.containerId ?? null,
@@ -88635,13 +88816,13 @@ function ownedSparseValueBindingChanged(before, after) {
   );
 }
 function ownedSparseValueBindingSlice(value) {
-  if (!isPlainRecord3(value)) return null;
+  if (!isPlainRecord4(value)) return null;
   return {
     classId: value.classId ?? null,
     containerId: value.containerId ?? null
   };
 }
-function isPlainRecord3(value) {
+function isPlainRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function stagedChangesRequireWorldLayerBindingValidation(current, changes) {
@@ -88657,14 +88838,14 @@ function stagedChangesRequireWorldLayerBindingValidation(current, changes) {
       continue;
     }
     if (change.recordKind !== "class") continue;
-    if (change.operation === "create" && change.deleted !== true && !classesById.has(change.recordId) && isPlainRecord3(change.nextData) && change.nextData.extendsClassId == null && change.nextData.system == null)
+    if (change.operation === "create" && change.deleted !== true && !classesById.has(change.recordId) && isPlainRecord4(change.nextData) && change.nextData.extendsClassId == null && change.nextData.system == null)
       continue;
     if (change.operation !== "update") return true;
     if (change.deleted === true) return true;
     const before = classesById.get(change.recordId);
     if (before === void 0) return true;
     const after = change.nextData;
-    if (!isPlainRecord3(after)) return true;
+    if (!isPlainRecord4(after)) return true;
     if (before.extendsClassId !== after.extendsClassId) return true;
     if (isAbstractClass(before) !== isAbstractClass(after)) return true;
     if (!worldClassSystemBlockIsEqual(before.system, after.system)) return true;
@@ -88686,12 +88867,12 @@ function stagedChangesRequireWorldLayerBindingValidation(current, changes) {
       before,
       change.deleted === true || change.operation === "delete" ? null : change.nextData
     ) ? [before, change.nextData] : []) {
-      if (!isPlainRecord3(row) || typeof row.containerId !== "string") continue;
+      if (!isPlainRecord4(row) || typeof row.containerId !== "string") continue;
       for (const owner of [
         valuesById.get(row.containerId),
         changedValuesById.get(row.containerId)
       ]) {
-        if (isPlainRecord3(owner) && isPlainRecord3(owner.value) && owner.value.assetValueId === change.recordId)
+        if (isPlainRecord4(owner) && isPlainRecord4(owner.value) && owner.value.assetValueId === change.recordId)
           return true;
       }
     }
@@ -88714,9 +88895,9 @@ function worldClassSystemBlockIsEqual(before, after) {
   );
 }
 function hasWorldLayerOverrideMetadata(record6) {
-  if (!isPlainRecord3(record6)) return false;
+  if (!isPlainRecord4(record6)) return false;
   const value = record6.value;
-  if (!isPlainRecord3(value)) return false;
+  if (!isPlainRecord4(value)) return false;
   return typeof value.layerOverrideValueId === "string";
 }
 var init_project_world_placement_bindings = __esm({
@@ -97455,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,
@@ -98326,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,
@@ -98801,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([
@@ -99708,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;
@@ -106579,7 +106644,7 @@ function systemProtectedWriteInheritedRecordId(write) {
     return null;
   if (write.deleted) return null;
   if (!isSystemBearingRecordKind(write.recordKind)) return null;
-  if (!isPlainRecord4(write.nextData)) return null;
+  if (!isPlainRecord5(write.nextData)) return null;
   if (readSystemMetadata(write.nextData) === null) return null;
   const extendsMemberId = write.nextData.extendsMemberId;
   if (typeof extendsMemberId !== "string") return null;
@@ -106599,7 +106664,7 @@ function assertSystemProtectedRecordWriteValid(write) {
   assertSystemMetadataUnchanged(write, base);
 }
 function readBaseRecord(write) {
-  if (!isPlainRecord4(write.baseData)) return null;
+  if (!isPlainRecord5(write.baseData)) return null;
   return {
     recordKind: write.recordKind,
     data: write.baseData,
@@ -106612,7 +106677,7 @@ function collectSystemBearingBaseRecords(document) {
     const stored = document[collection];
     if (!Array.isArray(stored)) continue;
     for (const record6 of stored) {
-      if (!isPlainRecord4(record6)) continue;
+      if (!isPlainRecord5(record6)) continue;
       const id2 = record6.id;
       if (typeof id2 !== "string") continue;
       records2.set(baseKey(recordKind, id2), {
@@ -106626,7 +106691,7 @@ function collectSystemBearingBaseRecords(document) {
 }
 function assertCreateDeclaresNoSystemMetadata(write) {
   if (!isSystemBearingRecordKind(write.recordKind)) return;
-  if (!isPlainRecord4(write.nextData)) return;
+  if (!isPlainRecord5(write.nextData)) return;
   const system = readSystemMetadata(write.nextData);
   if (system === null) return;
   if (inheritsLegacyEmittedSystemMetadata(write, system)) return;
@@ -106652,11 +106717,11 @@ function assertProtectedRecordNotEdited(change, base) {
   )) {
     return;
   }
-  if (!isPlainRecord4(change.nextData)) return;
+  if (!isPlainRecord5(change.nextData)) return;
   if (authoredFieldsEqual(change.recordKind, base.data, change.nextData)) {
     return;
   }
-  if (isInheritedWorldDefaultEdit(change) && isPlainRecord4(change.inheritedBaseData) && change.inheritedBaseData.id === base.data.extendsMemberId && systemMetadataEqual(
+  if (isInheritedWorldDefaultEdit(change) && isPlainRecord5(change.inheritedBaseData) && change.inheritedBaseData.id === base.data.extendsMemberId && systemMetadataEqual(
     base.system,
     readSystemMetadata(change.inheritedBaseData)
   ))
@@ -106668,7 +106733,7 @@ function assertProtectedRecordNotEdited(change, base) {
 function isInheritedWorldDefaultEdit(write) {
   if (write.recordKind !== "member" || write.recordId.startsWith("system_"))
     return false;
-  if (write.deleted || !isPlainRecord4(write.baseData) || !isPlainRecord4(write.nextData))
+  if (write.deleted || !isPlainRecord5(write.baseData) || !isPlainRecord5(write.nextData))
     return false;
   if (readSystemMetadata(write.baseData)?.kind !== SystemProtectionKind.WorldAuthoring)
     return false;
@@ -106684,7 +106749,7 @@ function isInheritedWorldDefaultEdit(write) {
   );
 }
 function assertSystemMetadataUnchanged(change, base) {
-  if (!isPlainRecord4(change.nextData)) return;
+  if (!isPlainRecord5(change.nextData)) return;
   const next = readSystemMetadata(change.nextData);
   if (systemMetadataEqual(base.system, next)) return;
   throw new Error(
@@ -106735,10 +106800,10 @@ function repointedChildValueIds(document, change) {
   );
   if (baseValue === void 0) return [];
   const before = baseValue.value;
-  if (!isPlainRecord4(before)) return [];
-  if (!isPlainRecord4(change.nextData)) return [];
+  if (!isPlainRecord5(before)) return [];
+  if (!isPlainRecord5(change.nextData)) return [];
   const after = change.nextData.value;
-  if (!isPlainRecord4(after)) return [];
+  if (!isPlainRecord5(after)) return [];
   return Object.entries(before).flatMap(([schemaKey, childValueId2]) => {
     if (typeof childValueId2 !== "string") return [];
     if (after[schemaKey] === childValueId2) return [];
@@ -106773,7 +106838,7 @@ function isSystemBearingRecordKind(recordKind) {
   );
 }
 function readSystemMetadata(record6) {
-  if (!isPlainRecord4(record6)) return null;
+  if (!isPlainRecord5(record6)) return null;
   const system = record6.system;
   if (!isSystemMetadata(system)) return null;
   return system;
@@ -106792,11 +106857,11 @@ function systemReason(system) {
   return SYSTEM_PROTECTION_RULES[system.kind].serverReason;
 }
 function describeChangedRecord(recordKind, recordId, record6) {
-  const name = isPlainRecord4(record6) ? record6.name : void 0;
+  const name = isPlainRecord5(record6) ? record6.name : void 0;
   if (typeof name !== "string") return `Record ${recordKind} "${recordId}"`;
   return `Record ${recordKind} "${name}" (${recordId})`;
 }
-function isPlainRecord4(value) {
+function isPlainRecord5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function baseKey(recordKind, recordId) {
@@ -106927,7 +106992,7 @@ function readWorldReferenceList(args) {
     args.keyCandidates
   );
   if (schemaKey === null) return [];
-  if (!isPlainRecord5(args.ownerValue.value)) return [];
+  if (!isPlainRecord6(args.ownerValue.value)) return [];
   const listValueId = args.ownerValue.value[schemaKey];
   if (typeof listValueId !== "string") return [];
   const listValue2 = args.graph.valuesById.get(listValueId);
@@ -106993,18 +107058,18 @@ function worldReferenceClassInherits(graph, classId, ancestorClassId) {
   return false;
 }
 function toWorldReferenceClassRecord(value) {
-  if (!isPlainRecord5(value)) return null;
+  if (!isPlainRecord6(value)) return null;
   const id2 = stringField2(value, "id");
   if (id2 === null) return null;
   return {
     id: id2,
     extendsClassId: nullableStringField(value, "extendsClassId"),
     schema: isStringRecord8(value.schema) ? value.schema : void 0,
-    system: isPlainRecord5(value.system) ? value.system : null
+    system: isPlainRecord6(value.system) ? value.system : null
   };
 }
 function toWorldReferenceValueRecord(value) {
-  if (!isPlainRecord5(value)) return null;
+  if (!isPlainRecord6(value)) return null;
   const id2 = stringField2(value, "id");
   if (id2 === null) return null;
   return {
@@ -107018,10 +107083,10 @@ function worldReferenceValueClassId(value) {
   return typeof value.classId === "string" && value.classId.length > 0 ? value.classId : null;
 }
 function isStringRecord8(value) {
-  if (!isPlainRecord5(value)) return false;
+  if (!isPlainRecord6(value)) return false;
   return Object.values(value).every((entry) => typeof entry === "string");
 }
-function isPlainRecord5(value) {
+function isPlainRecord6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function stringField2(value, key) {
@@ -107603,7 +107668,7 @@ function stagedAffectedWorldLayerLinkClassIds(args) {
       change.nextData
     ];
     for (const candidate of candidates) {
-      if (!isPlainRecord2(candidate)) continue;
+      if (!isPlainRecord3(candidate)) continue;
       const relationKind = candidate.relationKind;
       if (typeof relationKind !== "string") continue;
       if (!isStagedWorldLayerLinkTargetRelationKind(relationKind)) continue;
@@ -107788,7 +107853,7 @@ function candidateActionListenerRowIds(projected, actions) {
   for (const row of projected.values) {
     if (storedRowActionListeners(row).length > 0) candidates.add(row.id);
     if (actionSchemaKeys.size === 0) continue;
-    if (!isPlainRecord2(row.value)) continue;
+    if (!isPlainRecord3(row.value)) continue;
     for (const schemaKey of actionSchemaKeys) {
       const childId = row.value[schemaKey];
       if (typeof childId === "string") candidates.add(childId);
@@ -107798,7 +107863,7 @@ function candidateActionListenerRowIds(projected, actions) {
 }
 function storedRowActionListeners(row) {
   const body = row.value;
-  if (!isPlainRecord2(body)) return [];
+  if (!isPlainRecord3(body)) return [];
   const listeners = body.listeners;
   return Array.isArray(listeners) ? listeners : [];
 }
@@ -107876,7 +107941,7 @@ function authoredActionListeners(action) {
   if (defaultValue === void 0 || defaultValue === null) return [];
   if (!isLiteralValueContent(defaultValue)) return [];
   const body = defaultValue.value;
-  if (!isPlainRecord2(body)) return [];
+  if (!isPlainRecord3(body)) return [];
   const listeners = body.listeners;
   return Array.isArray(listeners) ? listeners : [];
 }
@@ -108238,7 +108303,7 @@ function candidateVariantRowIds(projected, variantMembers) {
       candidates.add(row.id);
     }
     if (schemaKeys.size === 0) continue;
-    if (!isPlainRecord2(row.value)) continue;
+    if (!isPlainRecord3(row.value)) continue;
     for (const [schemaKey, childId] of Object.entries(row.value)) {
       if (schemaKeys.has(schemaKey) && typeof childId === "string")
         candidates.add(childId);
@@ -112872,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");
@@ -117420,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)
     });
@@ -117737,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");
@@ -118484,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: {
@@ -118532,7 +118602,6 @@ function computeWorkspaceStatus(workspace, options) {
     reconstructed: reconstructed3,
     authoredValueSeeds,
     pendingValueIdentitySites: valueLowerRegistry.pendingValueIdentitySites,
-    localInitializerMaterialization,
     binaryChanges,
     binaryFiles,
     initConversions: collectInitDefaultConversions(
@@ -119614,6 +119683,7 @@ function verifyProjectSourceCommitAgainstStateV4(args) {
   const status = computeWorkspaceStatus(workspace, {
     forceRecompile: args.forceRecompile,
     skipProjectBinaryInspection: true,
+    skipInitializerMaterialization: true,
     useBuildCaches: false,
     writeProjectAnalysisCache: () => void 0,
     trustedPendingProjectFiles,
@@ -119659,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(
@@ -119680,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;
@@ -120077,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) {
@@ -120211,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;
@@ -120223,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;
@@ -120295,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(
@@ -120355,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,
@@ -120721,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();
@@ -130461,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 })}`;
@@ -130577,27 +130657,6 @@ var init_convex = __esm({
   }
 });
 
-// ../convex/convexValues.ts
-function decodeConvexOpaqueJson(value, context) {
-  if (typeof value !== "string") {
-    throw new Error(`${context} must be an encoded JSON string.`);
-  }
-  try {
-    return JSON.parse(value);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw new Error(`${context} could not be parsed as JSON: ${message}`);
-  }
-}
-var CONVEX_DOCUMENT_WARNING_BYTES, CONVEX_DOCUMENT_MAX_BYTES;
-var init_convexValues = __esm({
-  "../convex/convexValues.ts"() {
-    "use strict";
-    CONVEX_DOCUMENT_WARNING_BYTES = 750 * 1024;
-    CONVEX_DOCUMENT_MAX_BYTES = 1024 * 1024;
-  }
-});
-
 // ../src/database/project-version-transaction-result.ts
 function decodeProjectVersionTransactionResultPage(page) {
   const assignments = {};
@@ -131959,7 +132018,7 @@ import {
   statSync
 } from "node:fs";
 import { join as join11, relative as relative6, sep as sep6 } from "node:path";
-function assignPendingIds(changes, authoredValueSeeds, reconstructed3, localInitializerMaterialization) {
+function assignPendingIds(changes, authoredValueSeeds, reconstructed3) {
   const assigned = /* @__PURE__ */ new Map();
   const assign = (pendingId2) => {
     const existing = assigned.get(pendingId2);
@@ -132034,9 +132093,6 @@ function assignPendingIds(changes, authoredValueSeeds, reconstructed3, localInit
       collect(record6.fullData);
     }
   }
-  if (localInitializerMaterialization !== void 0) {
-    collect(localInitializerMaterialization);
-  }
   const rewriteString = createIdentityRewriter(assigned);
   const rewrite = (value) => {
     if (assigned.size === 0) return value;
@@ -132146,16 +132202,7 @@ function assignPendingIds(changes, authoredValueSeeds, reconstructed3, localInit
       reconstructed3.set(key, record6);
     }
   }
-  const rewrittenLocalInitializerMaterialization = localInitializerMaterialization === void 0 ? void 0 : rewrite(
-    localInitializerMaterialization
-  );
-  return {
-    assigned,
-    authoredValueSeeds: rewrittenSeeds,
-    ...rewrittenLocalInitializerMaterialization === void 0 ? {} : {
-      localInitializerMaterialization: rewrittenLocalInitializerMaterialization
-    }
-  };
+  return { assigned, authoredValueSeeds: rewrittenSeeds };
 }
 function pendingInterfaceMemberSymbolOwner(value) {
   const marker = ":member:";
@@ -132171,11 +132218,14 @@ function pendingInterfaceMemberSymbolOwner(value) {
 }
 async function commitProjectVersionChanges(args) {
   const { workspace } = args;
-  const body = {
+  const body = clientPreparedCommitBody({
+    workspace,
     operation: args.operation,
-    changes: args.changes,
-    authoredValueSeeds: [],
-    initializerMaterialization: { roots: [] },
+    prepared: prepareClientPush({
+      workspace,
+      changes: args.changes,
+      authoredValueSeeds: []
+    }),
     stagedFiles: [],
     stagedUploadSessionId: null,
     // The asynchronous path keys reconnects on this identity; the rows name
@@ -132186,11 +132236,8 @@ async function commitProjectVersionChanges(args) {
       )
     ).digest("hex"),
     pendingIdAssignments: {},
-    summary: args.summary,
-    headTransactionHash: workspace.state.headTransactionHash ?? null,
-    derivedEdgeExtractorVersion: PROJECT_SNAPSHOT_DERIVED_EDGE_EXTRACTOR_VERSION,
-    forceRecompile: false
-  };
+    summary: args.summary
+  });
   const reporter = createPushProgressReporter(args.json, args.progressLabel);
   reporter.report({
     type: "project-transaction-progress",
@@ -132205,19 +132252,7 @@ async function commitProjectVersionChanges(args) {
   });
   try {
     const connection = await createConvexPushConnection(workspace);
-    let response;
-    try {
-      response = await connection.submit(body, false);
-    } catch (error) {
-      if (!(error instanceof NeoApiError) || error.status !== 413 || !isObjectRecord2(error.body) || error.body.error !== "schema-commit-route-required")
-        throw error;
-      response = await NeoApiClient.forBaseUrl(
-        workspace.config.apiBaseUrl
-      ).post(
-        `/api/projects/${workspace.config.projectId}/versions/${workspace.config.versionId}/schema/commit`,
-        body
-      );
-    }
+    const response = await connection.submit(body, false);
     const accepted = readAcceptedProjectVersionCommitResponse(response);
     if (accepted === null) {
       if (!isObjectRecord2(response) || typeof response.kind !== "string") {
@@ -132244,6 +132279,23 @@ async function commitProjectVersionChanges(args) {
     reporter.stop();
   }
 }
+function clientPreparedCommitBody(args) {
+  return {
+    operation: args.operation,
+    changes: args.prepared.changes,
+    basePayloadBytes: args.prepared.basePayloadBytes,
+    stagedFiles: args.stagedFiles,
+    stagedUploadSessionId: args.stagedUploadSessionId,
+    sourceHash: args.sourceHash,
+    pendingIdAssignments: args.pendingIdAssignments,
+    summary: args.summary,
+    // P43 §4. Preparation ran against the pulled snapshot, so the server
+    // refuses the push unless that snapshot is still the project head.
+    headTransactionHash: args.workspace.state.headTransactionHash ?? null,
+    derivedEdgeExtractorVersion: PROJECT_SNAPSHOT_DERIVED_EDGE_EXTRACTOR_VERSION,
+    compilerRevision: NEOSCRIPT_COMPILER_REVISION
+  };
+}
 function readAcceptedProjectVersionCommitResponse(value) {
   if (!isObjectRecord2(value) || value.kind !== "accepted") return null;
   if (typeof value.transactionId !== "string") {
@@ -132785,7 +132837,8 @@ async function preparePushStatus(workspace, options, onPhase = () => void 0) {
   onPhase("Analyzing working copy\u2026");
   const status = computeWorkspaceStatus2(workspace, {
     onPhase,
-    forceRecompile: options.forceRecompile
+    forceRecompile: options.forceRecompile,
+    skipInitializerMaterialization: true
   });
   if (status.conflictedFiles.length > 0) {
     throw new Error(
@@ -132823,11 +132876,6 @@ ${blockingErrors.map((error) => `  ${error.message}`).join("\n")}`
   }
   const blockedConversions = describeBlockingInitConversions(initConversions);
   if (blockedConversions !== null) throw new Error(blockedConversions);
-  if (!options.acceptBump && (workspace.state.headTransactionHash === void 0 || workspace.state.headTransactionHash === null)) {
-    throw new Error(
-      'This workspace has no recorded project head, so a push cannot be proven to be a fast-forward. Run "neo pull" first, or re-run with "neo push --accept-bump" to force the write.'
-    );
-  }
   prepareNSPropertySetterChanges(workspace, status);
   prepareNSFunctionBodyChanges(workspace, status);
   const needsNeoScriptCompilation = status.changes.some(
@@ -133106,41 +133154,24 @@ async function runPush(workspace, options, preparationOverride) {
     pendingAssignment,
     transactionOperation,
     client,
-    transportChanges,
-    transportSeeds,
+    clientPrepared,
     stagedUploadSessionId
   } = preparedPush;
   const { stagedFiles } = preparedPush;
   let pushConnection;
   const commit = async (force) => {
-    const body = {
+    const body = clientPreparedCommitBody({
+      workspace,
       operation: transactionOperation,
-      changes: transportChanges,
-      authoredValueSeeds: transportSeeds,
-      initializerMaterialization: pendingAssignment.localInitializerMaterialization ?? { roots: [] },
+      prepared: clientPrepared,
       stagedFiles,
       stagedUploadSessionId,
       sourceHash: source.sourceHash,
       pendingIdAssignments: Object.fromEntries(pendingAssignment.assigned),
-      summary: options.summary ?? "neo push",
-      // P43 §4. The local evaluator computes against the pulled snapshot, so
-      // the server rejects a push whose base is not the project head.
-      headTransactionHash: workspace.state.headTransactionHash ?? null,
-      derivedEdgeExtractorVersion: PROJECT_SNAPSHOT_DERIVED_EDGE_EXTRACTOR_VERSION,
-      forceRecompile: options.forceRecompile === true
-    };
+      summary: options.summary ?? "neo push"
+    });
     pushConnection ??= await createConvexPushConnection(workspace);
-    try {
-      return await pushConnection.submit(body, force);
-    } catch (error) {
-      if (!(error instanceof NeoApiError) || error.status !== 413 || !isObjectRecord2(error.body) || error.body.error !== "schema-commit-route-required")
-        throw error;
-    }
-    return await client.post(
-      `/api/projects/${workspace.config.projectId}/versions/${workspace.config.versionId}/schema/commit`,
-      body,
-      force ? { "x-neo-force-project-version-write": "true" } : void 0
-    );
+    return await pushConnection.submit(body, force);
   };
   const finishCommitResponse = async (response, reporter) => {
     let accepted;
@@ -133178,7 +133209,7 @@ async function runPush(workspace, options, preparationOverride) {
         errorMessage: null
       });
       reporter.stop();
-      reportAdditionalServerChanges(
+      reportDerivedChanges(
         committedChangeCount,
         status.changes.length,
         options.json === true
@@ -133266,7 +133297,7 @@ async function runPush(workspace, options, preparationOverride) {
       errorMessage: null
     });
     reporter.stop();
-    reportAdditionalServerChanges(
+    reportDerivedChanges(
       completed.totalChangeCount,
       status.changes.length,
       options.json === true
@@ -133368,7 +133399,7 @@ async function runPush(workspace, options, preparationOverride) {
   await finishCommitResponse(result, progress);
 }
 function isDefinitiveSchemaCommitRejection(error) {
-  return error.status === 400 || error.status === 401 || error.status === 403 || error.status === 404 || error.status === 409;
+  return error.status === 400 || error.status === 401 || error.status === 403 || error.status === 404 || error.status === 409 || error.status === 413;
 }
 async function prepareLocalPushArtifactsV4(workspace, status, onPhase = () => void 0, options = {
   fullValidation: true,
@@ -133387,22 +133418,11 @@ async function prepareLocalPushArtifactsV4(workspace, status, onPhase = () => vo
     status,
     status.authoredValueSeeds
   ) : null;
-  const pendingTransportChanges = transportChangesForStatus(status);
-  const pendingTransportSeeds = [...status.authoredValueSeeds].map(
-    ([memberId, seed]) => ({ memberId, ...seed })
-  );
-  const localInitializerMaterialization = status.localInitializerMaterialization ?? materializeInitializersLocallyV4({
-    workspace,
-    changes: pendingTransportChanges,
-    authoredValueSeeds: pendingTransportSeeds,
-    forceRecompile: options.forceRecompile
-  });
   onPhase("Assigning pending value identities\u2026");
   const pendingAssignment = assignPendingIds(
     status.changes,
     status.authoredValueSeeds,
-    status.reconstructed,
-    localInitializerMaterialization
+    status.reconstructed
   );
   const operations = new Set(status.changes.map((change) => change.kind));
   const transactionOperation = operations.size === 1 ? status.changes[0].kind : "update";
@@ -133416,11 +133436,11 @@ async function prepareLocalPushArtifactsV4(workspace, status, onPhase = () => vo
     binaryChanges: status.binaryChanges ?? [],
     assignedIds: pendingAssignment.assigned
   });
+  const stagedRecordIds = new Set(preparedFiles.map((file) => file.recordId));
   assertPushedRecordsPassDomainGuards(
     status.changes,
     localizedTextCreateEnvelopeConfig2(workspace, status.changes)
   );
-  let preparedChanges = null;
   if (verificationSource !== null) {
     onPhase("Verifying the assigned-id source rewrite\u2026");
     materializeAssignedSchemaIdsInAuthoredSource(
@@ -133437,36 +133457,47 @@ async function prepareLocalPushArtifactsV4(workspace, status, onPhase = () => vo
       files: verificationSource.files,
       changes: transportChanges,
       authoredValueSeeds: transportSeeds,
-      initializerMaterialization: pendingAssignment.localInitializerMaterialization ?? { roots: [] },
       forceRecompile: options.forceRecompile,
       pendingIdAssignments: Object.fromEntries(pendingAssignment.assigned),
       stagedFiles: preparedFiles
     });
-    onPhase(
-      `Rehearsing server validation for ${transportChanges.length.toLocaleString("en-US")} change(s)\u2026`
-    );
-    preparedChanges = assertServerPreparationSucceeds({
+  }
+  onPhase(
+    `Preparing ${transportChanges.length.toLocaleString("en-US")} change(s)\u2026`
+  );
+  const finishPreparation = startPerformanceSpan("client-preparation");
+  let prepared;
+  try {
+    prepared = prepareClientPush({
       workspace,
       changes: completeLocallyStagedProjectFileChanges({
         projectId: workspace.config.projectId,
         changes: transportChanges,
-        stagedRecordIds: new Set(preparedFiles.map((file) => file.recordId))
+        stagedRecordIds
       }),
       authoredValueSeeds: transportSeeds,
       sourceByRecord: status.reconstructed,
-      localInitializerMaterialization: pendingAssignment.localInitializerMaterialization,
       forceRecompile: options.forceRecompile
     });
+  } finally {
+    finishPreparation();
   }
   return {
     source,
     submittedStatus,
     pendingAssignment,
     transactionOperation,
-    transportChanges,
-    transportSeeds,
     preparedFiles,
-    preparedChanges
+    /** The prepared graph with local stand-ins for staged file storage. */
+    preparedChanges: prepared.changes,
+    clientPrepared: {
+      changes: restoreStagedProjectFileStorage(
+        prepared.changes,
+        transportChanges,
+        stagedRecordIds
+      ),
+      basePayloadBytes: prepared.basePayloadBytes
+    }
   };
 }
 async function prepareLocalCandidateV4(workspace, options = {}) {
@@ -133591,14 +133622,50 @@ function completeLocallyStagedProjectFileChanges(args) {
         ...change.nextData,
         id: change.recordId,
         projectId: args.projectId,
-        status: "uploaded",
-        storageKey: `local-candidate/${change.recordId}`,
-        storageETag: "local-candidate"
+        ...localStagedProjectFileStorage(change.recordId)
       }
     };
     return completed;
   });
 }
+function localStagedProjectFileStorage(recordId) {
+  return {
+    status: "uploaded",
+    storageKey: `local-candidate/${recordId}`,
+    storageETag: "local-candidate"
+  };
+}
+function restoreStagedProjectFileStorage(prepared, transportChanges, stagedRecordIds) {
+  if (stagedRecordIds.size === 0) return prepared;
+  const authoredById = /* @__PURE__ */ new Map();
+  for (const change of transportChanges) {
+    if (!stagedRecordIds.has(change.recordId)) continue;
+    if (change.nextData === void 0) {
+      throw new Error(
+        `Staged project file ${change.recordId} has no local source record.`
+      );
+    }
+    authoredById.set(change.recordId, change.nextData);
+  }
+  return prepared.map((change) => {
+    if (change.recordKind !== "project-file") return change;
+    const authored = authoredById.get(change.recordId);
+    if (authored === void 0) return change;
+    if (!isObjectRecord2(change.nextData)) {
+      throw new Error(
+        `Prepared staged project file ${change.recordId} has no record data.`
+      );
+    }
+    const nextData = { ...change.nextData };
+    for (const field of Object.keys(
+      localStagedProjectFileStorage(change.recordId)
+    )) {
+      if (authored[field] === void 0) delete nextData[field];
+      else nextData[field] = authored[field];
+    }
+    return { ...change, nextData };
+  });
+}
 function transportChangesForStatus(status) {
   return status.changes.map((change) => ({
     recordKind: change.recordKind,
@@ -133963,6 +134030,12 @@ function reportPushRejection(status, body) {
     );
     return;
   }
+  if (isObjectRecord2(body) && body.error === "schema-commit-too-large") {
+    console.error(
+      typeof body.bytes === "number" && typeof body.limitBytes === "number" ? `Push rejected: the prepared commit is ${body.bytes.toLocaleString("en-US")} bytes ${String(body.measure)}, over the ${body.limitBytes.toLocaleString("en-US")}-byte limit.` : "Push rejected: the prepared commit is over the server's body limit."
+    );
+    return;
+  }
   console.error(`Push rejected (${status}): ${JSON.stringify(body)}`);
 }
 function applyCommittedHeadTransactionHash(workspace, result) {
@@ -133998,11 +134071,11 @@ function immediateCommittedChangeCount(result) {
   }
   return result.changedRecords.length;
 }
-function reportAdditionalServerChanges(totalChangeCount, authoredChangeCount, json) {
+function reportDerivedChanges(totalChangeCount, authoredChangeCount, json) {
   if (json || totalChangeCount <= authoredChangeCount) return;
   console.log(
     color.dim(
-      `Server prepared ${totalChangeCount - authoredChangeCount} additional derived record change(s) (${totalChangeCount} total).`
+      `Push preparation added ${totalChangeCount - authoredChangeCount} derived record change(s) (${totalChangeCount} total).`
     )
   );
 }
@@ -135370,7 +135443,6 @@ var init_push = __esm({
     init_project_file_push();
     init_trusted_commit_verification();
     init_server_preparation_preflight();
-    init_local_initializer_materialization();
     init_initializer_replay();
     init_project_version_validation();
     init_project2();
@@ -140680,7 +140752,7 @@ var init_registry2 = __esm({
   "schema-contract/registry.mjs"() {
     "use strict";
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
-      cliVersion: "0.58.2",
+      cliVersion: "0.59.0",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -148395,7 +148467,7 @@ ${h("Usage")}
 
 ${h("Flags")}
   --dry-run         ${d("Preview the change set; commit nothing.")}
-  --force-recompile ${d("Exhaustively recompile every stored NeoScript body through the durable server path (parity/recovery; slower, and may surface unrelated invalid bodies).")}
+  --force-recompile ${d("Exhaustively recompile every stored NeoScript body during push preparation (parity/recovery; slower, and may surface unrelated invalid bodies).")}
   --summary <text>  ${d("Attach a summary message to the transaction.")}
   --accept-bump     ${d("Accept a server-required version bump instead of aborting.")}
   --json            ${d("Emit machine-readable plan and transaction progress events.")}
@@ -148501,7 +148573,7 @@ There is no --keep-current: preserving current semantic state defines flatten.
 async function main() {
   const args = parseArgs(process.argv.slice(2));
   if (args.command === "--version") {
-    console.log("0.58.2");
+    console.log("0.59.0");
     return;
   }
   if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {