@neocompose/cli 0.11.0 → 0.12.0

package/dist/neo.mjs

@@ -11837,12 +11837,13 @@ var init_project_source_parser = __esm({
 });
 
 // ../packages/neoscript-language/src/project-schema-contract.generated.ts
-var PROJECT_SCHEMA_MANIFEST_FORMAT_VERSION, PROJECT_SCHEMA_MANIFEST_CONTRACT_VERSION, NEO_PROJECT_SOURCE_RECORD_CONTRACT;
+var PROJECT_SCHEMA_MANIFEST_FORMAT_VERSION, PROJECT_SCHEMA_MANIFEST_CONTRACT_VERSION, PROJECT_FILE_UPLOAD_BATCH_SIZE, NEO_PROJECT_SOURCE_RECORD_CONTRACT;
 var init_project_schema_contract_generated = __esm({
   "../packages/neoscript-language/src/project-schema-contract.generated.ts"() {
     "use strict";
     PROJECT_SCHEMA_MANIFEST_FORMAT_VERSION = 3;
     PROJECT_SCHEMA_MANIFEST_CONTRACT_VERSION = "3.5";
+    PROJECT_FILE_UPLOAD_BATCH_SIZE = 32;
     NEO_PROJECT_SOURCE_RECORD_CONTRACT = {
       "recordFields": {
         "member": [
@@ -19507,8 +19508,8 @@ function memberSymbol(member, schemaKey, environment, field) {
     `${field}.source`
   );
   const overrideOf = nullableString(member.overrideOf, `${field}.overrideOf`);
-  const inheritedMember = overrideOf ? environment.members.get(overrideOf) : void 0;
-  const inheritedOwner = inheritedMember ? optionalRecord(inheritedMember.owner) : void 0;
+  const inheritedMember2 = overrideOf ? environment.members.get(overrideOf) : void 0;
+  const inheritedOwner = inheritedMember2 ? optionalRecord(inheritedMember2.owner) : void 0;
   const inheritedTypeId = inheritedOwner?.kind === "classMember" && typeof inheritedOwner.classId === "string" ? inheritedOwner.classId : void 0;
   const inheritedType = inheritedTypeId ? environment.classes.get(inheritedTypeId) : void 0;
   const common = {
@@ -29260,6 +29261,7 @@ function lowerFieldMember(context, ownerClass, declaration, id2, commonInput, ba
   const fieldType = partial ? requiredTypeArgument(declaration.type, 0) : declaration.type;
   const storedStatic = declaration.modifiers.includes("static") && !declaration.modifiers.includes("readonly");
   const settings = annotation(declaration.annotations, "settings");
+  const inherited = inheritedMember(context, commonInput.overrideOf);
   const storesSelectionArray = context.enumIdsByName.has(fieldType.name) || fieldType.name === "Dialogue" || Boolean(settings && argument(settings, "collection"));
   const common = {
     ...commonInput,
@@ -29291,11 +29293,12 @@ function lowerFieldMember(context, ownerClass, declaration, id2, commonInput, ba
     return { ...common, kind: name };
   }
   if (name === "int") {
+    const inheritedInt = inherited?.kind === "int" ? inherited : void 0;
     return {
       ...common,
       kind: "int",
-      min: numberArgument(settings, "min"),
-      max: numberArgument(settings, "max")
+      min: numberArgument(settings, "min") ?? inheritedInt?.min ?? null,
+      max: numberArgument(settings, "max") ?? inheritedInt?.max ?? null
     };
   }
   if (name === "string") {
@@ -29310,20 +29313,24 @@ function lowerFieldMember(context, ownerClass, declaration, id2, commonInput, ba
     const min = numberTextArgument(settings, "min");
     const max = numberTextArgument(settings, "max");
     if (name === "decimal") {
+      const inheritedDecimal = inherited?.kind === "decimal" ? inherited : void 0;
       return {
         ...common,
         kind: "decimal",
-        min,
-        max,
-        decimalPoints: numberArgument(settings, "decimalPoints")
+        min: min ?? inheritedDecimal?.min ?? null,
+        max: max ?? inheritedDecimal?.max ?? null,
+        decimalPoints: numberArgument(settings, "decimalPoints") ?? inheritedDecimal?.decimalPoints ?? null
       };
     }
+    const inheritedFloat = inherited?.kind === "float" ? inherited : void 0;
+    const numericMin = min === null ? null : Number(min);
+    const numericMax = max === null ? null : Number(max);
     return {
       ...common,
       kind: "float",
-      min: min === null ? null : Number(min),
-      max: max === null ? null : Number(max),
-      decimalPoints: numberArgument(settings, "decimalPoints")
+      min: numericMin ?? inheritedFloat?.min ?? null,
+      max: numericMax ?? inheritedFloat?.max ?? null,
+      decimalPoints: numberArgument(settings, "decimalPoints") ?? inheritedFloat?.decimalPoints ?? null
     };
   }
   const primitive3 = primitiveMemberKind(name);
@@ -29443,6 +29450,10 @@ function lowerFieldMember(context, ownerClass, declaration, id2, commonInput, ba
     `Unsupported field type ${JSON.stringify(name)} on ${ownerClass.name}.${declaration.name}.`
   );
 }
+function inheritedMember(context, memberId) {
+  if (memberId === null) return void 0;
+  return context.loweredMembers.get(memberId) ?? context.baseMembers.get(memberId);
+}
 function lowerListIndexes(ownerClass, declaration) {
   const declared = /* @__PURE__ */ new Set();
   return declaration.annotations.filter((entry) => entry.name === "index").map((entry) => {
@@ -36051,6 +36062,14 @@ var init_world_system_classes_generated = __esm({
             defaultValue: { x: 1, y: 1, z: 0 },
             required: true,
             schemaKey: "Size"
+          },
+          {
+            memberId: "system_4858148e-1c42-449d-8a03-c1601da529bd",
+            memberKind: "bool",
+            defaultValue: true,
+            docsText: "When false, this object and its children are neither rendered nor collided with. The value stays live: member writes still apply and a running animation clip keeps playing. Disabling an object hides its whole subtree regardless of each child's own value, and re-enabling it restores exactly what was there.",
+            required: true,
+            schemaKey: "Enabled"
           }
         ],
         worldKind: "objectBase"
@@ -47688,6 +47707,24 @@ function assertAnimationClipDocumentValid(document) {
     context.validateClipMember(member);
   }
 }
+function collectAnimationClipNestedOwnerWarnings(document) {
+  try {
+    return new AnimationValidationContext(
+      document
+    ).collectNestedOwnerWarnings();
+  } catch {
+    return [];
+  }
+}
+function compareNestedChildrenRowUseSites(left, right) {
+  if (left.ownerClassName !== right.ownerClassName) {
+    return left.ownerClassName < right.ownerClassName ? -1 : 1;
+  }
+  if (left.rowValueId !== right.rowValueId) {
+    return left.rowValueId < right.rowValueId ? -1 : 1;
+  }
+  return 0;
+}
 function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -48257,13 +48294,19 @@ var init_animation_clips = __esm({
         return typeof member.valueId === "string" ? this.valueById.get(member.valueId) ?? null : null;
       }
       memberRootNode(member) {
-        const value = member.defaultValue?.value;
+        const node = this.optionalMemberRootNode(member);
+        if (node === null) {
+          throw new Error(
+            `Animation clip "${member.name}" must have a composite default-value graph.`
+          );
+        }
+        return node;
+      }
+      /** {@link memberRootNode} without the throw, for diagnostics-only readers. */
+      optionalMemberRootNode(member) {
         if (member.defaultValue !== void 0) {
-          if (!isRecord3(value)) {
-            throw new Error(
-              `Animation clip "${member.name}" must have a composite default-value graph.`
-            );
-          }
+          const value = member.defaultValue.value;
+          if (!isRecord3(value)) return null;
           return {
             id: `member-default:${member.id}`,
             projectId: member.projectId,
@@ -48274,13 +48317,8 @@ var init_animation_clips = __esm({
           };
         }
         const valueId = member.valueId;
-        if (typeof valueId === "string") {
-          const stored = this.valueById.get(valueId);
-          if (stored !== void 0) return stored;
-        }
-        throw new Error(
-          `Animation clip "${member.name}" must have a composite default-value graph.`
-        );
+        if (typeof valueId !== "string") return null;
+        return this.valueById.get(valueId) ?? null;
       }
       optionalFieldNode(parent, classId, memberId) {
         const field = this.field(classId, memberId);
@@ -48304,35 +48342,45 @@ var init_animation_clips = __esm({
       }
       requireListField(parent, classId, memberId, label) {
         const field = this.requireField(classId, memberId, label);
+        const ids = this.listFieldIds(parent, field);
+        if (!Array.isArray(ids)) {
+          throw new Error(`${label} must be an ordered list.`);
+        }
+        const inferredClassId = this.listEntryClassId(field.member);
+        return ids.map((id2) => {
+          if (typeof id2 !== "string" || !this.valueById.has(id2)) {
+            throw new Error(`${label} references missing entry "${String(id2)}".`);
+          }
+          const entry = this.valueById.get(id2);
+          return typeof entry.classId === "string" || inferredClassId === void 0 ? entry : { ...entry, classId: inferredClassId };
+        });
+      }
+      /**
+       * The raw list payload behind a field: an explicit instance edge wins even
+       * when it is dangling, then the member default, then the legacy value row.
+       */
+      listFieldIds(parent, field) {
         const mapped = isRecord3(parent.value) ? parent.value[field.schemaKey] : null;
-        let ids;
         if (typeof mapped === "string") {
-          ids = this.valueById.get(mapped)?.value;
-        } else if (field.member.defaultValue !== void 0) {
-          ids = field.member.defaultValue.value;
-        } else {
-          ids = typeof field.member.valueId === "string" ? this.valueById.get(field.member.valueId)?.value : void 0;
+          return this.valueById.get(mapped)?.value;
         }
-        if (!Array.isArray(ids)) {
-          throw new Error(`${label} must be an ordered list.`);
+        if (field.member.defaultValue !== void 0) {
+          return field.member.defaultValue.value;
         }
+        return typeof field.member.valueId === "string" ? this.valueById.get(field.member.valueId)?.value : void 0;
+      }
+      /** Class a list's rows carry when a row omits its own `classId`. */
+      listEntryClassId(member) {
         const listMember = {
-          ...field.member,
-          ...resolveMember2(field.member, this.document.members)
+          ...member,
+          ...resolveMember2(member, this.document.members)
         };
         const entryMember = isMemberList(listMember) ? this.memberById.get(listMember.entryMemberId) : void 0;
         const resolvedEntryMember = entryMember === void 0 ? void 0 : {
           ...entryMember,
           ...resolveMember2(entryMember, this.document.members)
         };
-        const inferredClassId = isMemberClass(resolvedEntryMember) ? resolvedEntryMember.classId : void 0;
-        return ids.map((id2) => {
-          if (typeof id2 !== "string" || !this.valueById.has(id2)) {
-            throw new Error(`${label} references missing entry "${String(id2)}".`);
-          }
-          const entry = this.valueById.get(id2);
-          return typeof entry.classId === "string" || inferredClassId === void 0 ? entry : { ...entry, classId: inferredClassId };
-        });
+        return isMemberClass(resolvedEntryMember) ? resolvedEntryMember.classId : void 0;
       }
       requireSingleLookupField(parent, classId, memberId, label) {
         const value = this.scalarField(parent, classId, memberId);
@@ -48377,18 +48425,23 @@ var init_animation_clips = __esm({
         return node.classId;
       }
       requireClassBinding(member, paramId, label) {
+        const classId = this.optionalClassBinding(member, paramId);
+        if (classId === null) {
+          throw new Error(
+            `${label} must bind its target generic to a Class member.`
+          );
+        }
+        return classId;
+      }
+      /** {@link requireClassBinding} without the throw, for diagnostics-only readers. */
+      optionalClassBinding(member, paramId) {
         const binding = resolveInstanceEnv(
           member.classId,
           member.classArguments,
           this.document.classes
         ).get(paramId);
         const bindingMember = binding?.kind === "member" ? this.memberById.get(binding.memberId) : void 0;
-        if (!isMemberClass(bindingMember)) {
-          throw new Error(
-            `${label} must bind its target generic to a Class member.`
-          );
-        }
-        return bindingMember.classId;
+        return isMemberClass(bindingMember) ? bindingMember.classId : null;
       }
       requireClassMember(value) {
         if (!isMemberClass(value)) throw new Error("Expected Class member.");
@@ -48425,6 +48478,188 @@ var init_animation_clips = __esm({
         }
         return false;
       }
+      // ---------------------------------------------------------------------------
+      // P41 §2.3 SCAFFOLDING — DELETE EVERYTHING BELOW THIS BANNER WHEN P44 LANDS,
+      // together with `collectAnimationClipNestedOwnerWarnings` and its tests. See
+      // that function's doc block for why the check exists and why P44 retires it.
+      // ---------------------------------------------------------------------------
+      collectNestedOwnerWarnings() {
+        const useSiteByClassId = this.nestedChildrenRowUseSites();
+        if (useSiteByClassId.size === 0) return [];
+        const warnings = [];
+        for (const member of this.document.members) {
+          if (!isMemberClass(member)) continue;
+          if (!this.classHasWorldKind(member.classId, "animationClip")) continue;
+          const ownerClassId2 = this.optionalClassBinding(
+            member,
+            WORLD_ANIMATION_CLIP_TARGET_PARAM_ID
+          );
+          if (ownerClassId2 === null) continue;
+          const useSite = useSiteByClassId.get(ownerClassId2);
+          if (useSite === void 0) continue;
+          if (!this.clipDeclaresChildReferences(member)) continue;
+          const ownerClassName = this.classById.get(ownerClassId2)?.name ?? ownerClassId2;
+          const nestedRowClassName = this.classById.get(useSite.rowClassId)?.name ?? useSite.rowClassId;
+          const nesting = useSite.rowClassId === ownerClassId2 ? "which is also used as a nested Children row" : `whose subclass "${nestedRowClassName}" is used as a nested Children row`;
+          warnings.push({
+            clipName: member.name,
+            ownerClassName,
+            nestedOwnerClassName: useSite.ownerClassName,
+            nestedRowClassName,
+            nestedRowValueId: useSite.rowValueId,
+            message: `Animation clip "${member.name}" overrides or tracks children of "${ownerClassName}", ${nesting} (value "${useSite.rowValueId}" in class "${useSite.ownerClassName}"). A nested instance carries re-lowered copies of those rows, so the clip resolves none of them there. Give nested Children rows authored provenance (P44), or declare the child rows through a constructor (P43).`
+          });
+        }
+        return warnings;
+      }
+      /**
+       * Every class an authored `Children` list instantiates as a row, keyed by
+       * that class and each of its ancestors — a nested row of a subclass inherits
+       * the base class's clips, so the base is affected too.
+       *
+       * Both authoring shapes count. A class-default `Children` is one; a
+       * `Children` list authored on a row inside one is the other, and it is the
+       * shape P41 §3 itself writes — `CharacterBody.Children` holds a `HeadPart`
+       * row whose own `Children` holds the hat. Scanning only class defaults would
+       * miss every slot below the first level.
+       *
+       * A layer's directly placed objects hang off `NeoObjectLayerLink.Objects`, a
+       * different member, so a directly placed class is never collected here.
+       */
+      nestedChildrenRowUseSites() {
+        const declaringClasses = /* @__PURE__ */ new Map();
+        for (const schemaClass2 of this.document.classes) {
+          for (const [schemaKey, memberId] of Object.entries(schemaClass2.schema)) {
+            if (typeof memberId !== "string") continue;
+            if (declaringClasses.has(memberId)) continue;
+            declaringClasses.set(memberId, { schemaClass: schemaClass2, schemaKey });
+          }
+        }
+        const sites = [];
+        const pending = [];
+        for (const member of this.document.members) {
+          if (!this.memberDescendsFrom(member.id, WORLD_OBJECT_CHILDREN_MEMBER_ID)) {
+            continue;
+          }
+          const declaration = declaringClasses.get(member.id);
+          if (declaration === void 0) continue;
+          const node = this.resolveDefinitionChild(
+            null,
+            declaration.schemaKey,
+            member
+          );
+          pending.push(
+            ...this.childrenRowUseSites(node, member, declaration.schemaClass.name)
+          );
+        }
+        const visited = /* @__PURE__ */ new Set();
+        for (let index = 0; index < pending.length; index += 1) {
+          const site = pending[index];
+          if (site === void 0) continue;
+          if (visited.has(site.rowValueId)) continue;
+          visited.add(site.rowValueId);
+          sites.push(site);
+          const row = this.valueById.get(site.rowValueId);
+          if (row === void 0) continue;
+          const field = this.field(
+            site.rowClassId,
+            WORLD_OBJECT_CHILDREN_MEMBER_ID
+          );
+          if (field === null) continue;
+          const rowClassName = this.classById.get(site.rowClassId)?.name ?? site.rowClassId;
+          pending.push(
+            ...this.childrenRowUseSites(
+              { ...row, value: this.listFieldIds(row, field) },
+              field.member,
+              rowClassName
+            )
+          );
+        }
+        sites.sort(compareNestedChildrenRowUseSites);
+        const useSiteByClassId = /* @__PURE__ */ new Map();
+        for (const site of sites) {
+          if (useSiteByClassId.has(site.rowClassId)) continue;
+          useSiteByClassId.set(site.rowClassId, site);
+        }
+        for (const site of sites) {
+          for (const classId of this.classAndAncestorIds(site.rowClassId)) {
+            if (useSiteByClassId.has(classId)) continue;
+            useSiteByClassId.set(classId, site);
+          }
+        }
+        return useSiteByClassId;
+      }
+      /** The rows an authored `Children` list holds, as use sites of `ownerClassName`. */
+      childrenRowUseSites(node, listMember, ownerClassName) {
+        if (!Array.isArray(node?.value)) return [];
+        const entryClassId = this.listEntryClassId(listMember);
+        const sites = [];
+        for (const rowValueId of node.value) {
+          if (typeof rowValueId !== "string") continue;
+          const row = this.valueById.get(rowValueId);
+          const rowClassId = typeof row?.classId === "string" ? row.classId : entryClassId;
+          if (rowClassId === void 0) continue;
+          sites.push({ ownerClassName, rowValueId, rowClassId });
+        }
+        return sites;
+      }
+      /** True when the clip names at least one child through a track or override. */
+      clipDeclaresChildReferences(clipMember) {
+        const clipNode = this.optionalMemberRootNode(clipMember);
+        if (clipNode === null) return false;
+        const tracks = this.optionalListRows(
+          clipNode,
+          clipMember.classId,
+          WORLD_ANIMATION_CLIP_TRACKS_MEMBER_ID
+        );
+        if (tracks !== null && tracks.length > 0) return true;
+        const frames = this.optionalListRows(
+          clipNode,
+          clipMember.classId,
+          WORLD_ANIMATION_CLIP_FRAMES_MEMBER_ID
+        ) ?? [];
+        for (const frame of frames) {
+          if (typeof frame.classId !== "string") continue;
+          const childOverrides = this.optionalListRows(
+            frame,
+            frame.classId,
+            WORLD_ANIMATION_FRAME_CHILD_OVERRIDES_MEMBER_ID
+          );
+          if (childOverrides !== null && childOverrides.length > 0) return true;
+        }
+        return false;
+      }
+      /** {@link requireListField} without the throws, for diagnostics-only readers. */
+      optionalListRows(parent, classId, memberId) {
+        const field = this.field(classId, memberId);
+        if (field === null) return null;
+        const ids = this.listFieldIds(parent, field);
+        if (!Array.isArray(ids)) return null;
+        const inferredClassId = this.listEntryClassId(field.member);
+        const rows = [];
+        for (const id2 of ids) {
+          if (typeof id2 !== "string") return null;
+          const entry = this.valueById.get(id2);
+          if (entry === void 0) return null;
+          rows.push(
+            typeof entry.classId === "string" || inferredClassId === void 0 ? entry : { ...entry, classId: inferredClassId }
+          );
+        }
+        return rows;
+      }
+      /** The class itself followed by every ancestor it extends. */
+      classAndAncestorIds(classId) {
+        const ids = [];
+        const visited = /* @__PURE__ */ new Set();
+        let current = this.classById.get(classId);
+        if (current === void 0) return [classId];
+        while (current !== void 0 && !visited.has(current.id)) {
+          visited.add(current.id);
+          ids.push(current.id);
+          current = current.extendsClassId ? this.classById.get(current.extendsClassId) : void 0;
+        }
+        return ids;
+      }
     };
   }
 });
@@ -48703,6 +48938,7 @@ function compareWorkspacePaths(left, right) {
 function computeWorkspaceStatus(workspace, options = {}) {
   const conflictedFiles = [];
   const parseErrors = [];
+  const warnings = [];
   const migrationSources = [];
   const projectSources = [];
   const sourceEntries = options.virtualSourceFiles === void 0 ? listProjectSourceFilesV4(workspace.root).map((filePath) => ({
@@ -48732,6 +48968,7 @@ function computeWorkspaceStatus(workspace, options = {}) {
       changes: [],
       conflictedFiles,
       parseErrors,
+      warnings,
       reconstructed: /* @__PURE__ */ new Map(),
       staticValueSeeds: /* @__PURE__ */ new Map(),
       binaryChanges: [],
@@ -48780,6 +49017,7 @@ function computeWorkspaceStatus(workspace, options = {}) {
         changes: [],
         conflictedFiles,
         parseErrors,
+        warnings,
         reconstructed: /* @__PURE__ */ new Map(),
         staticValueSeeds,
         binaryChanges: [],
@@ -48804,6 +49042,7 @@ function computeWorkspaceStatus(workspace, options = {}) {
         changes: [],
         conflictedFiles,
         parseErrors,
+        warnings,
         reconstructed: /* @__PURE__ */ new Map(),
         staticValueSeeds,
         binaryChanges: [],
@@ -48851,6 +49090,7 @@ function computeWorkspaceStatus(workspace, options = {}) {
       changes: [],
       conflictedFiles,
       parseErrors,
+      warnings,
       reconstructed: /* @__PURE__ */ new Map(),
       staticValueSeeds: /* @__PURE__ */ new Map(),
       binaryChanges: [],
@@ -49067,15 +49307,16 @@ function computeWorkspaceStatus(workspace, options = {}) {
   )) {
     parseErrors.push(new SchemaSourceError(message, "<project-files>", 1, 1));
   }
+  let validatedAnimationRecords = null;
   try {
-    validateProspectiveAnimationRecordsV4(
-      prospectiveAnimationRecords(
-        workspace.state.records,
-        reconstructed3,
-        changes,
-        staticValueSeeds
-      )
+    const animationRecords = prospectiveAnimationRecords(
+      workspace.state.records,
+      reconstructed3,
+      changes,
+      staticValueSeeds
     );
+    validateProspectiveAnimationRecordsV4(animationRecords);
+    validatedAnimationRecords = animationRecords;
   } catch (error) {
     parseErrors.push(
       new SchemaSourceError(
@@ -49086,6 +49327,11 @@ function computeWorkspaceStatus(workspace, options = {}) {
       )
     );
   }
+  if (validatedAnimationRecords !== null) {
+    warnings.push(
+      ...collectProspectiveAnimationWarningsV4(validatedAnimationRecords)
+    );
+  }
   for (const binary of binaryChanges) {
     if (binary.action !== "missing-local") continue;
     parseErrors.push(
@@ -49101,6 +49347,7 @@ function computeWorkspaceStatus(workspace, options = {}) {
     changes,
     conflictedFiles,
     parseErrors,
+    warnings,
     reconstructed: reconstructed3,
     staticValueSeeds,
     binaryChanges,
@@ -49108,11 +49355,27 @@ function computeWorkspaceStatus(workspace, options = {}) {
   };
 }
 function validateProspectiveAnimationRecordsV4(records2) {
+  const document = prospectiveAnimationDocumentV4(records2);
+  if (document === null) return;
+  assertAnimationClipDocumentValid(document);
+}
+function collectProspectiveAnimationWarningsV4(records2) {
+  try {
+    const document = prospectiveAnimationDocumentV4(records2);
+    if (document === null) return [];
+    return collectAnimationClipNestedOwnerWarnings(document).map(
+      (warning) => warning.message
+    );
+  } catch {
+    return [];
+  }
+}
+function prospectiveAnimationDocumentV4(records2) {
   const candidates = [...records2];
   const hasAnimationSchema = candidates.some(
     (record3) => record3.recordKind === "class" && (Array.isArray(record3.data.constructorProjections) || isObjectRecord2(record3.data.system) && typeof record3.data.system.worldKind === "string" && record3.data.system.worldKind.startsWith("animation"))
   );
-  if (!hasAnimationSchema) return;
+  if (!hasAnimationSchema) return null;
   let project;
   const classes = [];
   const members = [];
@@ -49148,8 +49411,8 @@ function validateProspectiveAnimationRecordsV4(records2) {
       values.push(record3.data);
     }
   }
-  if (project === void 0) return;
-  assertAnimationClipDocumentValid({ project, classes, members, values });
+  if (project === void 0) return null;
+  return { project, classes, members, values };
 }
 function serverEnvelope(stored) {
   if (!isObjectRecord2(stored)) return {};
@@ -51477,7 +51740,7 @@ var init_http = __esm({
         }
         return new _NeoApiClient(apiBaseUrl, token);
       }
-      async post(path, body, headers) {
+      async post(path, body, headers, options = {}) {
         const url = new URL(path, this.apiBaseUrl).toString();
         const response = await fetch(url, {
           method: "POST",
@@ -51486,7 +51749,8 @@ var init_http = __esm({
             "Content-Type": "application/json",
             ...headers
           },
-          body: body === void 0 ? void 0 : JSON.stringify(body)
+          body: body === void 0 ? void 0 : JSON.stringify(body),
+          signal: options.signal
         });
         const text = await response.text();
         let parsed = null;
@@ -59572,13 +59836,13 @@ function ownedObjectChildMember(row, sourceMember, key, ctx) {
   return memberForCustomSchemaValue(classId, key, ctx);
 }
 function freshCloneValueId() {
-  const randomUUID6 = globalThis.crypto?.randomUUID;
-  if (randomUUID6 === void 0) {
+  const randomUUID7 = globalThis.crypto?.randomUUID;
+  if (randomUUID7 === void 0) {
     throw new NSGetterRuntimeError(
       "Class.Clone cannot mint a value id because crypto.randomUUID is unavailable."
     );
   }
-  return randomUUID6.call(globalThis.crypto);
+  return randomUUID7.call(globalThis.crypto);
 }
 function parseDialogueMemoryPointer(pointer) {
   if (typeof pointer !== "string") return null;
@@ -66504,80 +66768,154 @@ function ensureProjectFileBinaryChangesV4(args) {
     });
   }
 }
+function prepareProjectFilePushesV4(args) {
+  const prepared = [];
+  for (const binary of args.binaryChanges) {
+    if (binary.action !== "create" && binary.action !== "upload") continue;
+    const recordId = args.assignedIds.get(binary.fileId) ?? binary.fileId;
+    const change = args.changes.find(
+      (candidate) => candidate.recordKind === "project-file" && candidate.recordId === recordId
+    );
+    if (change === void 0) {
+      throw new Error(
+        `Project file ${recordId} has upload bytes but no source change.`
+      );
+    }
+    if (!isObjectRecord2(change.nextData)) {
+      throw new Error(
+        `Project file ${recordId} has upload bytes but its source change has no record data.`
+      );
+    }
+    const absolute = join14(args.workspace.root, binary.path);
+    const bytes = new Uint8Array(readFileSync12(absolute));
+    const digest = sha256Bytes(bytes);
+    if (binary.localSha256 !== null && digest !== binary.localSha256) {
+      throw new Error(
+        `Project file ${binary.path} changed after status was computed; run push again.`
+      );
+    }
+    const mimeType = binary.mimeType;
+    if (mimeType === null) {
+      throw new Error(`Project file ${binary.path} has no MIME type.`);
+    }
+    prepared.push({
+      uploadToken: `${recordId}-${prepared.length}`,
+      recordId,
+      replaceFileId: binary.action === "upload" ? recordId : null,
+      name: basename2(binary.path),
+      fileType: binary.kind,
+      mimeType,
+      byteLength: bytes.byteLength,
+      contentSha256: digest,
+      audioDurationSeconds: binary.kind === "audio" && typeof change.nextData.audioDurationSeconds === "number" ? change.nextData.audioDurationSeconds : null,
+      bytes
+    });
+  }
+  return prepared;
+}
 async function stageProjectFilePushesV4(args) {
+  const prepared = args.prepared ?? prepareProjectFilePushesV4({
+    workspace: args.workspace,
+    changes: args.changes,
+    binaryChanges: args.binaryChanges,
+    assignedIds: args.assignedIds
+  });
   const staged = [];
   const cleanupKeys = [];
   const put = args.put ?? fetch;
+  const interruptController = new AbortController();
+  const interrupt = () => interruptController.abort(new ProjectFilePushCancelledError());
+  process.once("SIGINT", interrupt);
+  const signal = combineSignals(args.signal, interruptController.signal);
+  const totalBytes = prepared.reduce((sum, file) => sum + file.byteLength, 0);
+  let completedBytes = 0;
+  let completedFiles = 0;
+  const report = () => args.onProgress?.({
+    completedFiles,
+    totalFiles: prepared.length,
+    completedBytes,
+    totalBytes
+  });
+  report();
   try {
-    for (const binary of args.binaryChanges) {
-      if (binary.action !== "create" && binary.action !== "upload") continue;
-      const recordId = args.assignedIds.get(binary.fileId) ?? binary.fileId;
-      const change = args.changes.find(
-        (candidate) => candidate.recordKind === "project-file" && candidate.recordId === recordId
+    for (let offset = 0; offset < prepared.length; offset += PROJECT_FILE_UPLOAD_BATCH_SIZE) {
+      const batch = prepared.slice(
+        offset,
+        offset + PROJECT_FILE_UPLOAD_BATCH_SIZE
       );
-      if (change === void 0 || !isObjectRecord2(change.nextData)) {
-        throw new Error(
-          `Project file ${recordId} has upload bytes but no source change.`
-        );
-      }
-      const absolute = join14(args.workspace.root, binary.path);
-      const bytes = new Uint8Array(readFileSync12(absolute));
-      const digest = sha256Bytes(bytes);
-      if (binary.localSha256 !== null && digest !== binary.localSha256) {
-        throw new Error(
-          `Project file ${binary.path} changed after status was computed; run push again.`
-        );
-      }
-      const mimeType = binary.mimeType;
-      if (mimeType === null) {
-        throw new Error(`Project file ${binary.path} has no MIME type.`);
-      }
-      const name = basename2(binary.path);
-      const replaceFileId = binary.action === "upload" ? recordId : null;
-      const presign = await args.client.post(
+      const presign = await postWithTimeout(
+        args.client,
         versionPath2(args.workspace, "upload"),
         {
           route: "projectFile",
           metadata: {
-            projectFileId: recordId,
-            replaceFileId,
-            contentSha256: digest,
-            deferredSourceCommit: true
+            deferredSourceCommit: true,
+            uploads: batch.map((file) => ({
+              uploadToken: file.uploadToken,
+              projectFileId: file.recordId,
+              replaceFileId: file.replaceFileId,
+              name: file.name,
+              contentSha256: file.contentSha256
+            }))
           },
-          files: [{ name, size: bytes.byteLength, type: mimeType }]
-        }
+          files: batch.map((file) => ({
+            name: file.uploadToken,
+            size: file.byteLength,
+            type: file.mimeType
+          }))
+        },
+        signal
       );
-      const entry = Array.isArray(presign.files) ? presign.files.find(isObjectRecord2) : void 0;
-      const fileInfo = isObjectRecord2(entry?.file) ? entry.file : {};
-      const objectInfo = isObjectRecord2(fileInfo.objectInfo) ? fileInfo.objectInfo : {};
-      if (typeof entry?.signedUrl !== "string" || typeof objectInfo.key !== "string") {
-        throw new Error("Upload presign response is missing signedUrl/key.");
+      const entries = readPresignEntries(presign, batch);
+      for (const entry of entries) cleanupKeys.push(entry.storageKey);
+      const batchController = new AbortController();
+      try {
+        await mapWithConcurrency(entries, UPLOAD_CONCURRENCY, async (entry) => {
+          try {
+            await putWithRetry(
+              put,
+              entry,
+              combineSignals(signal, batchController.signal)
+            );
+          } catch (error) {
+            batchController.abort(error);
+            throw error;
+          }
+          staged.push({
+            uploadToken: entry.file.uploadToken,
+            file: {
+              recordId: entry.file.recordId,
+              replaceFileId: entry.file.replaceFileId,
+              name: entry.file.name,
+              fileType: entry.file.fileType,
+              mimeType: entry.file.mimeType,
+              byteLength: entry.file.byteLength,
+              storageKey: entry.storageKey,
+              contentSha256: entry.file.contentSha256,
+              audioDurationSeconds: entry.file.audioDurationSeconds
+            }
+          });
+          completedFiles += 1;
+          completedBytes += entry.file.byteLength;
+          report();
+        });
+      } catch (error) {
+        batchController.abort(error);
+        throw error;
       }
-      cleanupKeys.push(objectInfo.key);
-      const headers = uploadHeaders(entry, objectInfo, mimeType);
-      const response = await put(entry.signedUrl, {
-        method: "PUT",
-        headers,
-        body: bytes
-      });
-      if (!response.ok) {
+    }
+    const byUploadToken = new Map(
+      staged.map((entry) => [entry.uploadToken, entry.file])
+    );
+    return prepared.map((file) => {
+      const result = byUploadToken.get(file.uploadToken);
+      if (result === void 0) {
         throw new Error(
-          `Storage PUT failed (${response.status}): ${await response.text()}`
+          `Uploaded project file ${file.name} (${file.uploadToken}) is missing from the staged result.`
         );
       }
-      staged.push({
-        recordId,
-        replaceFileId,
-        name,
-        fileType: binary.kind,
-        mimeType,
-        byteLength: bytes.byteLength,
-        storageKey: objectInfo.key,
-        contentSha256: digest,
-        audioDurationSeconds: binary.kind === "audio" && typeof change.nextData.audioDurationSeconds === "number" ? change.nextData.audioDurationSeconds : null
-      });
-    }
-    return staged;
+      return result;
+    });
   } catch (error) {
     if (cleanupKeys.length > 0) {
       try {
@@ -66588,8 +66926,145 @@ async function stageProjectFilePushesV4(args) {
       } catch {
       }
     }
+    if (interruptController.signal.aborted || args.signal?.aborted === true) {
+      throw new ProjectFilePushCancelledError();
+    }
     throw error;
+  } finally {
+    process.removeListener("SIGINT", interrupt);
+  }
+}
+function readPresignEntries(presign, batch) {
+  const entries = Array.isArray(presign.files) ? presign.files.filter(isObjectRecord2) : [];
+  return batch.map((file) => {
+    const entry = entries.find((candidate) => {
+      const info = isObjectRecord2(candidate.file) ? candidate.file : {};
+      return info.name === file.uploadToken;
+    });
+    const fileInfo = isObjectRecord2(entry?.file) ? entry.file : {};
+    const objectInfo = isObjectRecord2(fileInfo.objectInfo) ? fileInfo.objectInfo : {};
+    if (typeof entry?.signedUrl !== "string") {
+      throw new Error(
+        `Upload presign response is missing signedUrl for ${file.name}.`
+      );
+    }
+    if (typeof objectInfo.key !== "string") {
+      throw new Error(
+        `Upload presign response is missing a storage key for ${file.name}.`
+      );
+    }
+    return {
+      file,
+      signedUrl: entry.signedUrl,
+      storageKey: objectInfo.key,
+      headers: uploadHeaders(entry, objectInfo, file.mimeType)
+    };
+  });
+}
+async function postWithTimeout(client, path, body, signal) {
+  for (let attempt = 1; attempt <= PRESIGN_ATTEMPTS; attempt += 1) {
+    try {
+      return await client.post(path, body, void 0, {
+        signal: combineSignals(signal, AbortSignal.timeout(PRESIGN_TIMEOUT_MS))
+      });
+    } catch (error) {
+      if (signal.aborted || !isRetryableRequestError(error) || attempt === PRESIGN_ATTEMPTS) {
+        throw error;
+      }
+      await waitForRetry(attempt, signal);
+    }
+  }
+  throw new Error("Upload presign failed after all retry attempts.");
+}
+async function putWithRetry(put, entry, signal) {
+  let lastError;
+  for (let attempt = 1; attempt <= STORAGE_PUT_ATTEMPTS; attempt += 1) {
+    let response;
+    try {
+      response = await put(entry.signedUrl, {
+        method: "PUT",
+        headers: entry.headers,
+        body: Buffer.from(entry.file.bytes),
+        signal: combineSignals(
+          signal,
+          AbortSignal.timeout(STORAGE_PUT_TIMEOUT_MS)
+        )
+      });
+    } catch (error) {
+      if (signal.aborted || attempt === STORAGE_PUT_ATTEMPTS) throw error;
+      lastError = error;
+      await waitForRetry(attempt, signal);
+      continue;
+    }
+    if (response.ok) return;
+    if (isRetryableStatus(response.status) && attempt < STORAGE_PUT_ATTEMPTS) {
+      lastError = new Error(`Storage PUT failed (${response.status}).`);
+      await waitForRetry(attempt, signal);
+      continue;
+    }
+    throw new Error(
+      `Storage PUT failed (${response.status}): ${await response.text()}`
+    );
+  }
+  throw lastError instanceof Error ? lastError : new Error(`Storage PUT failed for ${entry.file.name}.`);
+}
+function isRetryableStatus(status) {
+  return status === 408 || status === 429 || status >= 500;
+}
+function isRetryableRequestError(error) {
+  if (isObjectRecord2(error) && typeof error.status === "number") {
+    return isRetryableStatus(error.status);
+  }
+  if (isObjectRecord2(error) && error.name === "TimeoutError") return true;
+  if (!(error instanceof TypeError) || error.message !== "fetch failed") {
+    return false;
+  }
+  if (!isObjectRecord2(error.cause) || typeof error.cause.code !== "string") {
+    return false;
   }
+  return RETRYABLE_NETWORK_ERROR_CODES.has(error.cause.code);
+}
+async function waitForRetry(attempt, signal) {
+  await new Promise((resolve4, reject) => {
+    const abort = () => {
+      clearTimeout(timeout);
+      reject(signal.reason);
+    };
+    const timeout = setTimeout(
+      () => {
+        signal.removeEventListener("abort", abort);
+        resolve4();
+      },
+      200 * 2 ** (attempt - 1)
+    );
+    signal.addEventListener("abort", abort, { once: true });
+  });
+}
+async function mapWithConcurrency(values, concurrency, run) {
+  let nextIndex = 0;
+  let firstError;
+  const worker = async () => {
+    while (firstError === void 0) {
+      const index = nextIndex;
+      nextIndex += 1;
+      if (index >= values.length) return;
+      try {
+        await run(values[index]);
+      } catch (error) {
+        firstError ??= error;
+      }
+    }
+  };
+  await Promise.all(
+    Array.from({ length: Math.min(concurrency, values.length) }, worker)
+  );
+  if (firstError !== void 0) throw firstError;
+}
+function combineSignals(...signals) {
+  const defined = signals.filter(
+    (signal) => signal !== void 0
+  );
+  return defined.length === 1 ? defined[0] : AbortSignal.any(defined);
 }
 function uploadHeaders(entry, objectInfo, mimeType) {
   const headers = { "Content-Type": mimeType };
@@ -66611,11 +67086,431 @@ function uploadHeaders(entry, objectInfo, mimeType) {
 function versionPath2(workspace, suffix) {
   return `/api/projects/${workspace.config.projectId}/versions/${workspace.config.versionId}/${suffix}`;
 }
+var UPLOAD_CONCURRENCY, PRESIGN_TIMEOUT_MS, PRESIGN_ATTEMPTS, STORAGE_PUT_TIMEOUT_MS, STORAGE_PUT_ATTEMPTS, ProjectFilePushCancelledError, RETRYABLE_NETWORK_ERROR_CODES;
 var init_project_file_push = __esm({
   "src/project-source/project-file-push.ts"() {
     "use strict";
     init_project_files();
     init_projection();
+    init_src();
+    UPLOAD_CONCURRENCY = 6;
+    PRESIGN_TIMEOUT_MS = 3e4;
+    PRESIGN_ATTEMPTS = 3;
+    STORAGE_PUT_TIMEOUT_MS = 12e4;
+    STORAGE_PUT_ATTEMPTS = 3;
+    ProjectFilePushCancelledError = class extends Error {
+      constructor() {
+        super("Project file upload was cancelled.");
+        this.name = "ProjectFilePushCancelledError";
+      }
+    };
+    RETRYABLE_NETWORK_ERROR_CODES = /* @__PURE__ */ new Set([
+      "ECONNRESET",
+      "ECONNREFUSED",
+      "EHOSTUNREACH",
+      "ENETUNREACH",
+      "ENOTFOUND",
+      "EPIPE",
+      "ETIMEDOUT"
+    ]);
+  }
+});
+
+// src/project-source/trusted-commit-verification.ts
+import { randomUUID as randomUUID5 } from "node:crypto";
+import { tmpdir } from "node:os";
+import { join as join15 } from "node:path";
+function verifyProjectSourceCommitAgainstStateV4(args) {
+  const root = join15(tmpdir(), `neo-source-verify-virtual-${randomUUID5()}`);
+  const workspace = {
+    root,
+    config: {
+      formatVersion: 4,
+      apiBaseUrl: "https://trusted-server.invalid",
+      projectId: args.projectId,
+      versionId: args.versionId,
+      profile: "editor"
+    },
+    state: { records: { ...args.stateRecords } }
+  };
+  const assignments = validateAssignments(args.pendingIdAssignments);
+  const pendingIdByAssignedId = new Map(
+    [...assignments].map(([pendingId2, assignedId]) => [assignedId, pendingId2])
+  );
+  const trustedPendingProjectFiles = /* @__PURE__ */ new Map();
+  const stagedRecordIds = /* @__PURE__ */ new Set();
+  for (const file of args.stagedFiles) {
+    if (stagedRecordIds.has(file.recordId)) {
+      throw new ProjectSourceCommitVerificationError(
+        "Source commit contains duplicate verified staged project files."
+      );
+    }
+    stagedRecordIds.add(file.recordId);
+    const metadata = {
+      mimeType: file.mimeType,
+      byteLength: file.byteLength,
+      sha256: file.contentSha256
+    };
+    trustedPendingProjectFiles.set(file.recordId, metadata);
+    const pendingId2 = pendingIdByAssignedId.get(file.recordId);
+    if (pendingId2 !== void 0) {
+      trustedPendingProjectFiles.set(pendingId2, metadata);
+    }
+  }
+  const status = computeWorkspaceStatus(workspace, {
+    skipProjectBinaryInspection: true,
+    writeProjectAnalysisCache: () => void 0,
+    trustedPendingProjectFiles,
+    virtualSourceFiles: args.files
+  });
+  const blockingErrors = status.parseErrors.filter(isBlockingSchemaSourceError);
+  if (status.conflictedFiles.length > 0 || blockingErrors.length > 0) {
+    const first = blockingErrors[0];
+    throw new ProjectSourceCommitVerificationError(
+      first ? `Trusted source lowering failed: ${first.file}:${first.line}:${first.column} ${first.message}` : `Trusted source lowering found conflict markers in ${status.conflictedFiles[0]}.`
+    );
+  }
+  const usedAssignments = /* @__PURE__ */ new Set();
+  const expectedChanges = status.changes.map((change) => {
+    const rewrittenData = change.nextData === void 0 ? void 0 : rewritePending(change.nextData, assignments, usedAssignments);
+    return {
+      recordKind: change.recordKind,
+      recordId: rewritePending(change.recordId, assignments, usedAssignments),
+      operation: change.kind,
+      // Source syntax does not author project ownership. The CLI stamps the
+      // authenticated project id on creates immediately before transport;
+      // reproduce that server-known field instead of comparing the
+      // lowerer's empty construction placeholder.
+      nextData: change.kind === "create" && isObjectRecord2(rewrittenData) ? { ...rewrittenData, projectId: args.projectId } : rewrittenData,
+      expectedBaseContentHash: change.kind === "create" ? null : change.casBaseHash ?? null
+    };
+  });
+  const expectedSeeds = [...status.staticValueSeeds].map(
+    ([memberId, seed]) => ({
+      memberId: rewritePending(memberId, assignments, usedAssignments),
+      value: rewritePending(seed.value, assignments, usedAssignments),
+      classId: seed.classId === null ? null : rewritePending(seed.classId, assignments, usedAssignments),
+      ...seed.valueId === void 0 ? {} : {
+        valueId: rewritePending(seed.valueId, assignments, usedAssignments)
+      },
+      ...seed.values === void 0 ? {} : {
+        values: rewritePending(seed.values, assignments, usedAssignments)
+      },
+      ...seed.bindingMembers === void 0 ? {} : {
+        bindingMembers: rewritePending(
+          seed.bindingMembers,
+          assignments,
+          usedAssignments
+        )
+      },
+      ...seed.localizedTexts === void 0 ? {} : {
+        localizedTexts: rewritePending(
+          seed.localizedTexts,
+          assignments,
+          usedAssignments
+        )
+      }
+    })
+  );
+  for (const pendingId2 of assignments.keys()) {
+    if (!usedAssignments.has(pendingId2)) {
+      throw new ProjectSourceCommitVerificationError(
+        `Pending id assignment ${pendingId2} is not present in the verified source manifest.`
+      );
+    }
+  }
+  compareChanges(expectedChanges, args.changes);
+  compareSeeds(expectedSeeds, args.staticValueSeeds);
+}
+function validateAssignments(value) {
+  const assignments = /* @__PURE__ */ new Map();
+  const assignedIds = /* @__PURE__ */ new Set();
+  for (const [pendingId2, assignedId] of Object.entries(value)) {
+    if (!pendingId2.startsWith("__pending__:")) {
+      throw new ProjectSourceCommitVerificationError(
+        `Pending id assignment key ${pendingId2} is not a pending identity.`
+      );
+    }
+    if (pendingMemberValueMemberId(pendingId2) === null) {
+      if (!/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/u.test(
+        assignedId
+      )) {
+        throw new ProjectSourceCommitVerificationError(
+          `Pending id assignment for ${pendingId2} is not a UUID v4.`
+        );
+      }
+    }
+    if (assignedIds.has(assignedId)) {
+      throw new ProjectSourceCommitVerificationError(
+        `Pending id assignments reuse durable id ${assignedId}.`
+      );
+    }
+    assignments.set(pendingId2, assignedId);
+    assignedIds.add(assignedId);
+  }
+  assertMemberValueAssignmentsAreDerived(assignments);
+  return assignments;
+}
+function assertMemberValueAssignmentsAreDerived(assignments) {
+  for (const [pendingId2, assignedId] of assignments) {
+    const memberLocator = pendingMemberValueMemberId(pendingId2);
+    if (memberLocator === null) continue;
+    const memberId = memberLocator.startsWith("__pending__:") ? assignments.get(memberLocator) : memberLocator;
+    if (memberId === void 0) {
+      throw new ProjectSourceCommitVerificationError(
+        `Member value assignment ${pendingId2} names member ${memberLocator}, which has no pending id assignment.`
+      );
+    }
+    const derived = derivedMemberValueId(memberId);
+    if (assignedId !== derived) {
+      throw new ProjectSourceCommitVerificationError(
+        `Member value assignment ${pendingId2} is ${assignedId}, but member ${memberId} owns value ${derived}.`
+      );
+    }
+  }
+}
+function positionIndependentPendingKey(pendingId2) {
+  const parts = pendingId2.split(":");
+  if (parts.length !== 6) return null;
+  const [prefix, kind, uri, line, character, label] = parts;
+  if (prefix !== "__pending__") return null;
+  if (!/^\d+$/u.test(line) || !/^\d+$/u.test(character)) return null;
+  return `${prefix}:${kind}:${uri}:${label}`;
+}
+function positionIndependentAssignments(assignments) {
+  const candidates = /* @__PURE__ */ new Map();
+  for (const pendingId2 of assignments.keys()) {
+    const key = positionIndependentPendingKey(pendingId2);
+    if (key === null) continue;
+    candidates.set(key, [...candidates.get(key) ?? [], pendingId2]);
+  }
+  const resolved = /* @__PURE__ */ new Map();
+  for (const [key, pendingIds] of candidates) {
+    if (pendingIds.length !== 1) continue;
+    resolved.set(key, pendingIds[0]);
+  }
+  return resolved;
+}
+function rewritePending(value, assignments, used, byPosition) {
+  const positionless = byPosition ?? positionIndependentAssignments(assignments);
+  if (typeof value === "string") {
+    const exact = assignments.get(value);
+    if (exact !== void 0) {
+      used.add(value);
+      return exact;
+    }
+    if (value.startsWith("__pending__:")) {
+      const key = positionIndependentPendingKey(value);
+      const relocated = key === null ? void 0 : positionless.get(key);
+      if (relocated !== void 0) {
+        used.add(relocated);
+        return assignments.get(relocated);
+      }
+      throw new ProjectSourceCommitVerificationError(
+        `Verified source identity ${value} has no pending id assignment.`
+      );
+    }
+    let rewritten = value;
+    for (const [pendingId2, assignedId] of assignments) {
+      if (!rewritten.includes(pendingId2)) continue;
+      rewritten = rewritten.replaceAll(pendingId2, assignedId);
+      used.add(pendingId2);
+    }
+    return rewritten;
+  }
+  if (Array.isArray(value)) {
+    return value.map(
+      (entry) => rewritePending(entry, assignments, used, positionless)
+    );
+  }
+  if (isObjectRecord2(value)) {
+    const result = {};
+    for (const [key, entry] of Object.entries(value)) {
+      const rewrittenKey = key.startsWith("__pending__:") ? rewritePending(key, assignments, used, positionless) : key;
+      result[rewrittenKey] = rewritePending(
+        entry,
+        assignments,
+        used,
+        positionless
+      );
+    }
+    return result;
+  }
+  return value;
+}
+function compareChanges(expected, received) {
+  const expectedByKey = new Map(
+    expected.map((change) => [
+      `${change.recordKind}:${change.recordId}`,
+      change
+    ])
+  );
+  const receivedByKey = new Map(
+    received.map((change) => [
+      `${change.recordKind}:${change.recordId}`,
+      change
+    ])
+  );
+  if (expectedByKey.size !== expected.length || receivedByKey.size !== received.length) {
+    throw new ProjectSourceCommitVerificationError(
+      "Source commit contains duplicate semantic record changes."
+    );
+  }
+  for (const [key, expectedChange] of expectedByKey) {
+    const actual = receivedByKey.get(key);
+    if (actual === void 0) {
+      throw new ProjectSourceCommitVerificationError(
+        `Source commit omitted semantic change ${key}.`
+      );
+    }
+    if (actual.operation !== expectedChange.operation || (actual.expectedBaseContentHash ?? null) !== expectedChange.expectedBaseContentHash) {
+      throw new ProjectSourceCommitVerificationError(
+        `Source commit changed operation or CAS base for ${key}.`
+      );
+    }
+    const expectedData = comparisonData(
+      expectedChange.recordKind,
+      expectedChange.nextData
+    );
+    const actualData = comparisonData(actual.recordKind, actual.nextData);
+    if (canonicalStringify(expectedData) !== canonicalStringify(actualData)) {
+      const difference = firstDifference(expectedData, actualData);
+      throw new ProjectSourceCommitVerificationError(
+        `Source commit nextData for ${key} does not match trusted lowering${difference === null ? "." : ` at ${difference.path}: trusted ${formatDifferenceValue(difference.trusted)}, submitted ${formatDifferenceValue(difference.submitted)}.`}`
+      );
+    }
+    if (!isObjectRecord2(actual.intent) || actual.intent.type !== `${actual.recordKind}.${actual.operation}`) {
+      throw new ProjectSourceCommitVerificationError(
+        `Source commit intent for ${key} does not match its semantic operation.`
+      );
+    }
+    receivedByKey.delete(key);
+  }
+  const extra = receivedByKey.keys().next().value;
+  if (extra !== void 0) {
+    throw new ProjectSourceCommitVerificationError(
+      `Source commit added semantic change ${extra} absent from trusted lowering.`
+    );
+  }
+}
+function firstDifference(trusted, submitted, path = "$") {
+  if (Object.is(trusted, submitted)) return null;
+  if (Array.isArray(trusted) && Array.isArray(submitted)) {
+    const count = Math.max(trusted.length, submitted.length);
+    for (let index = 0; index < count; index += 1) {
+      if (index >= trusted.length) {
+        return {
+          path: `${path}[${index}]`,
+          trusted: ABSENT_DIFFERENCE_VALUE,
+          submitted: submitted[index]
+        };
+      }
+      if (index >= submitted.length) {
+        return {
+          path: `${path}[${index}]`,
+          trusted: trusted[index],
+          submitted: ABSENT_DIFFERENCE_VALUE
+        };
+      }
+      const difference = firstDifference(
+        trusted[index],
+        submitted[index],
+        `${path}[${index}]`
+      );
+      if (difference !== null) return difference;
+    }
+  }
+  if (isObjectRecord2(trusted) && isObjectRecord2(submitted)) {
+    const keys = [
+      .../* @__PURE__ */ new Set([...Object.keys(trusted), ...Object.keys(submitted)])
+    ].sort();
+    for (const key of keys) {
+      const trustedHasKey = Object.hasOwn(trusted, key);
+      const submittedHasKey = Object.hasOwn(submitted, key);
+      const childPath = `${path}.${key}`;
+      if (!trustedHasKey || !submittedHasKey) {
+        return {
+          path: childPath,
+          trusted: trustedHasKey ? trusted[key] : ABSENT_DIFFERENCE_VALUE,
+          submitted: submittedHasKey ? submitted[key] : ABSENT_DIFFERENCE_VALUE
+        };
+      }
+      const difference = firstDifference(
+        trusted[key],
+        submitted[key],
+        childPath
+      );
+      if (difference !== null) return difference;
+    }
+  }
+  return { path, trusted, submitted };
+}
+function formatDifferenceValue(value) {
+  if (value === ABSENT_DIFFERENCE_VALUE) return "<absent>";
+  const serialized = JSON.stringify(value);
+  const rendered = serialized === void 0 ? String(value) : serialized;
+  return rendered.length <= 160 ? rendered : `${rendered.slice(0, 157)}...`;
+}
+function comparisonData(recordKind, value) {
+  if (!isObjectRecord2(value)) return value;
+  const result = { ...value };
+  delete result.createdAt;
+  delete result.updatedAt;
+  if (recordKind === "member") {
+    delete result.getter;
+    delete result.setter;
+    if (result.kind === 23) delete result.action;
+  }
+  if (recordKind === "migration") delete result.action;
+  return result;
+}
+function compareSeeds(expected, received) {
+  const normalize = (values) => values.map(normalizeSeedForComparison).sort((left, right) => {
+    if (left.memberId < right.memberId) return -1;
+    if (left.memberId > right.memberId) return 1;
+    return 0;
+  });
+  if (canonicalStringify(normalize(expected)) !== canonicalStringify(normalize(received))) {
+    throw new ProjectSourceCommitVerificationError(
+      "Source commit static value seeds do not match trusted lowering."
+    );
+  }
+}
+function normalizeSeedForComparison(seed) {
+  const normalized = { ...seed };
+  if (seed.values !== void 0) {
+    normalized.values = sortSeedRows(seed.values);
+  }
+  if (seed.bindingMembers !== void 0) {
+    normalized.bindingMembers = sortSeedRows(seed.bindingMembers);
+  }
+  if (seed.localizedTexts !== void 0) {
+    normalized.localizedTexts = sortSeedRows(seed.localizedTexts);
+  }
+  return normalized;
+}
+function sortSeedRows(values) {
+  return [...values].sort((left, right) => {
+    if (left.id < right.id) return -1;
+    if (left.id > right.id) return 1;
+    return 0;
+  });
+}
+var ProjectSourceCommitVerificationError, ABSENT_DIFFERENCE_VALUE;
+var init_trusted_commit_verification = __esm({
+  "src/project-source/trusted-commit-verification.ts"() {
+    "use strict";
+    init_workspace_status();
+    init_source_diagnostics();
+    init_projection();
+    init_member_value_id();
+    ProjectSourceCommitVerificationError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "ProjectSourceCommitVerificationError";
+      }
+    };
+    ABSENT_DIFFERENCE_VALUE = /* @__PURE__ */ Symbol("absent-difference-value");
   }
 });
 
@@ -66660,7 +67555,7 @@ __export(push_exports, {
   stripServerDerivedNeoScript: () => stripServerDerivedNeoScript,
   workspaceChangesRequireCompleteBodySweep: () => workspaceChangesRequireCompleteBodySweep
 });
-import { randomUUID as randomUUID5 } from "node:crypto";
+import { randomUUID as randomUUID6 } from "node:crypto";
 import {
   mkdirSync as mkdirSync11,
   writeFileSync as writeFileSync11,
@@ -66668,7 +67563,7 @@ import {
   existsSync as existsSync12,
   readFileSync as readFileSync13
 } from "node:fs";
-import { dirname as dirname7, join as join15, relative as relative5, sep as sep5 } from "node:path";
+import { dirname as dirname7, join as join16, relative as relative5, sep as sep5 } from "node:path";
 function assignPendingIds(changes, staticValueSeeds, reconstructed3) {
   const assigned = /* @__PURE__ */ new Map();
   const assign = (pendingId2) => {
@@ -66681,7 +67576,7 @@ function assignPendingIds(changes, staticValueSeeds, reconstructed3) {
       assigned.set(pendingId2, derived);
       return derived;
     }
-    const fresh = randomUUID5();
+    const fresh = randomUUID6();
     assigned.set(pendingId2, fresh);
     return fresh;
   };
@@ -66992,6 +67887,10 @@ function createPushProgressReporter(json) {
   };
 }
 function projectTransactionProgressLabel(event) {
+  if (event.type === "push-progress") {
+    if (event.phase === "preparing") return "Preparing push\u2026";
+    return `Uploading files\u2026 ${event.completedFiles.toLocaleString("en-US")}/${event.totalFiles.toLocaleString("en-US")} (${formatByteProgress(event.completedBytes)}/${formatByteProgress(event.totalBytes)})`;
+  }
   if (event.phase === "submitting") return "Pushing\u2026";
   if (event.phase === "preparing") return "Preparing push\u2026";
   if (event.phase === "waiting") return "Waiting to apply project transaction\u2026";
@@ -67009,6 +67908,11 @@ function projectTransactionProgressLabel(event) {
   }
   return "Finalizing project transaction\u2026";
 }
+function formatByteProgress(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KiB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MiB`;
+}
 function progressEventFromAccepted(accepted) {
   return {
     type: "project-transaction-progress",
@@ -67177,6 +68081,9 @@ ${blockingErrors.map((error) => `  ${error.message}`).join("\n")}`
     changes: status.changes,
     binaryChanges: status.binaryChanges ?? []
   });
+  if (options.json !== true) {
+    for (const message of status.warnings) warn(message);
+  }
   if (status.changes.length === 0) {
     if (options.json === true) {
       console.log(
@@ -67185,7 +68092,8 @@ ${blockingErrors.map((error) => `  ${error.message}`).join("\n")}`
           dryRun: options.dryRun,
           changeCount: 0,
           staticValueSeedCount: 0,
-          changes: []
+          changes: [],
+          warnings: status.warnings
         })
       );
     } else {
@@ -67247,7 +68155,8 @@ ${blockingErrors.map((error) => `  ${error.message}`).join("\n")}`
           kind: change.kind,
           recordKind: change.recordKind,
           recordId: change.recordId
-        }))
+        })),
+        warnings: status.warnings
       })
     );
   } else {
@@ -67281,46 +68190,111 @@ ${blockingErrors.map((error) => `  ${error.message}`).join("\n")}`
     console.log("Push cancelled.");
     return;
   }
-  const sourceBundle = await createPendingProjectSourceBundleV4(
-    workspace,
-    status,
-    status.staticValueSeeds
-  );
-  const pendingAssignment = assignPendingIds(
-    status.changes,
-    status.staticValueSeeds,
-    status.reconstructed
-  );
-  const operations = new Set(status.changes.map((change) => change.kind));
-  const transactionOperation = operations.size === 1 ? status.changes[0].kind : "update";
-  const client = NeoApiClient.forBaseUrl(workspace.config.apiBaseUrl);
-  let stagedFiles = await stageProjectFilePushesV4({
-    workspace,
-    changes: status.changes,
-    binaryChanges: status.binaryChanges ?? [],
-    assignedIds: pendingAssignment.assigned,
-    client
+  let progress = createPushProgressReporter(options.json === true);
+  progress.report({
+    type: "push-progress",
+    phase: "preparing",
+    completedFiles: 0,
+    totalFiles: status.binaryChanges?.length ?? 0,
+    completedBytes: 0,
+    totalBytes: 0
   });
+  const prepareAndStage = async () => {
+    const source2 = await createPendingProjectSourceBundleV4(
+      workspace,
+      status,
+      status.staticValueSeeds
+    );
+    const pendingAssignment2 = assignPendingIds(
+      status.changes,
+      status.staticValueSeeds,
+      status.reconstructed
+    );
+    const operations = new Set(status.changes.map((change) => change.kind));
+    const transactionOperation2 = operations.size === 1 ? status.changes[0].kind : "update";
+    const client2 = NeoApiClient.forBaseUrl(workspace.config.apiBaseUrl);
+    const transportChanges2 = status.changes.map((change) => ({
+      recordKind: change.recordKind,
+      recordId: change.recordId,
+      operation: change.kind,
+      nextData: change.kind === "delete" ? void 0 : stripServerDerivedNeoScript(change.nextData),
+      deleted: change.kind === "delete" ? true : void 0,
+      intent: createNeoCliPushIntent(change),
+      expectedBaseContentHash: change.kind === "create" ? null : change.casBaseHash ?? null
+    }));
+    const transportSeeds2 = [...pendingAssignment2.staticValueSeeds].map(
+      ([memberId, seed]) => ({ memberId, ...seed })
+    );
+    const files = prepareProjectFilePushesV4({
+      workspace,
+      changes: status.changes,
+      binaryChanges: status.binaryChanges ?? [],
+      assignedIds: pendingAssignment2.assigned
+    });
+    verifyProjectSourceCommitAgainstStateV4({
+      projectId: workspace.config.projectId,
+      versionId: workspace.config.versionId,
+      stateRecords: workspace.state.records,
+      files: source2.files,
+      changes: transportChanges2,
+      staticValueSeeds: transportSeeds2,
+      pendingIdAssignments: Object.fromEntries(pendingAssignment2.assigned),
+      stagedFiles: files
+    });
+    const stagedFiles2 = await stageProjectFilePushesV4({
+      workspace,
+      changes: status.changes,
+      binaryChanges: status.binaryChanges ?? [],
+      assignedIds: pendingAssignment2.assigned,
+      client: client2,
+      prepared: files,
+      onProgress: (upload) => progress.report({
+        type: "push-progress",
+        phase: "uploading",
+        ...upload
+      })
+    });
+    return {
+      source: source2,
+      pendingAssignment: pendingAssignment2,
+      transactionOperation: transactionOperation2,
+      client: client2,
+      transportChanges: transportChanges2,
+      transportSeeds: transportSeeds2,
+      preparedFiles: files,
+      stagedFiles: stagedFiles2
+    };
+  };
+  let preparedPush;
+  try {
+    preparedPush = await prepareAndStage();
+  } catch (error) {
+    progress.stop();
+    if (error instanceof ProjectFilePushCancelledError) {
+      if (options.json !== true) console.error("Push cancelled.");
+      process.exitCode = 130;
+      return;
+    }
+    throw error;
+  }
+  const {
+    source,
+    pendingAssignment,
+    transactionOperation,
+    client,
+    transportChanges,
+    transportSeeds,
+    preparedFiles
+  } = preparedPush;
+  let { stagedFiles } = preparedPush;
   const commit = async (force) => await client.post(
     `/api/projects/${workspace.config.projectId}/versions/${workspace.config.versionId}/schema/commit`,
     {
       operation: transactionOperation,
-      changes: status.changes.map((change) => {
-        return {
-          recordKind: change.recordKind,
-          recordId: change.recordId,
-          operation: change.kind,
-          nextData: change.kind === "delete" ? void 0 : stripServerDerivedNeoScript(change.nextData),
-          deleted: change.kind === "delete" ? true : void 0,
-          intent: createNeoCliPushIntent(change),
-          expectedBaseContentHash: change.kind === "create" ? null : change.casBaseHash ?? null
-        };
-      }),
-      staticValueSeeds: [...pendingAssignment.staticValueSeeds].map(
-        ([memberId, seed]) => ({ memberId, ...seed })
-      ),
+      changes: transportChanges,
+      staticValueSeeds: transportSeeds,
       stagedFiles,
-      sourceBundle,
+      sourceBundle: source.bundle,
       pendingIdAssignments: Object.fromEntries(pendingAssignment.assigned),
       summary: options.summary ?? "neo push"
     },
@@ -67434,7 +68408,6 @@ ${blockingErrors.map((error) => `  ${error.message}`).join("\n")}`
     if (options.json !== true) success("Push complete.");
     return true;
   };
-  let progress = createPushProgressReporter(options.json === true);
   progress.report({
     type: "project-transaction-progress",
     transactionId: null,
@@ -67467,28 +68440,39 @@ ${blockingErrors.map((error) => `  ${error.message}`).join("\n")}`
         fallback: false
       })) {
         progress = createPushProgressReporter(options.json === true);
-        progress.report({
-          type: "project-transaction-progress",
-          transactionId: null,
-          phase: "submitting",
-          totalChangeCount: status.changes.length,
-          appliedChangeCount: 0,
-          totalChunkCount: null,
-          appliedChunkCount: 0,
-          errorCode: null,
-          errorMessage: null
-        });
         try {
           stagedFiles = await stageProjectFilePushesV4({
             workspace,
             changes: status.changes,
             binaryChanges: status.binaryChanges ?? [],
             assignedIds: pendingAssignment.assigned,
-            client
+            client,
+            prepared: preparedFiles,
+            onProgress: (upload) => progress.report({
+              type: "push-progress",
+              phase: "uploading",
+              ...upload
+            })
+          });
+          progress.report({
+            type: "project-transaction-progress",
+            transactionId: null,
+            phase: "submitting",
+            totalChangeCount: status.changes.length,
+            appliedChangeCount: 0,
+            totalChunkCount: null,
+            appliedChunkCount: 0,
+            errorCode: null,
+            errorMessage: null
           });
           result = await commit(true);
         } catch (retryError) {
           progress.stop();
+          if (retryError instanceof ProjectFilePushCancelledError) {
+            if (options.json !== true) console.error("Push cancelled.");
+            process.exitCode = 130;
+            return;
+          }
           if (retryError instanceof NeoApiError) {
             reportPushRejection(retryError.status, retryError.body);
             process.exitCode = 1;
@@ -67617,17 +68601,19 @@ async function createPendingProjectSourceBundleV4(workspace, status, staticValue
     }
   }
   const emission = emitProjectDocumentFilesV4(records2);
-  return createProjectSourceBundle(
-    emission.files.map((file) => {
-      const kind = neoProjectSourceKind(file.path);
-      if (kind === null) {
-        throw new Error(
-          `Emitted project source bundle file ${JSON.stringify(file.path)} is not a recognized Neo source path.`
-        );
-      }
-      return { path: file.path, kind, content: file.content };
-    })
-  );
+  const files = emission.files.map((file) => {
+    const kind = neoProjectSourceKind(file.path);
+    if (kind === null) {
+      throw new Error(
+        `Emitted project source bundle file ${JSON.stringify(file.path)} is not a recognized Neo source path.`
+      );
+    }
+    return { path: file.path, kind, content: file.content };
+  });
+  return {
+    files,
+    bundle: await createProjectSourceBundle(files)
+  };
 }
 function staticSeedBindingMemberRecord(projectId, bindingMember, timestamp) {
   return {
@@ -68018,11 +69004,11 @@ ${finalErrors.map(
   for (const recordState of Object.values(workspace.state.records)) {
     const previousPath = recordState.file;
     if (previousPath === void 0 || emittedPaths.has(previousPath)) continue;
-    const absolute = join15(workspace.root, previousPath);
+    const absolute = join16(workspace.root, previousPath);
     if (existsSync12(absolute)) rmSync6(absolute);
   }
   for (const file of files) {
-    const absolute = join15(workspace.root, file.path);
+    const absolute = join16(workspace.root, file.path);
     mkdirSync11(dirname7(absolute), { recursive: true });
     const existing = existsSync12(absolute) ? readFileSync13(absolute, "utf8") : null;
     if (existing !== file.content)
@@ -68702,6 +69688,7 @@ var init_push = __esm({
     init_source_diagnostics();
     init_projection();
     init_project_file_push();
+    init_trusted_commit_verification();
     init_world_system_classes();
     init_project_manifest();
     init_merge();
@@ -68744,7 +69731,7 @@ __export(dev_exports, {
   runDev: () => runDev
 });
 import { watch } from "node:fs";
-import { join as join16 } from "node:path";
+import { join as join17 } from "node:path";
 import { emitKeypressEvents } from "node:readline";
 import { ConvexClient } from "convex/browser";
 function isSchemaSignal(value) {
@@ -68851,7 +69838,7 @@ async function runDev(workspace, options) {
   };
   for (const dir of ["Classes", "Enums"]) {
     try {
-      watch(join16(workspace.root, dir), { persistent: true }, onFileChange);
+      watch(join17(workspace.root, dir), { persistent: true }, onFileChange);
     } catch {
     }
   }
@@ -68907,7 +69894,7 @@ __export(resolve_exports, {
   workspaceFilePath: () => workspaceFilePath
 });
 import { readFileSync as readFileSync14, rmSync as rmSync7, writeFileSync as writeFileSync12 } from "node:fs";
-import { join as join17 } from "node:path";
+import { join as join18 } from "node:path";
 function runResolve(workspace, side) {
   let resolvedFiles = 0;
   for (const filePath of listProjectSourceFilesV4(workspace.root)) {
@@ -68922,12 +69909,12 @@ function runResolve(workspace, side) {
     const binary = state.projectBinary;
     const conflict2 = binary?.conflict;
     if (binary === void 0 || conflict2 === void 0) continue;
-    const destination = join17(workspace.root, binary.path);
+    const destination = join18(workspace.root, binary.path);
     if (side === "theirs") {
       if (conflict2.remoteSha256 !== null && conflict2.artifactPath !== void 0) {
         writeVerifiedBinaryDownloadV4(
           destination,
-          readFileSync14(join17(workspace.root, conflict2.artifactPath)),
+          readFileSync14(join18(workspace.root, conflict2.artifactPath)),
           conflict2.remoteSha256
         );
         binary.sha256 = conflict2.remoteSha256;
@@ -68937,7 +69924,7 @@ function runResolve(workspace, side) {
       }
     }
     if (conflict2.artifactPath !== void 0) {
-      rmSync7(join17(workspace.root, conflict2.artifactPath), { force: true });
+      rmSync7(join18(workspace.root, conflict2.artifactPath), { force: true });
     }
     delete binary.conflict;
     resolvedBinaries += 1;
@@ -68990,7 +69977,7 @@ function resolveMarkers(source, side) {
   return output.join("\n");
 }
 function workspaceFilePath(workspace, file) {
-  return join17(workspace.root, file);
+  return join18(workspace.root, file);
 }
 var init_resolve = __esm({
   "src/commands/resolve.ts"() {
@@ -69373,6 +70360,7 @@ function projectStatusJsonV4(status, options) {
       blocking: isBlockingSchemaSourceError(error),
       message: error.message
     })),
+    warnings: status.warnings,
     records: status.changes.map(
       (change) => recordChangeJsonV4(change, status, options)
     ),
@@ -70051,6 +71039,9 @@ async function main() {
       for (const error of status.parseErrors) {
         console.log(`${sym.warn} ${error.message}`);
       }
+      for (const message of status.warnings) {
+        console.log(`${sym.warn} ${message}`);
+      }
       for (const group of groupProjectStatusChangesV4(status)) {
         console.log(color.bold(group.source));
         for (const change of group.changes) {