@neocompose/cli 0.42.1 → 0.43.0

package/dist/neo.mjs

@@ -288,6 +288,11 @@ function readWorkspaceState(root, options = {}) {
   if (typeof state.records !== "object" || state.records === null) {
     throw new Error(`"${statePath}" is missing the "records" object.`);
   }
+  if (state.derivedEdgeVersion !== void 0 && state.derivedEdgeVersion !== null && (!Number.isSafeInteger(state.derivedEdgeVersion) || state.derivedEdgeVersion < 0)) {
+    throw new Error(
+      `"${statePath}" field "derivedEdgeVersion" must be a non-negative safe integer or null.`
+    );
+  }
   for (const [key, value] of Object.entries(state.records)) {
     if (typeof value !== "object" || value === null) {
       throw new Error(
@@ -48107,6 +48112,31 @@ function worldAnimationChildOverrideBindingMember(projectId, classId) {
     updatedAt: 0
   };
 }
+function animationFamilyClassKinds(classes) {
+  const classesById2 = new Map(classes.map((entry) => [entry.id, entry]));
+  const resolved = /* @__PURE__ */ new Map();
+  const resolve5 = (classId, visiting) => {
+    const cached = resolved.get(classId);
+    if (cached !== void 0) return cached;
+    if (visiting.has(classId)) return null;
+    const schemaClass2 = classesById2.get(classId);
+    if (schemaClass2 === void 0) return null;
+    const worldKind = schemaClass2.system?.worldKind;
+    if (typeof worldKind === "string" && WORLD_SYSTEM_ANIMATION_KINDS.has(worldKind)) {
+      resolved.set(classId, worldKind);
+      return worldKind;
+    }
+    const result = typeof schemaClass2.extendsClassId === "string" ? resolve5(schemaClass2.extendsClassId, new Set(visiting).add(classId)) : null;
+    resolved.set(classId, result);
+    return result;
+  };
+  const family = /* @__PURE__ */ new Map();
+  for (const classId of classesById2.keys()) {
+    const worldKind = resolve5(classId, /* @__PURE__ */ new Set());
+    if (worldKind !== null) family.set(classId, worldKind);
+  }
+  return family;
+}
 var WORLD_ANIMATION_CHILD_OVERRIDE_BINDING_MEMBER_NAME, WORLD_ANIMATION_CHILD_OVERRIDE_BINDING_MEMBER_NAMESPACE, WORLD_SYSTEM_CLASS_DEFINITION_BY_KIND, WORLD_SYSTEM_ANIMATION_KIND_MARKER, WORLD_SYSTEM_ANIMATION_KINDS, GENERIC_WORLD_SYSTEM_CLASS_KINDS, WORLD_SYSTEM_ALL_KINDS, WORLD_SYSTEM_SCHEMA_FIELD_SITES_BY_MEMBER_ID;
 var init_world_system_classes = __esm({
   "../src/models/classes/world-system-classes.ts"() {
@@ -49665,6 +49695,51 @@ function decodePackedValueRow(row) {
     packedChildIdsByParentId: state.edges
   };
 }
+function packedValuePositions(row) {
+  if (!rowCarriesPackedValueContent(row)) return NO_POSITIONS;
+  const positions = [];
+  collectPackedPositions(row, {
+    ownerLabel: `value "${row.id}"`,
+    constructionRootId: isCollapseStampedInstanceRoot(row) ? row.id : null,
+    path: [],
+    positions
+  });
+  return positions;
+}
+function collectPackedPositions(content, scope) {
+  collectPackedContainerPositions(content.value, "value", scope);
+  collectPackedContainerPositions(
+    content.constructorArgs,
+    "constructorArgs",
+    scope
+  );
+}
+function collectPackedContainerPositions(container, field, scope) {
+  if (!containerHoldsPackedEntry(container)) return;
+  const entries = Array.isArray(
+    container
+  ) ? container.map((entry, index) => [String(index), entry]) : Object.entries(container);
+  for (const [key, candidate] of entries) {
+    if (!isPackedValueEnvelope(candidate)) continue;
+    const label = `Packed value entry at ${scope.ownerLabel}.${field}[${JSON.stringify(key)}]`;
+    const entry = candidate[PACKED_VALUE_ENTRY_KEY];
+    assertDecodableEntry(entry, label);
+    const valueId = packedEntryLogicalId(
+      entry,
+      label,
+      scope.constructionRootId
+    );
+    const path = [...scope.path, field, key];
+    scope.positions.push({ valueId, path, entry });
+    if (isInitValueContent(entry)) continue;
+    collectPackedPositions(entry, {
+      ownerLabel: `packed value "${valueId}"`,
+      constructionRootId: isCollapseStampedInstanceRoot(entry) ? valueId : scope.constructionRootId,
+      path,
+      positions: scope.positions
+    });
+  }
+}
 function encodePackedValueRow(args) {
   const scope = {
     parent: args.parent,
@@ -49984,7 +50059,7 @@ function registerEdge(edges, ownerId, childId) {
   if (existing === void 0) edges.set(ownerId, [childId]);
   else existing.push(childId);
 }
-var PACKED_VALUE_ENTRY_KEY, PackedValueEncodingError, NO_CHILDREN, NO_EDGES, PACKED_ENTRY_FORBIDDEN_FIELDS;
+var PACKED_VALUE_ENTRY_KEY, PackedValueEncodingError, NO_CHILDREN, NO_EDGES, NO_POSITIONS, PACKED_ENTRY_FORBIDDEN_FIELDS;
 var init_packed_value_encoding = __esm({
   "../src/models/members/packed-value-encoding.ts"() {
     "use strict";
@@ -50000,6 +50075,7 @@ var init_packed_value_encoding = __esm({
     };
     NO_CHILDREN = [];
     NO_EDGES = /* @__PURE__ */ new Map();
+    NO_POSITIONS = [];
     PACKED_ENTRY_FORBIDDEN_FIELDS = [
       "projectId",
       "containerId",
@@ -77995,13 +78071,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;
@@ -81322,6 +81398,8 @@ var init_init_backed_value_materialization = __esm({
 function materializeDialogues(dialogueRecords, dialogueNodes) {
   return dialogueRecords.map((dialogue) => {
     if (!isRecordWithStringId(dialogue)) return dialogue;
+    const { triggerNodeId: _triggerNodeId, ...dialoguePayload } = dialogue;
+    void _triggerNodeId;
     const nodes = dialogueNodes.filter(
       (node) => getDialogueNodeDialogueId(node) === dialogue.id
     );
@@ -81334,7 +81412,7 @@ function materializeDialogues(dialogueRecords, dialogueNodes) {
       })
     );
     const materializedDialogue = {
-      ...dialogue,
+      ...dialoguePayload,
       nodes: bodyNodes,
       triggerNode: triggerNode === null || triggerNode === void 0 ? null : toDialogueNodePayload(triggerNode)
     };
@@ -81560,10 +81638,12 @@ __export(project_document_read_exports, {
   readOptionalArrayField: () => readOptionalArrayField,
   readProjectDocument: () => readProjectDocument,
   readProjectDocumentContentHashHeads: () => readProjectDocumentContentHashHeads,
+  readProjectDocumentManifestPage: () => readProjectDocumentManifestPage,
   readProjectDocumentManifestPageRecords: () => readProjectDocumentManifestPageRecords,
   readProjectDocumentManifestRecords: () => readProjectDocumentManifestRecords,
   readProjectDocumentRevisionMarker: () => readProjectDocumentRevisionMarker,
-  readStoredMembersField: () => readStoredMembersField
+  readStoredMembersField: () => readStoredMembersField,
+  withStoredValueBase: () => withStoredValueBase
 });
 async function fetchProjectDocumentRawChunked(runner, options = {}) {
   const mapKeys = options.mapKeys ?? [
@@ -82015,6 +82095,9 @@ function projectDocumentValueBuckets(rows) {
   if (expanded === rows) return { values: rows };
   return { values: [...expanded], physicalValues: rows };
 }
+function withStoredValueBase(document) {
+  return document.physicalValues === void 0 ? { ...document, physicalValues: document.values } : document;
+}
 function readProjectDocument(value, options = {}) {
   if (!isObject4(value)) {
     throw new Error("Convex project document query returned a non-object.");
@@ -86414,11 +86497,12 @@ function isWorldAnimationStructuralMember(memberId, members) {
   }
   return false;
 }
-function assertAnimationClipDocumentValid(document) {
+function assertAnimationClipDocumentValid(document, scope) {
   const context = new AnimationValidationContext(document);
-  context.validateSegments();
+  context.validateSegments(scope);
   for (const member of document.members) {
     if (!isMemberClass(member)) continue;
+    if (scope !== void 0 && !scope.memberIds.has(member.id)) continue;
     if (!context.classHasWorldKind(member.classId, "animationClip")) continue;
     if (isAbstractMember(member) === true) continue;
     context.validateClipMember(member);
@@ -87034,10 +87118,11 @@ var init_animation_clips = __esm({
        * files, and Session all hold segments, and a Session-stored `Duration` a
        * game writes at runtime is a feature, not drift.
        */
-      validateSegments() {
+      validateSegments(scope) {
         const visited = /* @__PURE__ */ new Set();
         for (const member of this.document.members) {
           if (!isMemberClass(member)) continue;
+          if (scope !== void 0 && !scope.memberIds.has(member.id)) continue;
           if (!this.classHasWorldKind(member.classId, "animationSegment")) continue;
           const node = this.optionalMemberRootNode(member);
           if (node === null) continue;
@@ -88847,44 +88932,61 @@ function transactionImpactsAnyOwnerMember(scope, impactedIds) {
   }
   return false;
 }
-function collectNeoScriptRecompileTargets(args) {
-  if (args.forceRecompile === true) return completeTargets(args.postDocument);
-  const explicit = explicitTargetIds(args.changes);
-  const {
-    impactedIds,
-    changedValueIds,
-    impactedTypeNames,
-    constructedClassIds
-  } = collectChangedContractIds(args);
-  for (const id2 of args.additionalImpactedIds ?? []) impactedIds.add(id2);
+function collectNeoScriptRecompileImpact(args) {
+  const impact = collectChangedContractIds(args);
+  for (const id2 of args.additionalImpactedIds ?? []) impact.impactedIds.add(id2);
   for (const id2 of args.additionalChangedValueIds ?? []) {
-    changedValueIds.add(id2);
-    explicit.valueIds.add(id2);
+    impact.changedValueIds.add(id2);
   }
   includeDerivedConstructionContracts(
-    constructedClassIds,
+    impact.constructedClassIds,
     args.postDocument.classes
   );
-  const schemaRecords = [
+  const dependentsById = /* @__PURE__ */ new Map();
+  for (const record3 of [
     ...collectSchemaDependencyRecords(args.postDocument),
     ...collectStructuralDependencyRecords(args.postDocument)
-  ];
-  const dependentsById = /* @__PURE__ */ new Map();
-  for (const record3 of schemaRecords) {
+  ]) {
     for (const dependencyId of collectCompilerReferenceIds(record3.value)) {
       const dependents = dependentsById.get(dependencyId) ?? [];
       dependents.push(record3);
       dependentsById.set(dependencyId, dependents);
     }
   }
-  const queue = [...impactedIds, ...changedValueIds];
+  const queue = [...impact.impactedIds, ...impact.changedValueIds];
   for (let index = 0; index < queue.length; index += 1) {
     const dependencyId = queue[index];
     if (dependencyId === void 0) continue;
     for (const dependent of dependentsById.get(dependencyId) ?? []) {
-      addImpactedId(impactedIds, queue, dependent.id);
+      addImpactedId(impact.impactedIds, queue, dependent.id);
     }
   }
+  return impact;
+}
+function collectNeoScriptRecompileReferenceTargets(args) {
+  const impact = collectNeoScriptRecompileImpact(args);
+  return {
+    ids: /* @__PURE__ */ new Set([
+      ...impact.impactedIds,
+      ...impact.changedValueIds,
+      ...impact.constructedClassIds
+    ]),
+    names: impact.impactedTypeNames
+  };
+}
+function collectNeoScriptRecompileTargets(args) {
+  if (args.forceRecompile === true) return completeTargets(args.postDocument);
+  const explicit = explicitTargetIds(args.changes);
+  const {
+    impactedIds,
+    changedValueIds,
+    impactedTypeNames,
+    constructedClassIds
+  } = collectNeoScriptRecompileImpact(args);
+  for (const id2 of args.additionalChangedValueIds ?? []) {
+    changedValueIds.add(id2);
+    explicit.valueIds.add(id2);
+  }
   const constructorOwnerById = constructorOwners(args.postDocument);
   const gradesSourceOnlyBodies = impactedIds.size > 0 || impactedTypeNames.size > 0;
   const impactScope = {
@@ -89026,7 +89128,9 @@ function collectCompilerReferenceNamesInto(value, field, names) {
   }
 }
 function isCompilerReferenceField(field) {
-  return /(?:member|class|enum|interface|constructor)(?:Type)?Ids?$/i.test(field) || field === "baseTypeIds" || field === "collectionValueId" || field === "fileId" || field === "primaryLinkedValueId" || field === "recordIds" || field === "valueId";
+  return /(?:member|class|enum|interface|constructor|variant)(?:Type)?Ids?$/i.test(
+    field
+  ) || field === "baseTypeIds" || field === "collectionValueId" || field === "fileId" || field === "primaryLinkedValueId" || field === "recordIds" || field === "valueId";
 }
 function collectChangedContractIds(args) {
   const impactedIds = /* @__PURE__ */ new Set();
@@ -89556,7 +89660,7 @@ function withoutFields(value, ignored) {
     Object.entries(value).filter(([field]) => !ignored.has(field))
   );
 }
-var NON_CONTRACT_MEMBER_FIELDS, NS_PROPERTY_BODY_FIELDS, NS_FUNCTION_BODY_FIELDS;
+var NON_CONTRACT_MEMBER_FIELDS, NS_PROPERTY_BODY_FIELDS, NS_FUNCTION_BODY_FIELDS, collectCompiledClassIds;
 var init_neo_script_recompile_scope = __esm({
   "../src/database/neo-script-recompile-scope.ts"() {
     "use strict";
@@ -89596,6 +89700,7 @@ var init_neo_script_recompile_scope = __esm({
       "bodyMode",
       "uiAction"
     ]);
+    collectCompiledClassIds = collectConstructedClassIds;
   }
 });
 
@@ -97524,7 +97629,7 @@ function reconcileDirectOverrideChains(args) {
     }
   }
 }
-function prepareServerOwnedSchemaCommit(args) {
+function* prepareServerOwnedSchemaCommitPasses(args) {
   if (args.forceRecompile === true) clearNeoScriptBodyCompileCache();
   assertUniqueChanges(args.changes);
   let authoredChanges = completeLocalizedTextCreateEnvelopes({
@@ -97542,7 +97647,8 @@ function prepareServerOwnedSchemaCommit(args) {
       args.document,
       authoredChanges
     ),
-    changes: authoredChanges
+    changes: authoredChanges,
+    createTextId: args.createLocalizedTextId
   });
   const explicitlyChangedMemberIds = /* @__PURE__ */ new Set();
   for (const change of authoredChanges) {
@@ -97572,6 +97678,7 @@ function prepareServerOwnedSchemaCommit(args) {
   if (!hasSchemaChange && !hasMigrationChange && !hasDialogueSourceChange && !hasValueChange && !hasAdditionalContractImpact) {
     return authoredChanges;
   }
+  args.passLifecycle?.("start", "neo-script-recompile-targets");
   const authoredPostDocument = applyProjectVersionWriteChanges(
     args.document,
     authoredChanges
@@ -97792,26 +97899,46 @@ function prepareServerOwnedSchemaCommit(args) {
     recompileTargets,
     contentHashHeads: args.contentHashHeads
   });
+  args.passLifecycle?.("complete", "neo-script-recompile-targets");
+  yield {
+    pass: "neo-script-recompile-targets",
+    preparedChanges: prepared
+  };
   const serverMintedBindingMemberIds = /* @__PURE__ */ new Set();
+  args.passLifecycle?.("start", "authored-value-seeds");
+  const seedPostDocument = applyProjectVersionWriteChanges(
+    args.document,
+    prepared
+  );
   const pendingConstructedGraphValidations = materializeAuthoredValueSeeds({
-    document: applyProjectVersionWriteChanges(postDocument, prepared),
+    document: seedPostDocument,
     prepared,
     authoredValueSeeds: args.authoredValueSeeds ?? [],
     contentHashHeads: args.contentHashHeads,
-    serverMintedBindingMemberIds
+    serverMintedBindingMemberIds,
+    createLocalizedTextId: args.createLocalizedTextId
   });
   prepareServerOwnedValueInitializerBodies({
     document: args.document,
-    postDocument,
+    postDocument: seedPostDocument,
     prepared,
     targetIds: recompileTargets.valueIds,
     contentHashHeads: args.contentHashHeads
   });
+  args.passLifecycle?.("complete", "authored-value-seeds");
+  yield { pass: "authored-value-seeds", preparedChanges: prepared };
+  args.passLifecycle?.("start", "variant-child-override-binding-members");
   materializeVariantChildOverrideBindingMembers({
     document: args.document,
     prepared,
     serverMintedBindingMemberIds
   });
+  args.passLifecycle?.("complete", "variant-child-override-binding-members");
+  yield {
+    pass: "variant-child-override-binding-members",
+    preparedChanges: prepared
+  };
+  args.passLifecycle?.("start", "prepared-instance-initializers");
   materializePreparedInstanceInitializers({
     document: args.document,
     prepared,
@@ -97829,13 +97956,22 @@ function prepareServerOwnedSchemaCommit(args) {
     prepared,
     pending: pendingConstructedGraphValidations
   });
+  args.passLifecycle?.("complete", "prepared-instance-initializers");
+  yield {
+    pass: "prepared-instance-initializers",
+    preparedChanges: prepared
+  };
+  args.passLifecycle?.("start", "delegate-value-bodies");
   prepareServerOwnedDelegateValueBodies({
     document: args.document,
-    postDocument,
+    postDocument: applyProjectVersionWriteChanges(args.document, prepared),
     prepared,
     targetIds: recompileTargets.valueIds,
     contentHashHeads: args.contentHashHeads
   });
+  args.passLifecycle?.("complete", "delegate-value-bodies");
+  yield { pass: "delegate-value-bodies", preparedChanges: prepared };
+  args.passLifecycle?.("start", "variant-constructor-args");
   reconcileVariantConstructorArgs({
     document: args.document,
     prepared,
@@ -97846,6 +97982,7 @@ function prepareServerOwnedSchemaCommit(args) {
     prepared,
     contentHashHeads: args.contentHashHeads
   });
+  normalizePreparedServerTimestamps(prepared, args.serverTimestamp);
   const committedDocument = applyProjectVersionWriteChanges(
     args.document,
     prepared
@@ -97862,11 +97999,37 @@ function prepareServerOwnedSchemaCommit(args) {
   });
   attachPreparedValuePlacements(physical, committedDocument);
   attachPreparedConstructorAggregateEdges(physical, committedDocument);
-  return orderLocalizedTextWritesBesideLinks(
+  const ordered = orderLocalizedTextWritesBesideLinks(
     orderVariantRootValuesWithVariants(
-      orderDeclaredMemberCreatesFirst(physical, postDocument)
+      orderDeclaredMemberCreatesFirst(
+        physical,
+        applyProjectVersionWriteChanges(args.document, prepared)
+      )
     )
   );
+  args.passLifecycle?.("complete", "variant-constructor-args");
+  yield { pass: "variant-constructor-args", preparedChanges: ordered };
+  return ordered;
+}
+function normalizePreparedServerTimestamps(prepared, serverTimestamp) {
+  if (serverTimestamp === void 0) return;
+  for (const change of prepared) {
+    if (change.operation === "delete" || change.nextData === null || typeof change.nextData !== "object") {
+      continue;
+    }
+    const nextData = change.nextData;
+    if (change.operation === "create" && "createdAt" in nextData) {
+      nextData.createdAt = serverTimestamp;
+    }
+    if ("updatedAt" in nextData) nextData.updatedAt = serverTimestamp;
+  }
+}
+function prepareServerOwnedSchemaCommit(args) {
+  const passes = prepareServerOwnedSchemaCommitPasses(args);
+  for (; ; ) {
+    const step = passes.next();
+    if (step.done) return step.value;
+  }
 }
 function orderLocalizedTextWritesBesideLinks(prepared) {
   const indexByLinkKey = /* @__PURE__ */ new Map();
@@ -98791,8 +98954,12 @@ function prepareServerOwnedDialogueBodies(args) {
       explicitNodeIds.add(change.recordId);
       const next = asRecord2(change.nextData);
       const current = currentNodes.get(change.recordId);
-      const dialogueId = typeof next?.dialogueId === "string" ? next.dialogueId : typeof current?.dialogueId === "string" ? current.dialogueId : null;
-      if (dialogueId !== null) changedDialogueIds.add(dialogueId);
+      if (typeof current?.dialogueId === "string") {
+        changedDialogueIds.add(current.dialogueId);
+      }
+      if (typeof next?.dialogueId === "string") {
+        changedDialogueIds.add(next.dialogueId);
+      }
       continue;
     }
     if (change.recordKind === "dialogue-group") {
@@ -99042,7 +99209,8 @@ function materializeAuthoredValueSeeds(args) {
         pendingGraphValidations,
         memberChange: { index, change },
         member,
-        seed
+        seed,
+        createLocalizedTextId: args.createLocalizedTextId
       });
       continue;
     }
@@ -99103,7 +99271,8 @@ function materializeAuthoredValueSeeds(args) {
       // 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.
-      seed: { ...seed, values: seed.values ?? [] }
+      seed: { ...seed, values: seed.values ?? [] },
+      createLocalizedTextId: args.createLocalizedTextId
     });
     const { createdValues, localizedTexts, storageKeyDeclarations, rootValue } = materialized;
     const ownedValueId = documentIndex.membersById.get(member.id)?.valueId ?? derivedMemberValueId(member.id);
@@ -99513,7 +99682,8 @@ function materializeInstanceDefaultSeed(args) {
     documentIndex: args.documentIndex,
     member: materializationMember,
     seed: { ...args.seed, values: args.seed.values },
-    allowExistingRows: args.memberChange === null || args.memberChange.change.operation === "update"
+    allowExistingRows: args.memberChange === null || args.memberChange.change.operation === "update",
+    createLocalizedTextId: args.createLocalizedTextId
   });
   stampCreatedValuesMapKey(createdValues, null);
   applyDeclaredStorageKeyOverrides({
@@ -99717,7 +99887,8 @@ function materializeAuthoredStaticSeed(args) {
     document: args.document,
     member: args.member,
     createdValues,
-    seededLocalizedTexts
+    seededLocalizedTexts,
+    createLocalizedTextId: args.createLocalizedTextId
   });
   return {
     rootValue,
@@ -99747,7 +99918,8 @@ function materializeSeedLocalizableStringWrites(args) {
         memberId: args.member.id
       }),
       expectedBaseContentHash: null
-    }))
+    })),
+    createTextId: args.createLocalizedTextId
   });
   const createdValuesById = new Map(
     args.createdValues.map((value) => [value.id, value])
@@ -102228,7 +102400,8 @@ function assertProjectVersionWholeGraphWritesValid(args) {
   assertStagedInternalRecordRelationsValid(args.document, projected, changes);
   assertStagedWorldContentLayerBindingsValid(args.document, projected, changes);
   assertAnimationClipDocumentValid(
-    materializeDeclarationInitializersForAnimationValidation(projected)
+    materializeDeclarationInitializersForAnimationValidation(projected),
+    args.animationValidationMemberIds === void 0 ? void 0 : { memberIds: args.animationValidationMemberIds }
   );
   if (args.operation === void 0 || !isSystemOwnedProjectVersionOperation(args.operation)) {
     assertProjectVersionSystemProtectedWritesValid({
@@ -102346,7 +102519,7 @@ function valueDematerializationRefusal(args) {
   return null;
 }
 function materializeDeclarationInitializersForAnimationValidation(document) {
-  const animationFamilyClassIds = animationFamilyClasses(document);
+  const animationFamilyClassIds = animationFamilyClassKinds(document.classes);
   const initializers = document.values.filter(
     (value) => isInitValueContent(value)
   );
@@ -102520,31 +102693,6 @@ function materializeDeclarationInitializersForAnimationValidation(document) {
   }
   return { ...document, members, values: [...valuesById.values()] };
 }
-function animationFamilyClasses(document) {
-  const classes = new Map(document.classes.map((entry) => [entry.id, entry]));
-  const animationKinds = new Set(WORLD_SYSTEM_ANIMATION_KINDS);
-  const result = /* @__PURE__ */ new Map();
-  const resolve5 = (classId, visiting) => {
-    const cached = result.get(classId);
-    if (cached !== void 0) return cached;
-    if (visiting.has(classId)) return false;
-    const schemaClass2 = classes.get(classId);
-    if (schemaClass2 === void 0) return false;
-    const worldKind = schemaClass2.system?.worldKind;
-    if (typeof worldKind === "string" && animationKinds.has(worldKind)) {
-      result.set(classId, true);
-      return true;
-    }
-    const nextVisiting = new Set(visiting).add(classId);
-    const belongs = typeof schemaClass2.extendsClassId === "string" && resolve5(schemaClass2.extendsClassId, nextVisiting);
-    result.set(classId, belongs);
-    return belongs;
-  };
-  for (const classId of classes.keys()) resolve5(classId, /* @__PURE__ */ new Set());
-  return new Set(
-    [...result].flatMap(([classId, belongs]) => belongs ? [classId] : [])
-  );
-}
 function containsDirectValueId(value, ids) {
   if (Array.isArray(value)) {
     return value.some((entry) => typeof entry === "string" && ids.has(entry));
@@ -105699,6 +105847,1467 @@ var init_trusted_commit_verification = __esm({
   }
 });
 
+// ../src/database/project-snapshot-derived-edges.ts
+function extractProjectSnapshotDerivedEdges(source) {
+  const edges = /* @__PURE__ */ new Map();
+  const add = (edge) => {
+    edges.set(edgeIdentity(edge), edge);
+  };
+  for (const targetKey of collectCompilerReferenceIds(source.data)) {
+    add({
+      edgeKind: "compiled-reference",
+      targetKey,
+      targetAddressing: "record",
+      payloadJson: canonicalJsonStringify({ referenceKind: "record-id" })
+    });
+  }
+  for (const targetKey of collectCompilerReferenceNames(source.data)) {
+    add({
+      edgeKind: "compiled-reference",
+      targetKey,
+      targetAddressing: "record",
+      // neo-terminology-audit: allow-next-line legacy-stable-id -- REJECTS: treating compiler reference metadata as a stable ID.
+      payloadJson: canonicalJsonStringify({ referenceKind: "type-name" })
+    });
+  }
+  for (const targetKey of collectCompiledClassIds(source.data)) {
+    add({
+      edgeKind: "compiled-reference",
+      targetKey,
+      targetAddressing: "record",
+      payloadJson: canonicalJsonStringify({
+        referenceKind: "constructed-class-id"
+      })
+    });
+  }
+  const record3 = asRecord3(source.data);
+  if (source.recordKind === "dialogue-node" && record3 !== null && typeof record3.dialogueId === "string") {
+    add({
+      edgeKind: "dialogue-membership",
+      targetKey: record3.dialogueId,
+      targetAddressing: "record",
+      payloadJson: canonicalJsonStringify({ relation: "dialogue-node" })
+    });
+  }
+  if (source.recordKind === "value" && record3 !== null) {
+    const body = record3.value;
+    if (Array.isArray(body) || asRecord3(body) !== null) {
+      for (const targetKey of collectDirectBodyChildIds(body)) {
+        add({
+          edgeKind: "containment-child",
+          targetKey,
+          targetAddressing: "record",
+          payloadJson: canonicalJsonStringify({
+            relation: "body-child",
+            depth: 1
+          })
+        });
+      }
+    }
+    if (typeof record3.containerId === "string") {
+      add({
+        edgeKind: "containment-child",
+        targetKey: record3.containerId,
+        targetAddressing: "record",
+        payloadJson: canonicalJsonStringify({
+          relation: "container-join",
+          childId: source.recordId
+        })
+      });
+    }
+    addStampBindingEdges(record3.genericBindings, add);
+    addPackedChildEdges(source, record3, add);
+  }
+  for (const edge of source.constructorAggregateEdges ?? []) {
+    if (edge.ownerValueId !== source.recordId) {
+      throw new Error(
+        `Constructor aggregate edge owner "${edge.ownerValueId}" does not match snapshot record "${source.recordId}".`
+      );
+    }
+    add({
+      edgeKind: "constructor-aggregate",
+      targetKey: edge.targetValueId,
+      targetAddressing: "record",
+      payloadJson: canonicalJsonStringify({
+        parameterId: edge.parameterId,
+        typeInfo: edge.typeInfo
+      })
+    });
+  }
+  const constructorArgs = record3 === null ? null : asRecord3(record3.constructorArgs);
+  return {
+    edges: [...edges.values()].sort(compareEdges),
+    complete: constructorArgs === null || Object.keys(constructorArgs).length === 0 || source.constructorAggregateEdges !== void 0
+  };
+}
+function addStampBindingEdges(genericBindings, add) {
+  const bindings = asRecord3(genericBindings);
+  if (bindings === null) return;
+  for (const [parameterId, stampedMemberId] of Object.entries(bindings)) {
+    if (typeof stampedMemberId !== "string") continue;
+    add({
+      edgeKind: "stamp-binding",
+      targetKey: stampedMemberId,
+      targetAddressing: "record",
+      payloadJson: canonicalJsonStringify({ parameterId, stampedMemberId })
+    });
+  }
+}
+function addPackedChildEdges(source, record3, add) {
+  if (!rowCarriesPackedValueContent(record3)) return;
+  if (!isMemberValue(source.data)) {
+    throw new Error(
+      `Value snapshot "${source.recordId}" stores packed children but is not a complete value row, so their positions cannot be addressed.`
+    );
+  }
+  for (const position of packedValuePositions(source.data)) {
+    add({
+      edgeKind: "containment-child",
+      targetKey: projectSnapshotDerivedPathTargetKey({
+        recordId: source.recordId,
+        path: position.path
+      }),
+      targetAddressing: "path",
+      payloadJson: canonicalJsonStringify({
+        relation: "packed-child",
+        childId: position.valueId
+      })
+    });
+    addStampBindingEdges(position.entry.genericBindings, add);
+  }
+}
+function projectSnapshotDerivedPathTargetKey(args) {
+  return canonicalJsonStringify({ recordId: args.recordId, path: args.path });
+}
+function projectSnapshotDerivedEdgeIdentity(edge) {
+  return edgeIdentity(edge);
+}
+function edgeIdentity(edge) {
+  return canonicalJsonStringify([
+    edge.edgeKind,
+    edge.targetAddressing,
+    edge.targetKey,
+    edge.payloadJson
+  ]);
+}
+function compareEdges(left, right) {
+  return edgeIdentity(left).localeCompare(edgeIdentity(right));
+}
+function collectDirectBodyChildIds(value) {
+  const candidates = Array.isArray(value) ? value : Object.values(asRecord3(value) ?? {});
+  return [
+    ...new Set(
+      candidates.filter(
+        (candidate) => typeof candidate === "string" && STORED_PROJECT_RECORD_ID_PATTERN.test(candidate)
+      )
+    )
+  ];
+}
+function asRecord3(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+var PROJECT_SNAPSHOT_DERIVED_EDGE_EXTRACTOR_VERSION, STORED_PROJECT_RECORD_ID_PATTERN;
+var init_project_snapshot_derived_edges = __esm({
+  "../src/database/project-snapshot-derived-edges.ts"() {
+    "use strict";
+    init_canonical_json();
+    init_neo_script_recompile_scope();
+    init_member_kinds();
+    init_packed_value_encoding();
+    PROJECT_SNAPSHOT_DERIVED_EDGE_EXTRACTOR_VERSION = 4;
+    STORED_PROJECT_RECORD_ID_PATTERN = /^(?:system_)?[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu;
+  }
+});
+
+// ../src/database/commit-preparation-scope-planner.ts
+function nextCommitPreparationPass(completed) {
+  const index = COMMIT_PREPARATION_PASS_ORDER.indexOf(completed);
+  return COMMIT_PREPARATION_PASS_ORDER[index + 1] ?? null;
+}
+var COMMIT_PREPARATION_PROJECTED_BUCKETS, COMMIT_PREPARATION_PASS_ORDER, COMMIT_PREPARATION_CLOSURE_SPECS;
+var init_commit_preparation_scope_planner = __esm({
+  "../src/database/commit-preparation-scope-planner.ts"() {
+    "use strict";
+    COMMIT_PREPARATION_PROJECTED_BUCKETS = [
+      "project",
+      "members",
+      "classes",
+      "constructors",
+      "variants",
+      "variantFolders",
+      "enums",
+      "interfaces",
+      "internalRecordRelations",
+      "projectFiles",
+      "textureTemplates",
+      "audioClipTemplates",
+      "dialogues",
+      "dialogueRecords",
+      "dialogueGroups",
+      "values",
+      "dialogueNodes",
+      "migrations"
+    ];
+    COMMIT_PREPARATION_PASS_ORDER = [
+      "neo-script-recompile-targets",
+      "authored-value-seeds",
+      "variant-child-override-binding-members",
+      "prepared-instance-initializers",
+      "delegate-value-bodies",
+      "variant-constructor-args"
+    ];
+    COMMIT_PREPARATION_CLOSURE_SPECS = {
+      "neo-script-recompile-targets": {
+        order: 1,
+        entryPoint: "collectNeoScriptRecompileTargets",
+        synthesizes: "recompile updates",
+        // The one pass that does not rebuild a post-document — its caller hands it
+        // both sides — so it is not held to the projection's bucket set.
+        reads: [
+          "project",
+          "members",
+          "classes",
+          "constructors",
+          "variants",
+          "variantFolders",
+          "enums",
+          "interfaces",
+          "values",
+          "dialogues",
+          "dialogueRecords",
+          "dialogueGroups",
+          "dialogueNodes",
+          "migrations"
+        ],
+        closureRules: [
+          "change-targets",
+          "ancestor-paths",
+          "animation-graph-closure",
+          "member-default-value-closure",
+          "compiled-reference-reverse-index",
+          "dialogue-membership-peers",
+          "every-variant-root",
+          "localizable-reference-candidates",
+          "source-only-rows",
+          "whole-graph-validation-members",
+          "world-value-ranges"
+        ],
+        mutatesDocument: []
+      },
+      "authored-value-seeds": {
+        order: 2,
+        entryPoint: "materializeAuthoredValueSeeds",
+        synthesizes: "seed value rows, localized texts",
+        // The one pass that reads the localization buckets: a static seed mints
+        // localized texts, and the mint reads the project's localization config.
+        reads: [
+          ...COMMIT_PREPARATION_PROJECTED_BUCKETS,
+          "localizationConfig",
+          "localizedTexts"
+        ],
+        closureRules: [
+          "change-targets",
+          "ancestor-paths",
+          "animation-graph-closure",
+          "authored-seed-requested-ids",
+          "member-default-value-closure",
+          "every-variant-root",
+          "localizable-reference-candidates",
+          "world-value-ranges"
+        ],
+        // `materializeStaticSeedBindingMembers` pushes the binding member it mints
+        // into the document the rest of this pass reads, not only into `prepared`.
+        mutatesDocument: ["members"]
+      },
+      "variant-child-override-binding-members": {
+        order: 3,
+        entryPoint: "materializeVariantChildOverrideBindingMembers",
+        synthesizes: "binding members",
+        reads: [...COMMIT_PREPARATION_PROJECTED_BUCKETS],
+        closureRules: [
+          "change-targets",
+          "ancestor-paths",
+          "animation-graph-closure",
+          "descendants",
+          "member-default-value-closure",
+          "every-variant-root",
+          "stamp-edge-candidates",
+          "world-value-ranges"
+        ],
+        // The minted binding member is pushed straight into the document the
+        // later passes read, not only into `prepared`.
+        mutatesDocument: ["members"]
+      },
+      "prepared-instance-initializers": {
+        order: 4,
+        entryPoint: "materializePreparedInstanceInitializers",
+        synthesizes: "created value rows from evaluation",
+        reads: [...COMMIT_PREPARATION_PROJECTED_BUCKETS],
+        closureRules: [
+          "change-targets",
+          "every-variant-root",
+          "full-content-dimension",
+          "member-default-value-closure",
+          "world-value-ranges"
+        ],
+        mutatesDocument: []
+      },
+      "delegate-value-bodies": {
+        order: 5,
+        entryPoint: "prepareServerOwnedDelegateValueBodies",
+        synthesizes: "delegate-body rewrites",
+        reads: [...COMMIT_PREPARATION_PROJECTED_BUCKETS],
+        closureRules: [
+          "change-targets",
+          "ancestor-paths",
+          "animation-graph-closure",
+          "descendants",
+          "member-default-value-closure",
+          "every-variant-root",
+          "source-only-rows",
+          "world-value-ranges"
+        ],
+        mutatesDocument: []
+      },
+      "variant-constructor-args": {
+        order: 6,
+        entryPoint: "reconcileVariantConstructorArgs",
+        synthesizes: "constructor-arg updates",
+        reads: [...COMMIT_PREPARATION_PROJECTED_BUCKETS],
+        closureRules: [
+          "change-targets",
+          "every-variant-root",
+          "touched-variant-schema-key-children",
+          "member-default-value-closure",
+          "world-value-ranges"
+        ],
+        mutatesDocument: []
+      }
+    };
+  }
+});
+
+// ../src/database/commit-preparation-animation-scope.ts
+function commitPreparationAnimationSchema(document) {
+  const classesById2 = new Map(
+    document.classes.map((schemaClass2) => [schemaClass2.id, schemaClass2])
+  );
+  const rootKindByClassId = /* @__PURE__ */ new Map();
+  for (const classId of animationFamilyClassKinds(document.classes).keys()) {
+    const visited = /* @__PURE__ */ new Set();
+    let current = classesById2.get(classId);
+    while (current !== void 0 && !visited.has(current.id)) {
+      visited.add(current.id);
+      const worldKind = current.system?.worldKind;
+      if (worldKind !== void 0 && ANIMATION_ROOT_KINDS.has(worldKind)) {
+        rootKindByClassId.set(classId, worldKind);
+        break;
+      }
+      current = typeof current.extendsClassId === "string" ? classesById2.get(current.extendsClassId) : void 0;
+    }
+  }
+  const rootMemberIds2 = /* @__PURE__ */ new Set();
+  for (const member of document.members) {
+    if (isMemberClass(member) && rootKindByClassId.has(member.classId)) {
+      rootMemberIds2.add(member.id);
+    }
+  }
+  const segmentClassIds = /* @__PURE__ */ new Set();
+  for (const [classId, worldKind] of rootKindByClassId) {
+    if (worldKind === NeoWorldSystemClassKind.AnimationSegment) {
+      segmentClassIds.add(classId);
+    }
+  }
+  return { rootMemberIds: rootMemberIds2, segmentClassIds };
+}
+function isAnimationSegmentValueRow(data, schema) {
+  if (data === null || typeof data !== "object") return false;
+  const classId = Reflect.get(data, "classId");
+  return typeof classId === "string" && schema.segmentClassIds.has(classId);
+}
+function animationClipMemberIdsTargetingClasses(document, classIds, schema) {
+  if (classIds.size === 0) return [];
+  const classesById2 = new Map(
+    document.classes.map((schemaClass2) => [schemaClass2.id, schemaClass2])
+  );
+  const membersById2 = new Map(
+    document.members.map((member) => [member.id, member])
+  );
+  const descendsFromChanged = (classId) => {
+    const visited = /* @__PURE__ */ new Set();
+    let current = classesById2.get(classId);
+    while (current !== void 0 && !visited.has(current.id)) {
+      if (classIds.has(current.id)) return true;
+      visited.add(current.id);
+      current = typeof current.extendsClassId === "string" ? classesById2.get(current.extendsClassId) : void 0;
+    }
+    return false;
+  };
+  const result = [];
+  for (const member of document.members) {
+    if (!isMemberClass(member)) continue;
+    if (!schema.rootMemberIds.has(member.id)) continue;
+    const binding = resolveInstanceEnv(
+      member.classId,
+      member.classArguments,
+      document.classes
+    ).get(WORLD_ANIMATION_CLIP_TARGET_PARAM_ID);
+    const bindingMember = binding?.kind === "member" ? membersById2.get(binding.memberId) : void 0;
+    if (!isMemberClass(bindingMember)) continue;
+    if (descendsFromChanged(bindingMember.classId)) result.push(member.id);
+  }
+  return result;
+}
+var ANIMATION_ROOT_KINDS;
+var init_commit_preparation_animation_scope = __esm({
+  "../src/database/commit-preparation-animation-scope.ts"() {
+    "use strict";
+    init_core();
+    init_member_kinds();
+    init_generics();
+    init_world_system_classes();
+    ANIMATION_ROOT_KINDS = /* @__PURE__ */ new Set([
+      NeoWorldSystemClassKind.AnimationClip,
+      NeoWorldSystemClassKind.AnimationSegment
+    ]);
+  }
+});
+
+// ../src/database/project-commit-preparation-scoped-loader.ts
+function overlayPlanningRows(rows, recordKind, changes) {
+  const result = new Map((rows ?? []).map((row) => [row.id, row]));
+  for (const change of changes) {
+    if (change.recordKind !== recordKind) continue;
+    if (change.operation === "delete" || change.nextData === null) {
+      result.delete(change.recordId);
+    } else {
+      result.set(change.recordId, change.nextData);
+    }
+  }
+  return [...result.values()];
+}
+function overlayPlanningDocument(document, changes) {
+  const projectChange = changes.findLast(
+    (change) => change.recordKind === "project" && change.operation !== "delete" && change.nextData !== null
+  );
+  return {
+    ...document,
+    project: projectChange?.nextData ?? document.project,
+    members: overlayPlanningRows(document.members, "member", changes),
+    classes: overlayPlanningRows(document.classes, "class", changes),
+    constructors: overlayPlanningRows(
+      document.constructors,
+      "constructor",
+      changes
+    ),
+    variants: overlayPlanningRows(document.variants, "variant", changes),
+    variantFolders: overlayPlanningRows(
+      document.variantFolders,
+      "variant-folder",
+      changes
+    ),
+    enums: overlayPlanningRows(document.enums, "enum", changes),
+    interfaces: overlayPlanningRows(document.interfaces, "interface", changes),
+    values: overlayPlanningRows(document.values, "value", changes),
+    dialogues: overlayPlanningRows(document.dialogues, "dialogue", changes),
+    dialogueGroups: overlayPlanningRows(
+      document.dialogueGroups,
+      "dialogue-group",
+      changes
+    ),
+    dialogueNodes: overlayPlanningRows(
+      document.dialogueNodes,
+      "dialogue-node",
+      changes
+    ),
+    migrations: overlayPlanningRows(document.migrations, "migration", changes),
+    localizedTexts: overlayPlanningRows(
+      document.localizedTexts,
+      "localized-text",
+      changes
+    )
+  };
+}
+function worldKindByClassId(document) {
+  const classes = new Map(
+    document.classes.map((schemaClass2) => [schemaClass2.id, schemaClass2])
+  );
+  const result = /* @__PURE__ */ new Map();
+  const resolve5 = (classId, visiting) => {
+    if (result.has(classId)) return result.get(classId);
+    if (visiting.has(classId)) return void 0;
+    const schemaClass2 = classes.get(classId);
+    if (schemaClass2 === void 0) return void 0;
+    const own = schemaClass2.system?.worldKind;
+    const resolved = typeof own === "string" ? own : schemaClass2.extendsClassId === void 0 ? void 0 : resolve5(schemaClass2.extendsClassId, new Set(visiting).add(classId));
+    result.set(classId, resolved);
+    return resolved;
+  };
+  for (const classId of classes.keys()) resolve5(classId, /* @__PURE__ */ new Set());
+  return result;
+}
+function valueWorldKind(kinds, value) {
+  if (value === null || typeof value !== "object") return void 0;
+  const classId = Reflect.get(value, "classId");
+  return typeof classId === "string" ? kinds.get(classId) : void 0;
+}
+function hasWorldLayerOverride(value) {
+  if (value === null || typeof value !== "object") return false;
+  const body = Reflect.get(value, "value");
+  return body !== null && typeof body === "object" && typeof Reflect.get(body, "layerOverrideValueId") === "string";
+}
+function commitPreparationWorldScopeKinds(args) {
+  const allKinds = new Set(
+    args.postDocument.classes.flatMap(
+      (schemaClass2) => typeof schemaClass2.system?.worldKind === "string" ? [schemaClass2.system.worldKind] : []
+    )
+  );
+  if (args.changes.some((change) => change.recordKind === "class")) {
+    return allKinds;
+  }
+  const kindsByClass = worldKindByClassId(args.postDocument);
+  const current = projectDocumentRecordsByKey(args.currentDocument);
+  const requiresWholeWorld = args.changes.some((change) => {
+    if (change.recordKind !== "value") return false;
+    const prior = current.get(commitPreparationRecordKey(change));
+    return [prior, change.nextData].some((candidate) => {
+      const worldKind = valueWorldKind(kindsByClass, candidate);
+      return hasWorldLayerOverride(candidate) || worldKind === NeoWorldSystemClassKind.TileLayerLink || worldKind === NeoWorldSystemClassKind.ObjectLayerLink;
+    });
+  });
+  return requiresWholeWorld ? allKinds : /* @__PURE__ */ new Set();
+}
+function commitPreparationMemberDefaultValueScope(args) {
+  const exactValueIds = /* @__PURE__ */ new Set();
+  const descendantValueIds = /* @__PURE__ */ new Set();
+  const membersById2 = new Map(
+    args.postDocument.members.map((member) => [member.id, member])
+  );
+  const classesById2 = new Map(
+    args.postDocument.classes.map((schemaClass2) => [
+      schemaClass2.id,
+      schemaClass2
+    ])
+  );
+  const visitedMemberIds = /* @__PURE__ */ new Set();
+  const visitedClassIds = /* @__PURE__ */ new Set();
+  const rememberDefaultIds = (value, descendants) => {
+    for (const valueId of collectStoredRecordIds(value)) {
+      exactValueIds.add(valueId);
+      if (descendants) descendantValueIds.add(valueId);
+    }
+  };
+  function visitMember(memberId) {
+    if (visitedMemberIds.has(memberId)) return;
+    visitedMemberIds.add(memberId);
+    const rawMember = membersById2.get(memberId);
+    if (rawMember === void 0) return;
+    const member = resolveMember2(rawMember, args.postDocument.members);
+    rememberDefaultIds(member.defaultValue, true);
+    if (!isMemberClassBase(member)) return;
+    const defaultClassId = Reflect.get(member.defaultValue ?? {}, "classId");
+    visitClass(
+      typeof defaultClassId === "string" ? defaultClassId : member.classId
+    );
+  }
+  function visitClass(classId) {
+    if (visitedClassIds.has(classId)) return;
+    visitedClassIds.add(classId);
+    if (!classesById2.has(classId)) return;
+    for (const entry of mergeStoredInstanceSchema(
+      classId,
+      args.postDocument.classes,
+      args.postDocument.members
+    )) {
+      visitMember(entry.memberId);
+    }
+  }
+  for (const member of [
+    ...args.currentDocument.members,
+    ...args.postDocument.members
+  ]) {
+    rememberDefaultIds(member.defaultValue, false);
+  }
+  for (const seed of args.authoredValueSeeds) {
+    visitMember(seed.memberId);
+    if ("classId" in seed && typeof seed.classId === "string") {
+      visitClass(seed.classId);
+    }
+    for (const row of seed.values ?? []) {
+      visitMember(row.memberId);
+      if ("classId" in row && typeof row.classId === "string") {
+        visitClass(row.classId);
+      }
+    }
+  }
+  for (const change of args.changes) {
+    if (change.recordKind === "member") {
+      visitMember(change.recordId);
+      const currentMember = args.currentDocument.members.find(
+        (member) => member.id === change.recordId
+      );
+      if (currentMember !== void 0) {
+        rememberDefaultIds(currentMember.defaultValue, true);
+      }
+    }
+    if (change.recordKind === "value" && change.nextData !== null && typeof change.nextData === "object") {
+      const classId = Reflect.get(change.nextData, "classId");
+      if (typeof classId === "string") visitClass(classId);
+    }
+  }
+  return { exactValueIds, descendantValueIds };
+}
+function planCommitPreparationInitialScope(args) {
+  const rules = new Set(
+    COMMIT_PREPARATION_CLOSURE_SPECS[args.pass].closureRules
+  );
+  const currentDocument = overlayPlanningDocument(args.document, []);
+  const postDocument = overlayPlanningDocument(currentDocument, args.changes);
+  const exactRecords = /* @__PURE__ */ new Map();
+  const descendantRecords = /* @__PURE__ */ new Map();
+  const rememberExact = (recordKind, recordId, includeDescendants = false) => {
+    const record3 = { recordKind, recordId };
+    const key = commitPreparationRecordKey(record3);
+    exactRecords.set(key, record3);
+    if (includeDescendants) descendantRecords.set(key, record3);
+  };
+  for (const change of args.changes) {
+    rememberExact(change.recordKind, change.recordId, true);
+    if (change.recordKind === "member") {
+      rememberExact("value", derivedMemberValueId(change.recordId), true);
+      const current = args.document.members.find(
+        (member) => member.id === change.recordId
+      );
+      for (const candidate of [current, change.nextData]) {
+        if (candidate === null || typeof candidate !== "object") continue;
+        const valueId = Reflect.get(candidate, "valueId");
+        if (typeof valueId === "string") rememberExact("value", valueId, true);
+      }
+    }
+    for (const valueId of collectStoredRecordIds(change.nextData)) {
+      rememberExact("value", valueId, true);
+    }
+    if (change.nextData !== null && typeof change.nextData === "object") {
+      const candidate = change.recordKind === "member" && isMemberStringBase(change.nextData) && isLocalizedStringMember(change.nextData) ? Reflect.get(change.nextData, "defaultValue") : change.recordKind === "value" ? Reflect.get(change.nextData, "value") : void 0;
+      const localizedTextId = candidate !== null && typeof candidate === "object" && typeof Reflect.get(candidate, "value") === "string" ? Reflect.get(candidate, "value") : candidate;
+      if (typeof localizedTextId === "string") {
+        rememberExact("localized-text", localizedTextId);
+      }
+    }
+  }
+  const memberById2 = new Map(
+    postDocument.members.flatMap((member) => {
+      const id2 = Reflect.get(member, "id");
+      return typeof id2 === "string" ? [[id2, member]] : [];
+    })
+  );
+  const rememberSeedLocalizedTextCandidate = (memberId, body) => {
+    const member = memberById2.get(memberId);
+    if (member === void 0 || !isMemberStringBase(member) || !isLocalizedStringMember(member) || typeof body !== "string") {
+      return;
+    }
+    rememberExact("localized-text", body);
+  };
+  if (rules.has("authored-seed-requested-ids")) {
+    for (const seed of args.authoredValueSeeds) {
+      if (seed.valueId !== void 0) {
+        rememberExact("value", seed.valueId);
+      }
+      rememberSeedLocalizedTextCandidate(
+        seed.memberId,
+        Reflect.get(seed, "value")
+      );
+      for (const row of seed.values ?? []) {
+        rememberExact("value", row.id);
+        rememberSeedLocalizedTextCandidate(
+          row.memberId,
+          Reflect.get(row, "value")
+        );
+      }
+      for (const localizedText of seed.localizedTexts ?? []) {
+        rememberExact("localized-text", localizedText.id);
+      }
+      for (const valueId of collectStoredRecordIds(seed)) {
+        rememberExact("value", valueId);
+      }
+    }
+  }
+  if (rules.has("member-default-value-closure")) {
+    const defaultScope = commitPreparationMemberDefaultValueScope({
+      currentDocument,
+      postDocument,
+      changes: args.changes,
+      authoredValueSeeds: args.authoredValueSeeds
+    });
+    for (const valueId of defaultScope.exactValueIds) {
+      rememberExact(
+        "value",
+        valueId,
+        defaultScope.descendantValueIds.has(valueId)
+      );
+    }
+  }
+  if (rules.has("every-variant-root")) {
+    for (const variant of postDocument.variants ?? []) {
+      rememberExact("value", variant.valueId);
+    }
+    for (const folder of postDocument.variantFolders ?? []) {
+      const collectionValueId = Reflect.get(
+        folder,
+        "collectionValueId"
+      );
+      if (typeof collectionValueId === "string") {
+        rememberExact("value", collectionValueId);
+      }
+    }
+  }
+  if (rules.has("touched-variant-schema-key-children")) {
+    const valuesById = new Map(
+      postDocument.values.map((value) => [value.id, value])
+    );
+    for (const variant of postDocument.variants ?? []) {
+      const root = valuesById.get(variant.valueId);
+      const body = root?.value;
+      if (body === null || typeof body !== "object") continue;
+      for (const schemaKey of [
+        NEO_VARIANT_INITIALIZE_SCHEMA_KEY,
+        NEO_VARIANT_APPLY_SCHEMA_KEY,
+        NEO_VARIANT_OVERRIDES_SCHEMA_KEY,
+        NEO_VARIANT_CHILD_OVERRIDES_SCHEMA_KEY
+      ]) {
+        const childId = Reflect.get(body, schemaKey);
+        if (typeof childId === "string") rememberExact("value", childId);
+      }
+    }
+  }
+  const ranges = [];
+  if (rules.has("source-only-rows")) {
+    ranges.push({
+      rangeKind: "source-only",
+      targetKey: "true",
+      limit: Math.min(
+        args.rangeLimit,
+        COMMIT_PREPARATION_SCOPE_SOURCE_ONLY_ROW_LIMIT
+      )
+    });
+  }
+  const valueOwnerMemberIds = /* @__PURE__ */ new Set();
+  const animationValidationMemberIds = /* @__PURE__ */ new Set();
+  if (rules.has("whole-graph-validation-members")) {
+    for (const memberId of commitPreparationValidationCandidateMemberIds(
+      postDocument
+    )) {
+      valueOwnerMemberIds.add(memberId);
+    }
+    for (const change of args.changes) {
+      if (change.recordKind === "member") {
+        valueOwnerMemberIds.add(change.recordId);
+      }
+    }
+    const animationSchema = commitPreparationAnimationSchema(postDocument);
+    const declaringClassIdsByMemberId = /* @__PURE__ */ new Map();
+    for (const schemaClass2 of postDocument.classes) {
+      for (const memberId of Object.values(schemaClass2.schema)) {
+        const declaring = declaringClassIdsByMemberId.get(memberId) ?? [];
+        declaring.push(schemaClass2.id);
+        declaringClassIdsByMemberId.set(memberId, declaring);
+      }
+    }
+    const changedClassIds = /* @__PURE__ */ new Set();
+    for (const change of args.changes) {
+      if (change.recordKind === "class") changedClassIds.add(change.recordId);
+      if (change.recordKind !== "member") continue;
+      if (animationSchema.rootMemberIds.has(change.recordId)) {
+        animationValidationMemberIds.add(change.recordId);
+      }
+      for (const classId of declaringClassIdsByMemberId.get(change.recordId) ?? []) {
+        changedClassIds.add(classId);
+      }
+    }
+    for (const seed of args.authoredValueSeeds) {
+      if (animationSchema.rootMemberIds.has(seed.memberId)) {
+        animationValidationMemberIds.add(seed.memberId);
+      }
+    }
+    for (const memberId of animationClipMemberIdsTargetingClasses(
+      postDocument,
+      changedClassIds,
+      animationSchema
+    )) {
+      rememberExact("member", memberId, true);
+      animationValidationMemberIds.add(memberId);
+    }
+  }
+  for (const memberId of valueOwnerMemberIds) {
+    ranges.push({
+      rangeKind: "value-member",
+      targetKey: memberId,
+      limit: args.rangeLimit
+    });
+  }
+  if (rules.has("world-value-ranges")) {
+    for (const worldKind of commitPreparationWorldScopeKinds({
+      currentDocument,
+      postDocument,
+      changes: args.changes
+    })) {
+      ranges.push({
+        rangeKind: "world-kind",
+        targetKey: worldKind,
+        limit: args.rangeLimit
+      });
+    }
+  }
+  const postingKeys = /* @__PURE__ */ new Map();
+  const rememberPosting = (edgeKind, targetKey) => {
+    const request = { edgeKind, targetKey, limit: args.postingLimit };
+    postingKeys.set(commitPreparationPostingRequestKey(request), request);
+  };
+  const currentByKey = projectDocumentRecordsByKey(currentDocument);
+  if (rules.has("dialogue-membership-peers")) {
+    for (const change of args.changes) {
+      if (change.recordKind === "dialogue") {
+        rememberPosting("dialogue-membership", change.recordId);
+        continue;
+      }
+      if (change.recordKind !== "dialogue-node") continue;
+      for (const candidate of [
+        currentByKey.get(commitPreparationRecordKey(change)),
+        change.nextData
+      ]) {
+        if (candidate === null || typeof candidate !== "object") continue;
+        const dialogueId = Reflect.get(candidate, "dialogueId");
+        if (typeof dialogueId === "string") {
+          rememberPosting("dialogue-membership", dialogueId);
+        }
+      }
+    }
+  }
+  if (rules.has("compiled-reference-reverse-index")) {
+    const targets = collectNeoScriptRecompileReferenceTargets({
+      currentDocument,
+      postDocument,
+      changes: args.changes,
+      additionalImpactedIds: args.additionalImpactedIds,
+      additionalChangedValueIds: args.additionalChangedValueIds
+    });
+    for (const id2 of targets.ids) rememberPosting("compiled-reference", id2);
+    for (const name of targets.names) {
+      rememberPosting("compiled-reference", name);
+    }
+  }
+  for (const change of args.changes) {
+    if (rules.has("compiled-reference-reverse-index")) {
+      if (change.operation !== "create") {
+        rememberPosting("compiled-reference", change.recordId);
+      }
+      for (const candidate of [
+        currentByKey.get(commitPreparationRecordKey(change)),
+        change.nextData
+      ]) {
+        if (candidate === null || typeof candidate !== "object") continue;
+        const name = Reflect.get(candidate, "name");
+        if (typeof name === "string" && change.operation !== "create") {
+          rememberPosting("compiled-reference", name);
+        }
+      }
+    }
+    if (rules.has("stamp-edge-candidates") && change.recordKind === "member" && change.operation === "delete") {
+      rememberPosting("stamp-binding", change.recordId);
+    }
+    if (rules.has("localizable-reference-candidates") && change.recordKind === "value" && change.operation === "create" && change.nextData !== null && typeof change.nextData === "object" && typeof Reflect.get(change.nextData, "value") === "string") {
+      rememberPosting("containment-child", change.recordId);
+      rememberPosting("compiled-reference", change.recordId);
+    }
+  }
+  if (rules.has("localizable-reference-candidates")) {
+    for (const seed of args.authoredValueSeeds) {
+      const rootId = seed.valueId ?? derivedMemberValueId(seed.memberId);
+      if (typeof Reflect.get(seed, "value") === "string") {
+        rememberPosting("containment-child", rootId);
+        rememberPosting("compiled-reference", rootId);
+      }
+      for (const row of seed.values ?? []) {
+        if (typeof Reflect.get(row, "value") !== "string") continue;
+        rememberPosting("containment-child", row.id);
+        rememberPosting("compiled-reference", row.id);
+      }
+    }
+  }
+  return {
+    exactRecords: [...exactRecords.values()].sort(compareRecordKeys),
+    descendantRecords: [...descendantRecords.values()].sort(compareRecordKeys),
+    ranges: ranges.sort(
+      (left, right) => commitPreparationRangeRequestKey(left).localeCompare(
+        commitPreparationRangeRequestKey(right)
+      )
+    ),
+    postings: [...postingKeys.values()].sort(
+      (left, right) => commitPreparationPostingRequestKey(left).localeCompare(
+        commitPreparationPostingRequestKey(right)
+      )
+    ),
+    fullContentDimension: rules.has("full-content-dimension") && (containsInitializerSource(args.changes) || containsInitializerSource(args.authoredValueSeeds)),
+    ...animationValidationScope(animationValidationMemberIds)
+  };
+}
+function planCommitPreparationLoadedClosureScope(args) {
+  const rules = new Set(
+    COMMIT_PREPARATION_CLOSURE_SPECS[args.pass].closureRules
+  );
+  const exactRecords = /* @__PURE__ */ new Map();
+  const descendantRecords = /* @__PURE__ */ new Map();
+  const ranges = /* @__PURE__ */ new Map();
+  const postings = /* @__PURE__ */ new Map();
+  const animationValidationMemberIds = /* @__PURE__ */ new Set();
+  const rememberExact = (recordKind, recordId) => {
+    const record3 = { recordKind, recordId };
+    exactRecords.set(commitPreparationRecordKey(record3), record3);
+  };
+  const rememberDescendant = (recordKind, recordId) => {
+    const record3 = { recordKind, recordId };
+    const key = commitPreparationRecordKey(record3);
+    exactRecords.set(key, record3);
+    descendantRecords.set(key, record3);
+  };
+  const rememberRange = (range2) => {
+    ranges.set(commitPreparationRangeRequestKey(range2), range2);
+  };
+  const rememberPosting = (posting) => {
+    postings.set(commitPreparationPostingRequestKey(posting), posting);
+  };
+  for (const record3 of args.records) {
+    if (rules.has("animation-graph-closure") && args.animationSchema !== void 0) {
+      if (record3.recordKind === "value" && record3.includeDescendants === false && isAnimationSegmentValueRow(record3.data, args.animationSchema)) {
+        rememberDescendant(record3.recordKind, record3.recordId);
+      }
+      if (record3.parentRecordKind === "member" && typeof record3.parentRecordId === "string" && args.animationSchema.rootMemberIds.has(record3.parentRecordId)) {
+        rememberDescendant("member", record3.parentRecordId);
+        animationValidationMemberIds.add(record3.parentRecordId);
+      }
+    }
+    if (rules.has("ancestor-paths") && record3.parentRecordKind !== null && record3.parentRecordKind !== void 0 && record3.parentRecordId !== null && record3.parentRecordId !== void 0) {
+      rememberExact(record3.parentRecordKind, record3.parentRecordId);
+    }
+    const canOwnStoredDescendants = record3.recordKind !== "value" || record3.data !== null && typeof record3.data === "object" && Reflect.get(record3.data, "value") !== null && typeof Reflect.get(record3.data, "value") === "object";
+    if (rules.has("descendants") && record3.includeDescendants !== false && canOwnStoredDescendants && (record3.recordKind === "member" || record3.recordKind === "value" || record3.recordKind === "class" || record3.recordKind === "variant")) {
+      rememberRange({
+        rangeKind: "children",
+        targetKey: commitPreparationRecordKey(record3),
+        limit: args.rangeLimit
+      });
+    }
+    if (rules.has("descendants") && record3.includeDescendants !== false && canOwnStoredDescendants && record3.recordKind === "value") {
+      rememberRange({
+        rangeKind: "container-members",
+        targetKey: record3.recordId,
+        limit: args.rangeLimit
+      });
+    }
+    if (rules.has("dialogue-membership-peers") && record3.includeDescendants !== false && record3.recordKind === "dialogue-node" && record3.data !== null && typeof record3.data === "object") {
+      const dialogueId = Reflect.get(record3.data, "dialogueId");
+      if (typeof dialogueId === "string") {
+        rememberPosting({
+          edgeKind: "dialogue-membership",
+          targetKey: dialogueId,
+          limit: args.postingLimit
+        });
+      }
+    }
+    if (record3.includeDescendants !== false) {
+      for (const valueId of collectStoredRecordIds(record3.data)) {
+        rememberDescendant("value", valueId);
+      }
+    }
+  }
+  return {
+    exactRecords: [...exactRecords.values()].sort(compareRecordKeys),
+    descendantRecords: [...descendantRecords.values()].sort(compareRecordKeys),
+    ranges: [...ranges.values()].sort(
+      (left, right) => commitPreparationRangeRequestKey(left).localeCompare(
+        commitPreparationRangeRequestKey(right)
+      )
+    ),
+    postings: [...postings.values()].sort(
+      (left, right) => commitPreparationPostingRequestKey(left).localeCompare(
+        commitPreparationPostingRequestKey(right)
+      )
+    ),
+    fullContentDimension: false,
+    ...animationValidationScope(animationValidationMemberIds)
+  };
+}
+function animationValidationScope(memberIds) {
+  return memberIds.size === 0 ? {} : { animationValidationMemberIds: [...memberIds].sort() };
+}
+function withCommitPreparationInMemoryPlacement(records2) {
+  const recordKeys = new Set(records2.map(commitPreparationRecordKey));
+  const parentByChild = /* @__PURE__ */ new Map();
+  const ambiguousParentsByChild = /* @__PURE__ */ new Map();
+  const authorityRank = {
+    "reverse-container": 1,
+    forward: 2,
+    persisted: 3
+  };
+  const rememberParent = (childKey, parent, authority) => {
+    if (!recordKeys.has(childKey)) return;
+    const prior = parentByChild.get(childKey);
+    if (prior !== void 0) {
+      const comparison = authorityRank[authority] - authorityRank[prior.authority];
+      if (comparison < 0) return;
+      if (comparison > 0) {
+        ambiguousParentsByChild.delete(childKey);
+      }
+      if (comparison === 0) {
+        if (prior.recordKind === parent.recordKind && prior.recordId === parent.recordId) {
+          return;
+        }
+        const ambiguity = ambiguousParentsByChild.get(childKey) ?? {
+          authority,
+          parents: /* @__PURE__ */ new Set()
+        };
+        ambiguity.parents.add(`${prior.recordKind}:${prior.recordId}`);
+        ambiguity.parents.add(`${parent.recordKind}:${parent.recordId}`);
+        ambiguousParentsByChild.set(childKey, ambiguity);
+        if (`${prior.recordKind}:${prior.recordId}`.localeCompare(
+          `${parent.recordKind}:${parent.recordId}`
+        ) <= 0) {
+          return;
+        }
+      }
+    }
+    parentByChild.set(childKey, { ...parent, authority });
+  };
+  for (const record3 of records2) {
+    const sourceKey = commitPreparationRecordKey(record3);
+    if (record3.parentRecordKind !== void 0 && record3.parentRecordKind !== null && record3.parentRecordId !== void 0 && record3.parentRecordId !== null) {
+      rememberParent(
+        sourceKey,
+        {
+          recordKind: record3.parentRecordKind,
+          recordId: record3.parentRecordId
+        },
+        "persisted"
+      );
+    }
+    if (record3.recordKind === "dialogue-node") {
+      const dialogueId = record3.data !== null && typeof record3.data === "object" ? Reflect.get(record3.data, "dialogueId") : void 0;
+      if (typeof dialogueId === "string") {
+        rememberParent(
+          sourceKey,
+          {
+            recordKind: "dialogue",
+            recordId: dialogueId
+          },
+          "forward"
+        );
+      }
+    }
+    for (const edge of extractProjectSnapshotDerivedEdges(record3).edges) {
+      if (edge.edgeKind !== "containment-child" || edge.targetAddressing !== "record") {
+        continue;
+      }
+      const payload = JSON.parse(edge.payloadJson);
+      if (payload !== null && typeof payload === "object" && Reflect.get(payload, "relation") === "container-join") {
+        rememberParent(
+          sourceKey,
+          {
+            recordKind: "value",
+            recordId: edge.targetKey
+          },
+          "reverse-container"
+        );
+      } else {
+        rememberParent(
+          `value:${edge.targetKey}`,
+          {
+            recordKind: record3.recordKind,
+            recordId: record3.recordId
+          },
+          "forward"
+        );
+      }
+    }
+  }
+  for (const [childKey, ambiguity] of ambiguousParentsByChild) {
+    if (parentByChild.get(childKey)?.authority !== ambiguity.authority)
+      continue;
+    throw new Error(
+      `Commit preparation placement for "${childKey}" has ambiguous ${ambiguity.authority} parents ${[
+        ...ambiguity.parents
+      ].sort().map((parent) => `"${parent}"`).join(" and ")}.`
+    );
+  }
+  return records2.map((record3) => {
+    const parent = parentByChild.get(commitPreparationRecordKey(record3));
+    return parent === void 0 ? record3 : {
+      ...record3,
+      parentRecordKind: parent.recordKind,
+      parentRecordId: parent.recordId
+    };
+  });
+}
+function commitPreparationPackedRootIds(records2) {
+  const rootIdByChildId = /* @__PURE__ */ new Map();
+  for (const record3 of records2) {
+    if (record3.recordKind !== "value") continue;
+    if (!isMemberValue(record3.data)) continue;
+    if (!rowCarriesPackedValueContent(record3.data)) continue;
+    for (const position of packedValuePositions(record3.data)) {
+      rootIdByChildId.set(position.valueId, record3.recordId);
+    }
+  }
+  return rootIdByChildId;
+}
+function readCommitPreparationScopeInMemory(args) {
+  const records2 = withCommitPreparationInMemoryPlacement(args.records);
+  const recordsByKey = new Map(
+    records2.map((record3) => [commitPreparationRecordKey(record3), record3])
+  );
+  const packedRootIdByChildId = commitPreparationPackedRootIds(records2);
+  const exactStates = /* @__PURE__ */ new Map();
+  const packedRootKeyByExactKey = /* @__PURE__ */ new Map();
+  for (const record3 of args.request.exactRecords) {
+    const key = commitPreparationRecordKey(record3);
+    if (recordsByKey.has(key)) {
+      exactStates.set(key, "live");
+      continue;
+    }
+    const rootId = record3.recordKind === "value" ? packedRootIdByChildId.get(record3.recordId) : void 0;
+    if (rootId === void 0) {
+      exactStates.set(key, "absent");
+      continue;
+    }
+    const rootKey = commitPreparationRecordKey({
+      recordKind: "value",
+      recordId: rootId
+    });
+    exactStates.set(key, "live");
+    exactStates.set(rootKey, "live");
+    packedRootKeyByExactKey.set(key, rootKey);
+  }
+  const keysByKind = /* @__PURE__ */ new Map();
+  const sourceOnlyKeys = [];
+  const valueKeysByMemberId = /* @__PURE__ */ new Map();
+  const valueKeysByClassId = /* @__PURE__ */ new Map();
+  const valueKeysByContainerId = /* @__PURE__ */ new Map();
+  const valueKeysByWorldKind = /* @__PURE__ */ new Map();
+  const childKeysByParentKey = /* @__PURE__ */ new Map();
+  const worldKindsByClass = args.document === void 0 ? /* @__PURE__ */ new Map() : worldKindByClassId(args.document);
+  const semanticOwners = args.document === void 0 ? /* @__PURE__ */ new Map() : resolveSemanticOwnerMembersForValues(
+    args.document,
+    new Set(args.document.values.map((value) => value.id))
+  );
+  const rememberIndexed = (index, target, key) => {
+    if (typeof target !== "string") return;
+    const values = index.get(target) ?? [];
+    values.push(key);
+    index.set(target, values);
+  };
+  for (const record3 of records2) {
+    const key = commitPreparationRecordKey(record3);
+    const kindKeys = keysByKind.get(record3.recordKind) ?? [];
+    kindKeys.push(key);
+    keysByKind.set(record3.recordKind, kindKeys);
+    if (containsAuthoredNeoScriptSource(record3.data) && !containsCompiledNeoScriptBody(record3.data)) {
+      sourceOnlyKeys.push(key);
+    }
+    if (record3.recordKind !== "value") continue;
+    const data = record3.data !== null && typeof record3.data === "object" ? record3.data : {};
+    const explicitMemberId = Reflect.get(data, "valueMemberId") ?? Reflect.get(data, "memberId");
+    rememberIndexed(
+      valueKeysByMemberId,
+      explicitMemberId ?? Reflect.get(semanticOwners.get(record3.recordId) ?? {}, "id"),
+      key
+    );
+    rememberIndexed(valueKeysByClassId, Reflect.get(data, "classId"), key);
+    const classId = Reflect.get(data, "classId");
+    if (typeof classId === "string") {
+      rememberIndexed(
+        valueKeysByWorldKind,
+        worldKindsByClass.get(classId),
+        key
+      );
+    }
+    rememberIndexed(
+      valueKeysByContainerId,
+      Reflect.get(data, "containerId"),
+      key
+    );
+  }
+  const rememberChild = (parentKey, childKey) => {
+    const children = childKeysByParentKey.get(parentKey) ?? [];
+    if (!children.includes(childKey)) children.push(childKey);
+    childKeysByParentKey.set(parentKey, children);
+  };
+  for (const record3 of records2) {
+    const sourceKey = commitPreparationRecordKey(record3);
+    const parentRecordKind = record3.parentRecordKind;
+    const parentRecordId = record3.parentRecordId;
+    if (typeof parentRecordKind === "string" && typeof parentRecordId === "string") {
+      const parentKey = `${parentRecordKind}:${parentRecordId}`;
+      rememberChild(parentKey, sourceKey);
+    }
+  }
+  const rangeRecordKeys = /* @__PURE__ */ new Map();
+  for (const request of args.request.ranges) {
+    const matching = request.rangeKind === "record-kind" ? keysByKind.get(request.targetKey) ?? [] : request.rangeKind === "source-only" ? sourceOnlyKeys : request.rangeKind === "value-member" ? valueKeysByMemberId.get(request.targetKey) ?? [] : request.rangeKind === "value-class" ? valueKeysByClassId.get(request.targetKey) ?? [] : request.rangeKind === "container-members" ? valueKeysByContainerId.get(request.targetKey) ?? [] : request.rangeKind === "children" ? childKeysByParentKey.get(request.targetKey) ?? [] : request.rangeKind === "world-kind" ? valueKeysByWorldKind.get(request.targetKey) ?? [] : keysByKind.get("value") ?? [];
+    if (matching.length > request.limit) {
+      return {
+        kind: "fallback",
+        reason: {
+          code: "range-row-cap-exceeded",
+          requestKey: commitPreparationRangeRequestKey(request),
+          observed: matching.length,
+          limit: request.limit
+        }
+      };
+    }
+    rangeRecordKeys.set(
+      commitPreparationRangeRequestKey(request),
+      [...matching].sort()
+    );
+  }
+  const persisted = [];
+  for (const record3 of records2) {
+    const extraction = extractProjectSnapshotDerivedEdges(record3);
+    if (!extraction.complete && args.request.postings.some(
+      (request) => request.edgeKind === "constructor-aggregate"
+    )) {
+      return {
+        kind: "fallback",
+        reason: {
+          code: "derived-edge-extraction-incomplete",
+          recordKey: commitPreparationRecordKey(record3)
+        }
+      };
+    }
+    for (const edge of extraction.edges) {
+      persisted.push({ ...record3, ...edge });
+    }
+  }
+  const overlaid = overlayCommitPreparationDerivedEdgePostings({
+    requests: args.request.postings,
+    persisted,
+    prepared: args.prepared
+  });
+  if (overlaid.kind === "fallback") return overlaid;
+  return {
+    kind: "complete",
+    value: {
+      exactStates,
+      packedRootKeyByExactKey,
+      rangeRecordKeys,
+      postingSourceKeys: new Map(
+        [...overlaid.value].map(([key, edges]) => [
+          key,
+          edges.map(commitPreparationRecordKey)
+        ])
+      )
+    }
+  };
+}
+function commitPreparationRecordKey(record3) {
+  return `${record3.recordKind}:${record3.recordId}`;
+}
+function commitPreparationRangeRequestKey(request) {
+  return `${request.rangeKind}:${request.targetKey}`;
+}
+function commitPreparationPostingRequestKey(request) {
+  return `${request.edgeKind}:${request.targetKey}`;
+}
+function overlayCommitPreparationDerivedEdgePostings(args) {
+  const requestsByKey = /* @__PURE__ */ new Map();
+  const answersByKey = /* @__PURE__ */ new Map();
+  for (const request of args.requests) {
+    const key = commitPreparationPostingRequestKey(request);
+    const prior = requestsByKey.get(key);
+    if (prior === void 0 || prior.limit < request.limit) {
+      requestsByKey.set(key, request);
+    }
+    if (!answersByKey.has(key)) answersByKey.set(key, /* @__PURE__ */ new Map());
+  }
+  const preparedBySource = /* @__PURE__ */ new Map();
+  for (const change of args.prepared) {
+    preparedBySource.set(commitPreparationRecordKey(change), change);
+  }
+  for (const edge of args.persisted) {
+    const requestKey = commitPreparationPostingRequestKey(edge);
+    const answer = answersByKey.get(requestKey);
+    if (answer === void 0) continue;
+    if (preparedBySource.has(commitPreparationRecordKey(edge))) continue;
+    rememberOverlayEdge(answer, { ...edge, origin: "persisted" });
+  }
+  const constructorAggregateRequested = [...requestsByKey.values()].some(
+    (request) => request.edgeKind === "constructor-aggregate"
+  );
+  for (const change of preparedBySource.values()) {
+    if (change.operation === "delete" || change.deleted === true) continue;
+    if (change.nextData === void 0) {
+      return {
+        kind: "fallback",
+        reason: {
+          code: "prepared-edge-source-missing-data",
+          recordKey: commitPreparationRecordKey(change)
+        }
+      };
+    }
+    const extraction = extractProjectSnapshotDerivedEdges({
+      recordKind: change.recordKind,
+      recordId: change.recordId,
+      data: change.nextData,
+      constructorAggregateEdges: change.constructorAggregateEdges
+    });
+    if (!extraction.complete && constructorAggregateRequested) {
+      return {
+        kind: "fallback",
+        reason: {
+          code: "derived-edge-extraction-incomplete",
+          recordKey: commitPreparationRecordKey(change)
+        }
+      };
+    }
+    for (const edge of extraction.edges) {
+      const requestKey = commitPreparationPostingRequestKey(edge);
+      const answer = answersByKey.get(requestKey);
+      if (answer === void 0) continue;
+      rememberOverlayEdge(answer, {
+        ...edge,
+        recordKind: change.recordKind,
+        recordId: change.recordId,
+        origin: "prepared"
+      });
+    }
+  }
+  const result = /* @__PURE__ */ new Map();
+  for (const [requestKey, answer] of answersByKey) {
+    const request = requestsByKey.get(requestKey);
+    if (request === void 0) continue;
+    if (answer.size > request.limit) {
+      return {
+        kind: "fallback",
+        reason: {
+          code: "posting-budget-exceeded",
+          requestKey,
+          observed: answer.size,
+          limit: request.limit
+        }
+      };
+    }
+    result.set(
+      requestKey,
+      [...answer.values()].sort(
+        (left, right) => overlayEdgeKey(left).localeCompare(overlayEdgeKey(right))
+      )
+    );
+  }
+  return { kind: "complete", value: result };
+}
+function rememberOverlayEdge(answer, edge) {
+  answer.set(overlayEdgeKey(edge), edge);
+}
+function overlayEdgeKey(edge) {
+  return `${commitPreparationRecordKey(edge)}:${projectSnapshotDerivedEdgeIdentity(edge)}`;
+}
+function commitPreparationValidationCandidateMemberIds(document) {
+  const result = /* @__PURE__ */ new Set();
+  for (const member of document.members) {
+    if (member.kind === 26 /* NSAction */ || member.kind === 27 /* Variant */ || isReadOnlyMember(member)) {
+      result.add(member.id);
+    }
+  }
+  return result;
+}
+function projectDocumentRecordsByKey(document) {
+  const result = /* @__PURE__ */ new Map();
+  const add = (recordKind, records2) => {
+    for (const record3 of records2) {
+      if (record3 === null || typeof record3 !== "object") continue;
+      const recordId = Reflect.get(record3, "id");
+      if (typeof recordId !== "string") continue;
+      result.set(commitPreparationRecordKey({ recordKind, recordId }), record3);
+    }
+  };
+  add("project", [document.project]);
+  add("member", document.members ?? []);
+  add("class", document.classes ?? []);
+  add("constructor", document.constructors ?? []);
+  add("variant", document.variants ?? []);
+  add("variant-folder", document.variantFolders ?? []);
+  add("enum", document.enums ?? []);
+  add("interface", document.interfaces ?? []);
+  add("internal-record-relation", document.internalRecordRelations ?? []);
+  add("project-file", document.projectFiles ?? []);
+  add("dialogue", document.dialogueRecords ?? document.dialogues ?? []);
+  add("dialogue-node", document.dialogueNodes ?? []);
+  add("dialogue-group", document.dialogueGroups ?? []);
+  add("priority-group", document.priorityGroups ?? []);
+  add("unity-texture-template", document.textureTemplates ?? []);
+  add("unity-audio-clip-template", document.audioClipTemplates ?? []);
+  if (document.localizationConfig !== null) {
+    add("localization-config", [document.localizationConfig]);
+  }
+  add("localization-status", document.localizationStatuses ?? []);
+  add("localized-text", document.localizedTexts ?? []);
+  add("migration", document.migrations ?? []);
+  add("value", document.values ?? []);
+  return result;
+}
+function collectStoredRecordIds(value) {
+  const result = /* @__PURE__ */ new Set();
+  const visit = (candidate) => {
+    if (typeof candidate === "string") {
+      if (STORED_RECORD_ID_PATTERN.test(candidate)) result.add(candidate);
+      return;
+    }
+    if (Array.isArray(candidate)) {
+      for (const entry of candidate) visit(entry);
+      return;
+    }
+    if (candidate === null || typeof candidate !== "object") return;
+    for (const entry of Object.values(candidate)) visit(entry);
+  };
+  visit(value);
+  return result;
+}
+function containsInitializerSource(value) {
+  if (Array.isArray(value)) return value.some(containsInitializerSource);
+  if (value === null || typeof value !== "object") return false;
+  const record3 = value;
+  if (record3.init !== null && typeof record3.init === "object" && typeof Reflect.get(record3.init, "code") === "string") {
+    return true;
+  }
+  return Object.values(record3).some(containsInitializerSource);
+}
+function compareRecordKeys(left, right) {
+  return commitPreparationRecordKey(left).localeCompare(
+    commitPreparationRecordKey(right)
+  );
+}
+var COMMIT_PREPARATION_SCOPE_RANGE_ROW_LIMIT, COMMIT_PREPARATION_SCOPE_POSTING_ROW_LIMIT, COMMIT_PREPARATION_SCOPE_SOURCE_ONLY_ROW_LIMIT, STORED_RECORD_ID_PATTERN;
+var init_project_commit_preparation_scoped_loader = __esm({
+  "../src/database/project-commit-preparation-scoped-loader.ts"() {
+    "use strict";
+    init_member_kind_enum();
+    init_members();
+    init_inheritance();
+    init_core();
+    init_member_value_id();
+    init_member_kinds();
+    init_packed_value_encoding();
+    init_variants2();
+    init_project_snapshot_derived_edges();
+    init_neo_script_recompile_scope();
+    init_constructor_argument_ownership();
+    init_commit_preparation_scope_planner();
+    init_commit_preparation_animation_scope();
+    COMMIT_PREPARATION_SCOPE_RANGE_ROW_LIMIT = 4096;
+    COMMIT_PREPARATION_SCOPE_POSTING_ROW_LIMIT = 64;
+    COMMIT_PREPARATION_SCOPE_SOURCE_ONLY_ROW_LIMIT = 64;
+    STORED_RECORD_ID_PATTERN = /^(?:system_)?[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu;
+  }
+});
+
 // src/project-source/server-preparation-preflight.ts
 function assertServerPreparationSucceeds(args) {
   for (const change of args.changes) {
@@ -105712,6 +107321,7 @@ function assertServerPreparationSucceeds(args) {
     });
     if (refusal !== null) throw new ServerPreparationPreflightError(refusal);
   }
+  assertDerivedEdgeCompatibility(args.workspace);
   try {
     const prepared = prepareServerPreparationChanges(args);
     if (args.localInitializerMaterialization !== void 0) {
@@ -105725,6 +107335,42 @@ function assertServerPreparationSucceeds(args) {
     throw locateBodyCompileFailure(error, args.sourceByRecord);
   }
 }
+function assertDerivedEdgeCompatibility(workspace) {
+  const localVersion = PROJECT_SNAPSHOT_DERIVED_EDGE_EXTRACTOR_VERSION;
+  const serverVersion = workspace.state.derivedEdgeVersion;
+  if (serverVersion === void 0) {
+    throw new DerivedEdgeCompatibilityError(
+      "workspace-metadata-missing",
+      localVersion,
+      serverVersion,
+      "Dry-run server rehearsal requires derived-edge compatibility metadata. Run `neo pull` with this CLI, then retry."
+    );
+  }
+  if (serverVersion === null) {
+    throw new DerivedEdgeCompatibilityError(
+      "watermark-missing",
+      localVersion,
+      serverVersion,
+      `Project "${workspace.config.projectId}" has no derived-edge watermark. Run \`neo pull\` and retry. If this persists, repair the project's derived edge index.`
+    );
+  }
+  if (serverVersion > localVersion) {
+    throw new DerivedEdgeCompatibilityError(
+      "cli-stale",
+      localVersion,
+      serverVersion,
+      `This CLI uses derived-edge extractor v${localVersion}, but project "${workspace.config.projectId}" requires v${serverVersion}. Upgrade @neocompose/cli, run \`neo pull\`, then retry.`
+    );
+  }
+  if (serverVersion < localVersion) {
+    throw new DerivedEdgeCompatibilityError(
+      "server-stale",
+      localVersion,
+      serverVersion,
+      `This CLI uses derived-edge extractor v${localVersion}, but project "${workspace.config.projectId}" reports v${serverVersion}. Run \`neo pull\` and retry. If this persists, update the server and repair the project's derived edge index.`
+    );
+  }
+}
 function assertInitializerMaterializationParity(local, prepared) {
   const rowsById = /* @__PURE__ */ new Map();
   const createdByRoot = /* @__PURE__ */ new Map();
@@ -105796,9 +107442,27 @@ function locateBodyCompileFailure(error, sourceByRecord) {
   if (source === void 0) return error;
   return new Error(`${source.file}:${source.line} \u2014 ${error.message}`);
 }
+function prepareWithScopedSafetyValve(args) {
+  try {
+    const scoped = args.prepareScoped();
+    if (scoped !== null) {
+      args.validate(scoped);
+      return scoped;
+    }
+  } catch {
+  }
+  const full = args.prepareFull();
+  args.validate(full);
+  return full;
+}
 function prepareServerPreparationChanges(args) {
+  const serverTimestamp = args.serverTimestamp ?? Date.now();
   const rawDocument = pulledProjectDocumentRaw(args.workspace);
-  const document = readProjectDocument(rawDocument);
+  const document = withReplayValueIdFactory(
+    withStoredValueBase(readProjectDocument(rawDocument)),
+    args.createValueId,
+    serverTimestamp
+  );
   const contentHashHeads = readProjectDocumentContentHashHeads(rawDocument);
   const changes = args.changes.map((change) => ({
     ...change,
@@ -105809,9 +107473,44 @@ function prepareServerPreparationChanges(args) {
   }));
   const trustedChanges = stampServerOwnedSourceCommitMetadata({
     rawDocument,
-    changes
+    changes,
+    timestamp: serverTimestamp
   });
-  const prepared = prepareServerOwnedSchemaCommit({
+  const placedRecords = () => {
+    const canonicalPlacementByValueId = projectValueHeadPlacementGraph({
+      rootMembers: [
+        { id: document.project.rootAssetsMemberId, label: "Assets" },
+        { id: document.project.rootSaveFileMemberId, label: "Save" },
+        { id: document.project.rootSessionMemberId, label: "Session" }
+      ],
+      variantRoots: (document.variants ?? []).map((variant) => ({
+        variantId: variant.id,
+        valueId: variant.valueId
+      })),
+      members: document.members,
+      classes: document.classes,
+      values: document.values
+    });
+    return withCommitPreparationInMemoryPlacement(
+      Object.values(args.workspace.state.records).map((record3) => {
+        const recordKind = narrowRecordKind(
+          record3.recordKind,
+          `${record3.recordKind}:${record3.recordId}`
+        );
+        const placement = recordKind === "value" ? canonicalPlacementByValueId.get(record3.recordId) : void 0;
+        return {
+          recordKind,
+          recordId: record3.recordId,
+          data: record3.data,
+          ...placement?.parentRecordKind === null || placement?.parentRecordKind === void 0 || placement.parentRecordId === null ? {} : {
+            parentRecordKind: placement.parentRecordKind,
+            parentRecordId: placement.parentRecordId
+          }
+        };
+      })
+    );
+  };
+  const preparationArgs = {
     document,
     contentHashHeads,
     changes: trustedChanges,
@@ -105820,10 +107519,258 @@ function prepareServerPreparationChanges(args) {
     // A CLI push is always a trusted-source commit, so the server always
     // expands read-only source conversions for it.
     expandReadOnlySourceConversions: true,
-    forceRecompile: args.forceRecompile
+    forceRecompile: args.forceRecompile,
+    serverTimestamp,
+    createLocalizedTextId: args.createLocalizedTextId
+  };
+  const prepareFull = (discardedScopedAttempt) => {
+    if (discardedScopedAttempt) args.resetReplayIds?.();
+    return prepareServerOwnedSchemaCommit(preparationArgs);
+  };
+  const validate2 = (prepared) => assertProjectVersionWholeGraphWritesValid({ document, changes: prepared });
+  if (args.forceRecompile === true) {
+    const prepared = prepareFull(false);
+    validate2(prepared);
+    return prepared;
+  }
+  return prepareWithScopedSafetyValve({
+    prepareScoped: () => {
+      const records2 = placedRecords();
+      const initialScope = planCommitPreparationInitialScope({
+        pass: COMMIT_PREPARATION_PASS_ORDER[0],
+        document,
+        changes,
+        authoredValueSeeds: args.authoredValueSeeds,
+        rangeLimit: COMMIT_PREPARATION_SCOPE_RANGE_ROW_LIMIT,
+        postingLimit: COMMIT_PREPARATION_SCOPE_POSTING_ROW_LIMIT
+      });
+      if (initialScope.fullContentDimension) return null;
+      const scopeAnswer = readCommitPreparationScopeInMemory({
+        request: initialScope,
+        records: records2,
+        prepared: changes,
+        document
+      });
+      if (scopeAnswer.kind === "fallback") return null;
+      const selectedContentKeys = /* @__PURE__ */ new Set();
+      const descendantRootKeys = /* @__PURE__ */ new Set();
+      const absentExactKeys = /* @__PURE__ */ new Set();
+      absorbInMemoryScopeAnswer(
+        selectedContentKeys,
+        scopeAnswer.value,
+        descendantRootKeys,
+        scopeDescendantKeys(initialScope),
+        scopeDescendantRangeKeys(initialScope),
+        absentExactKeys
+      );
+      const initialClosed = closeInMemoryLoadedScope({
+        records: records2,
+        selected: selectedContentKeys,
+        descendantRoots: descendantRootKeys,
+        absentExactKeys,
+        prepared: changes,
+        document,
+        pass: COMMIT_PREPARATION_PASS_ORDER[0]
+      });
+      if (!initialClosed) return null;
+      const scopedDocument = selectPreparationContentRows(
+        document,
+        selectedContentKeys
+      );
+      const scopedHeads = contentHashHeads.filter(
+        (head) => !COMMIT_PREPARATION_CLI_CONTENT_KINDS.has(head.recordKind) || selectedContentKeys.has(`${head.recordKind}:${head.recordId}`)
+      );
+      const passes = prepareServerOwnedSchemaCommitPasses({
+        ...preparationArgs,
+        document: scopedDocument,
+        contentHashHeads: scopedHeads
+      });
+      for (; ; ) {
+        const step = passes.next();
+        if (step.done) return step.value;
+        const topUpRequest = planCommitPreparationInitialScope({
+          pass: nextCommitPreparationPass(step.value.pass) ?? step.value.pass,
+          document: scopedDocument,
+          changes: step.value.preparedChanges,
+          authoredValueSeeds: args.authoredValueSeeds,
+          rangeLimit: COMMIT_PREPARATION_SCOPE_RANGE_ROW_LIMIT,
+          postingLimit: COMMIT_PREPARATION_SCOPE_POSTING_ROW_LIMIT
+        });
+        if (topUpRequest.fullContentDimension) return null;
+        const topUpAnswer = readCommitPreparationScopeInMemory({
+          request: topUpRequest,
+          records: records2,
+          prepared: step.value.preparedChanges,
+          document
+        });
+        if (topUpAnswer.kind === "fallback") return null;
+        absorbInMemoryScopeAnswer(
+          selectedContentKeys,
+          topUpAnswer.value,
+          descendantRootKeys,
+          scopeDescendantKeys(topUpRequest),
+          scopeDescendantRangeKeys(topUpRequest),
+          absentExactKeys
+        );
+        for (const change of step.value.preparedChanges) {
+          if (change.operation === "delete" || change.deleted === true)
+            continue;
+          descendantRootKeys.add(`${change.recordKind}:${change.recordId}`);
+        }
+        if (!closeInMemoryLoadedScope({
+          records: records2,
+          selected: selectedContentKeys,
+          descendantRoots: descendantRootKeys,
+          absentExactKeys,
+          prepared: step.value.preparedChanges,
+          document,
+          pass: nextCommitPreparationPass(step.value.pass) ?? step.value.pass
+        })) {
+          return null;
+        }
+        Object.assign(
+          scopedDocument,
+          selectPreparationContentRows(document, selectedContentKeys)
+        );
+        scopedHeads.splice(
+          0,
+          scopedHeads.length,
+          ...contentHashHeads.filter(
+            (head) => !COMMIT_PREPARATION_CLI_CONTENT_KINDS.has(head.recordKind) || selectedContentKeys.has(`${head.recordKind}:${head.recordId}`)
+          )
+        );
+      }
+    },
+    prepareFull: () => prepareFull(true),
+    validate: validate2
   });
-  assertProjectVersionWholeGraphWritesValid({ document, changes: prepared });
-  return prepared;
+}
+function withReplayValueIdFactory(document, createValueId, timestamp) {
+  if (createValueId === void 0) return document;
+  return Object.assign(document, {
+    createValueRow: (projectId, body) => {
+      const value = buildNewValue(projectId, body, timestamp);
+      value.id = createValueId();
+      return value;
+    }
+  });
+}
+function absorbInMemoryScopeAnswer(selected, answer, descendantRoots, descendantExactKeys = /* @__PURE__ */ new Set(), descendantRangeKeys = /* @__PURE__ */ new Set(), absentExactKeys) {
+  for (const [key, state] of answer.exactStates) {
+    if (state !== "live") {
+      absentExactKeys?.add(key);
+      continue;
+    }
+    const selectedKey = answer.packedRootKeyByExactKey.get(key) ?? key;
+    selected.add(selectedKey);
+    if (descendantExactKeys.has(key)) descendantRoots?.add(selectedKey);
+  }
+  for (const [requestKey, keys] of answer.rangeRecordKeys) {
+    for (const key of keys) {
+      selected.add(key);
+      if (descendantRangeKeys.has(requestKey)) descendantRoots?.add(key);
+    }
+  }
+  for (const keys of answer.postingSourceKeys.values()) {
+    for (const key of keys) {
+      selected.add(key);
+    }
+  }
+}
+function closeInMemoryLoadedScope(args) {
+  const animationSchema = commitPreparationAnimationSchema(args.document);
+  for (; ; ) {
+    const closureRecords = args.records.filter(
+      (record3) => args.selected.has(`${record3.recordKind}:${record3.recordId}`)
+    ).map((record3) => ({
+      ...record3,
+      includeDescendants: args.descendantRoots.has(
+        `${record3.recordKind}:${record3.recordId}`
+      )
+    }));
+    const request = planCommitPreparationLoadedClosureScope({
+      pass: args.pass,
+      records: closureRecords,
+      rangeLimit: COMMIT_PREPARATION_SCOPE_RANGE_ROW_LIMIT,
+      postingLimit: COMMIT_PREPARATION_SCOPE_POSTING_ROW_LIMIT,
+      animationSchema
+    });
+    const answer = readCommitPreparationScopeInMemory({
+      request,
+      records: args.records,
+      prepared: args.prepared,
+      document: args.document
+    });
+    if (answer.kind === "fallback") return false;
+    const priorSelectedSize = args.selected.size;
+    const priorDescendantSize = args.descendantRoots.size;
+    absorbInMemoryScopeAnswer(
+      args.selected,
+      answer.value,
+      args.descendantRoots,
+      scopeDescendantKeys(request),
+      scopeDescendantRangeKeys(request),
+      args.absentExactKeys
+    );
+    if (args.selected.size === priorSelectedSize && args.descendantRoots.size === priorDescendantSize) {
+      return selectedAncestorPathsIntact(
+        args.records,
+        args.selected,
+        args.absentExactKeys
+      );
+    }
+  }
+}
+function selectedAncestorPathsIntact(records2, selected, absentExactKeys) {
+  if (absentExactKeys.size === 0) return true;
+  const selectedRecords = records2.filter(
+    (record3) => selected.has(`${record3.recordKind}:${record3.recordId}`)
+  );
+  const packedRootIdByChildId = commitPreparationPackedRootIds(selectedRecords);
+  for (const record3 of selectedRecords) {
+    if (record3.recordKind !== "value") continue;
+    if (record3.parentRecordKind !== "value") continue;
+    const parentId = record3.parentRecordId;
+    if (typeof parentId !== "string") continue;
+    if (selected.has(`value:${parentId}`)) continue;
+    if (packedRootIdByChildId.has(parentId)) continue;
+    if (absentExactKeys.has(`value:${parentId}`)) return false;
+  }
+  return true;
+}
+function scopeDescendantRangeKeys(scope) {
+  return new Set(
+    scope.ranges.filter(
+      (range2) => range2.rangeKind === "children" || range2.rangeKind === "container-members"
+    ).map((range2) => `${range2.rangeKind}:${range2.targetKey}`)
+  );
+}
+function scopeDescendantKeys(scope) {
+  return new Set(
+    (scope.descendantRecords ?? []).map(
+      (record3) => `${record3.recordKind}:${record3.recordId}`
+    )
+  );
+}
+function selectPreparationContentRows(document, selected) {
+  const physicalValues = (document.physicalValues ?? document.values).filter(
+    (row) => selected.has(`value:${row.id}`)
+  );
+  const values = expandPackedValueRows(physicalValues);
+  return {
+    ...document,
+    values: values === physicalValues ? physicalValues : [...values],
+    physicalValues,
+    dialogueNodes: (document.dialogueNodes ?? []).filter(
+      (row) => selected.has(`dialogue-node:${row.id}`)
+    ),
+    migrations: (document.migrations ?? []).filter(
+      (row) => selected.has(`migration:${row.id}`)
+    ),
+    localizedTexts: (document.localizedTexts ?? []).filter(
+      (row) => selected.has(`localized-text:${row.id}`)
+    )
+  };
 }
 function pulledProjectDocumentRaw(workspace) {
   const records2 = [];
@@ -105900,7 +107847,7 @@ function syntheticVersionMetadata(workspace) {
     releaseChannels: []
   };
 }
-var ServerPreparationPreflightError;
+var ServerPreparationPreflightError, DerivedEdgeCompatibilityError, COMMIT_PREPARATION_CLI_CONTENT_KINDS;
 var init_server_preparation_preflight = __esm({
   "src/project-source/server-preparation-preflight.ts"() {
     "use strict";
@@ -105910,13 +107857,33 @@ var init_server_preparation_preflight = __esm({
     init_project_version_whole_graph_validation();
     init_projectRecordBuckets();
     init_compile_ns_property();
+    init_valueHeadPlacementGraph();
     init_projection();
+    init_project_snapshot_derived_edges();
+    init_project_commit_preparation_scoped_loader();
+    init_packed_value_encoding();
+    init_commit_preparation_animation_scope();
+    init_commit_preparation_scope_planner();
+    init_build_default_member_value();
     ServerPreparationPreflightError = class extends Error {
       constructor(message) {
         super(message);
         this.name = "ServerPreparationPreflightError";
       }
     };
+    DerivedEdgeCompatibilityError = class extends ServerPreparationPreflightError {
+      constructor(reason, localVersion, serverVersion, message) {
+        super(message);
+        this.reason = reason;
+        this.localVersion = localVersion;
+        this.serverVersion = serverVersion;
+        this.name = "DerivedEdgeCompatibilityError";
+      }
+      reason;
+      localVersion;
+      serverVersion;
+    };
+    COMMIT_PREPARATION_CLI_CONTENT_KINDS = /* @__PURE__ */ new Set(["value", "dialogue-node", "localized-text", "migration"]);
   }
 });
 
@@ -115325,7 +117292,8 @@ async function queryProjectDocumentSyncMarker(workspace, convex) {
   return {
     revision: revisionValue,
     headTransactionId: signal?.transactionId ?? null,
-    headTransactionHash: signal?.transactionHash ?? null
+    headTransactionHash: signal?.transactionHash ?? null,
+    derivedEdgeVersion: signal?.derivedEdgeVersion ?? null
   };
 }
 async function fetchProjectDocumentDelta(workspace, cursor) {
@@ -115334,7 +117302,8 @@ async function fetchProjectDocumentDelta(workspace, cursor) {
   if (marker.revision.versionsStamp !== cursor.versionsStamp) {
     return {
       fullResync: true,
-      headTransactionHash: marker.headTransactionHash
+      headTransactionHash: marker.headTransactionHash,
+      derivedEdgeVersion: marker.derivedEdgeVersion
     };
   }
   if (marker.headTransactionId === marker.revision.latestTransactionId && marker.headTransactionHash === workspace.state.headTransactionHash) {
@@ -115343,7 +117312,8 @@ async function fetchProjectDocumentDelta(workspace, cursor) {
       document: projectDocumentFromWorkspaceState(workspace.state, cursor),
       changedKeys: /* @__PURE__ */ new Set(),
       cursor,
-      headTransactionHash: marker.headTransactionHash
+      headTransactionHash: marker.headTransactionHash,
+      derivedEdgeVersion: marker.derivedEdgeVersion
     };
   }
   const result = await convex.query(api2.projectDocuments.getRecordsSince, {
@@ -115355,7 +117325,8 @@ async function fetchProjectDocumentDelta(workspace, cursor) {
   if (result.fullResync) {
     return {
       fullResync: true,
-      headTransactionHash: marker.headTransactionHash
+      headTransactionHash: marker.headTransactionHash,
+      derivedEdgeVersion: marker.derivedEdgeVersion
     };
   }
   const document = projectDocumentFromWorkspaceState(workspace.state, cursor);
@@ -115404,7 +117375,8 @@ async function fetchProjectDocumentDelta(workspace, cursor) {
     document: projectDocumentWithRevision(document, nextCursor),
     changedKeys,
     cursor: nextCursor,
-    headTransactionHash: marker.headTransactionHash
+    headTransactionHash: marker.headTransactionHash,
+    derivedEdgeVersion: marker.derivedEdgeVersion
   };
 }
 function projectDocumentFromWorkspaceState(state, cursor) {
@@ -116385,6 +118357,7 @@ ${blockingErrors.map((error) => `  ${error.message}`).join("\n")}`
   let changedRecordKeys = null;
   let nextCursor = null;
   let observedHeadTransactionHash;
+  let observedDerivedEdgeVersion;
   let document = null;
   if (!destructive && hasBaseline) {
     progress.update("Checking remote changes\u2026");
@@ -116392,6 +118365,7 @@ ${blockingErrors.map((error) => `  ${error.message}`).join("\n")}`
     if (cursor !== void 0) {
       const delta = await fetchProjectDocumentDelta(workspace, cursor);
       observedHeadTransactionHash = delta.headTransactionHash;
+      observedDerivedEdgeVersion = delta.derivedEdgeVersion;
       if (!delta.fullResync) {
         document = delta.document;
         changedRecordKeys = delta.changedKeys;
@@ -116402,11 +118376,13 @@ ${blockingErrors.map((error) => `  ${error.message}`).join("\n")}`
             delta.cursor
           );
           const headChanged = workspace.state.headTransactionHash !== delta.headTransactionHash;
-          if (cursorChanged || headChanged) {
+          const derivedEdgeVersionChanged = workspace.state.derivedEdgeVersion !== delta.derivedEdgeVersion;
+          if (cursorChanged || headChanged || derivedEdgeVersionChanged) {
             workspace.state.documentRevisionCursor = mutableCursor(
               delta.cursor
             );
             workspace.state.headTransactionHash = delta.headTransactionHash;
+            workspace.state.derivedEdgeVersion = delta.derivedEdgeVersion;
             writeWorkspaceState(workspace.root, workspace.state);
           }
           progress.succeed("Already up to date.");
@@ -116416,9 +118392,11 @@ ${blockingErrors.map((error) => `  ${error.message}`).join("\n")}`
     } else if (!options.regenerateSourceNames && workspace.state.headTransactionHash !== void 0) {
       const marker = await fetchProjectDocumentSyncMarker(workspace);
       observedHeadTransactionHash = marker.headTransactionHash;
+      observedDerivedEdgeVersion = marker.derivedEdgeVersion;
       if (marker.headTransactionId === marker.revision.latestTransactionId && marker.headTransactionHash === workspace.state.headTransactionHash) {
         const seededCursor = cursorFromRevision(marker.revision);
         workspace.state.documentRevisionCursor = mutableCursor(seededCursor);
+        workspace.state.derivedEdgeVersion = marker.derivedEdgeVersion;
         writeWorkspaceState(workspace.root, workspace.state);
         progress.succeed("Already up to date.");
         return;
@@ -116557,6 +118535,7 @@ ${blockingErrors.map((error) => `  ${error.message}`).join("\n")}`
     changedRecordKeys,
     nextCursor,
     observedHeadTransactionHash,
+    observedDerivedEdgeVersion,
     progress
   });
 }
@@ -116591,8 +118570,10 @@ async function runResetPull(workspace) {
         versionId: workspace.config.versionId
       });
       workspace.state.headTransactionHash = document.revision !== void 0 && signal?.transactionId === document.revision.latestTransactionId ? signal.transactionHash : null;
+      workspace.state.derivedEdgeVersion = signal?.derivedEdgeVersion ?? null;
     } catch {
       workspace.state.headTransactionHash = null;
+      delete workspace.state.derivedEdgeVersion;
     }
     if (document.revision !== void 0) {
       workspace.state.documentRevisionCursor = mutableCursor(
@@ -116624,6 +118605,7 @@ async function finishFormat4Pull(args) {
     changedRecordKeys,
     nextCursor,
     observedHeadTransactionHash,
+    observedDerivedEdgeVersion,
     progress
   } = args;
   if (changedRecordKeys !== null && !regenerateSourceNames && conflictCount === 0 && localStatus !== null && !deltaRequiresSourceProjectionV4({
@@ -116639,6 +118621,7 @@ async function finishFormat4Pull(args) {
       changedRecordKeys,
       nextCursor,
       observedHeadTransactionHash,
+      observedDerivedEdgeVersion,
       progress
     });
     return;
@@ -116823,10 +118806,15 @@ async function finishFormat4Pull(args) {
         versionId: workspace.config.versionId
       });
       workspace.state.headTransactionHash = document.revision !== void 0 && signal?.transactionId === document.revision.latestTransactionId ? signal.transactionHash : null;
+      workspace.state.derivedEdgeVersion = signal?.derivedEdgeVersion ?? null;
     } catch {
       workspace.state.headTransactionHash = null;
+      delete workspace.state.derivedEdgeVersion;
     }
   }
+  if (observedDerivedEdgeVersion !== void 0) {
+    workspace.state.derivedEdgeVersion = observedDerivedEdgeVersion;
+  }
   writeWorkspaceState(workspace.root, workspace.state);
   if (conflictCount === 0) {
     writeProjectSourceAnalysisCacheV4(workspace.root, localResult.analysis);
@@ -116986,6 +118974,9 @@ function finishRecordOnlyDeltaPull(args) {
   if (args.observedHeadTransactionHash !== void 0) {
     args.workspace.state.headTransactionHash = args.observedHeadTransactionHash;
   }
+  if (args.observedDerivedEdgeVersion !== void 0) {
+    args.workspace.state.derivedEdgeVersion = args.observedDerivedEdgeVersion;
+  }
   writeWorkspaceState(args.workspace.root, args.workspace.state);
   args.progress.succeed(
     `Pulled ${args.changedRecordKeys.size} changed record(s) \u2014 0 file(s) updated \u2014 0 removed.`
@@ -120437,7 +122428,7 @@ function normalizeSourceFiles(inputFiles) {
   return files;
 }
 function readSourceFile(value, index) {
-  const record3 = asRecord3(value, `Project source identity file ${index}`);
+  const record3 = asRecord4(value, `Project source identity file ${index}`);
   assertExactKeys(record3, ["path", "kind", "content"]);
   if (typeof record3.path !== "string" || !isSafeSourcePath(record3.path)) {
     throw new Error(
@@ -120472,7 +122463,7 @@ function isSafeSourcePath(path) {
   }
   return neoProjectSourceKind(path) !== null;
 }
-function asRecord3(value, label) {
+function asRecord4(value, label) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
     throw new Error(`${label} must be an object.`);
   }
@@ -120674,6 +122665,17 @@ var init_push_hook = __esm({
 // src/project-source/project-file-push.ts
 import { basename as basename2, join as join13 } from "node:path";
 import { readFileSync as readFileSync14 } from "node:fs";
+import { randomUUID as randomUUID2 } from "node:crypto";
+async function cleanupRejectedProjectFilePushesV4(args) {
+  if (args.stagedUploadSessionId === null) return;
+  try {
+    await args.client.post(
+      versionPath(args.workspace, "files/cleanup-staged-upload"),
+      { stagedUploadSessionId: args.stagedUploadSessionId }
+    );
+  } catch {
+  }
+}
 function ensureProjectFileBinaryChangesV4(args) {
   for (const binary of args.binaryChanges) {
     if (binary.action !== "upload") continue;
@@ -120753,7 +122755,7 @@ async function stageProjectFilePushesV4(args) {
     assignedIds: args.assignedIds
   });
   const staged = [];
-  const cleanupKeys = [];
+  const stagedUploadSessionId = args.stagedUploadSessionId ?? randomUUID2();
   const put = args.put ?? fetch;
   const interruptController = new AbortController();
   const interrupt = () => interruptController.abort(new ProjectFilePushCancelledError());
@@ -120770,11 +122772,8 @@ async function stageProjectFilePushesV4(args) {
   });
   report();
   try {
-    for (let offset = 0; offset < prepared.length; offset += PROJECT_FILE_UPLOAD_BATCH_SIZE) {
-      const batch = prepared.slice(
-        offset,
-        offset + PROJECT_FILE_UPLOAD_BATCH_SIZE
-      );
+    for (let offset = 0; offset < prepared.length; offset += PRESIGN_BATCH_SIZE) {
+      const batch = prepared.slice(offset, offset + PRESIGN_BATCH_SIZE);
       const presign = await postWithTimeout(
         args.client,
         versionPath(args.workspace, "upload"),
@@ -120782,6 +122781,7 @@ async function stageProjectFilePushesV4(args) {
           route: "projectFile",
           metadata: {
             deferredSourceCommit: true,
+            stagedUploadSessionId,
             uploads: batch.map((file) => ({
               uploadToken: file.uploadToken,
               projectFileId: file.recordId,
@@ -120799,12 +122799,11 @@ async function stageProjectFilePushesV4(args) {
         signal
       );
       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(
+            await uploadWithRetry(
               put,
               entry,
               combineSignals(signal, batchController.signal)
@@ -120849,15 +122848,11 @@ async function stageProjectFilePushesV4(args) {
       return result;
     });
   } catch (error) {
-    if (cleanupKeys.length > 0) {
-      try {
-        await args.client.post(
-          versionPath(args.workspace, "files/cleanup-staged-upload"),
-          { storageKeys: cleanupKeys }
-        );
-      } catch {
-      }
-    }
+    await cleanupRejectedProjectFilePushesV4({
+      workspace: args.workspace,
+      client: args.client,
+      stagedUploadSessionId
+    });
     if (interruptController.signal.aborted || args.signal?.aborted === true) {
       throw new ProjectFilePushCancelledError();
     }
@@ -120867,7 +122862,8 @@ async function stageProjectFilePushesV4(args) {
   }
 }
 function readPresignEntries(presign, batch) {
-  const entries = Array.isArray(presign.files) ? presign.files.filter(isObjectRecord2) : [];
+  const multipart = isObjectRecord2(presign.multipart) ? presign.multipart : null;
+  const entries = Array.isArray(multipart?.files) ? multipart.files.filter(isObjectRecord2) : Array.isArray(presign.files) ? presign.files.filter(isObjectRecord2) : [];
   return batch.map((file) => {
     const entry = entries.find((candidate) => {
       const info = isObjectRecord2(candidate.file) ? candidate.file : {};
@@ -120875,21 +122871,62 @@ function readPresignEntries(presign, batch) {
     });
     const fileInfo = isObjectRecord2(entry?.file) ? entry.file : {};
     const objectInfo = isObjectRecord2(fileInfo.objectInfo) ? fileInfo.objectInfo : {};
-    if (typeof entry?.signedUrl !== "string") {
+    if (typeof objectInfo.key !== "string") {
       throw new Error(
-        `Upload presign response is missing signedUrl for ${file.name}.`
+        `Upload presign response is missing a storage key for ${file.name}.`
       );
     }
-    if (typeof objectInfo.key !== "string") {
+    if (multipart === null) {
+      if (typeof entry?.signedUrl !== "string") {
+        throw new Error(
+          `Upload presign response is missing signedUrl for ${file.name}.`
+        );
+      }
+      return {
+        protocol: "single-put",
+        file,
+        signedUrl: entry.signedUrl,
+        storageKey: objectInfo.key,
+        headers: uploadHeaders(entry, objectInfo, file.mimeType)
+      };
+    }
+    if (typeof entry?.completeSignedUrl !== "string") {
       throw new Error(
-        `Upload presign response is missing a storage key for ${file.name}.`
+        `Multipart presign response is missing completeSignedUrl for ${file.name}.`
+      );
+    }
+    if (!Array.isArray(entry.parts) || entry.parts.length === 0) {
+      throw new Error(
+        `Multipart presign response is missing parts for ${file.name}.`
+      );
+    }
+    let offset = 0;
+    const parts = entry.parts.map((candidate, index) => {
+      if (!isObjectRecord2(candidate) || candidate.partNumber !== index + 1 || typeof candidate.size !== "number" || !Number.isSafeInteger(candidate.size) || candidate.size <= 0 || typeof candidate.signedUrl !== "string") {
+        throw new Error(
+          `Multipart presign response has invalid part ${index + 1} for ${file.name}.`
+        );
+      }
+      const part = {
+        partNumber: candidate.partNumber,
+        offset,
+        size: candidate.size,
+        signedUrl: candidate.signedUrl
+      };
+      offset += candidate.size;
+      return part;
+    });
+    if (offset !== file.byteLength) {
+      throw new Error(
+        `Multipart presign response covers ${offset}/${file.byteLength} bytes for ${file.name}.`
       );
     }
     return {
+      protocol: "multipart",
       file,
-      signedUrl: entry.signedUrl,
       storageKey: objectInfo.key,
-      headers: uploadHeaders(entry, objectInfo, file.mimeType)
+      completeSignedUrl: entry.completeSignedUrl,
+      parts
     };
   });
 }
@@ -120908,7 +122945,11 @@ async function postWithTimeout(client, path, body, signal) {
   }
   throw new Error("Upload presign failed after all retry attempts.");
 }
-async function putWithRetry(put, entry, signal) {
+async function uploadWithRetry(put, entry, signal) {
+  if (entry.protocol === "multipart") {
+    await uploadMultipartWithRetry(put, entry, signal);
+    return;
+  }
   let lastError;
   for (let attempt = 1; attempt <= STORAGE_PUT_ATTEMPTS; attempt += 1) {
     let response;
@@ -120940,6 +122981,83 @@ async function putWithRetry(put, entry, signal) {
   }
   throw lastError instanceof Error ? lastError : new Error(`Storage PUT failed for ${entry.file.name}.`);
 }
+async function uploadMultipartWithRetry(put, entry, signal) {
+  const uploaded = await mapWithConcurrency(
+    entry.parts,
+    MULTIPART_PART_CONCURRENCY,
+    async (part) => {
+      const body2 = Buffer.from(
+        entry.file.bytes.subarray(part.offset, part.offset + part.size)
+      );
+      const response2 = await requestStorageWithRetry(
+        put,
+        part.signedUrl,
+        { method: "PUT", body: body2 },
+        signal,
+        `multipart part ${part.partNumber}`
+      );
+      const eTag = response2.headers.get("etag");
+      if (eTag === null || eTag.length === 0) {
+        throw new Error(
+          `Multipart upload part ${part.partNumber} for ${entry.file.name} returned no ETag.`
+        );
+      }
+      return { partNumber: part.partNumber, eTag };
+    }
+  );
+  const body = `<CompleteMultipartUpload>${uploaded.sort((left, right) => left.partNumber - right.partNumber).map(
+    ({ partNumber, eTag }) => `<Part><ETag>${escapeXml(eTag)}</ETag><PartNumber>${partNumber}</PartNumber></Part>`
+  ).join("")}</CompleteMultipartUpload>`;
+  const response = await put(entry.completeSignedUrl, {
+    method: "POST",
+    headers: { "content-type": "application/xml" },
+    body,
+    signal: combineSignals(signal, AbortSignal.timeout(STORAGE_PUT_TIMEOUT_MS))
+  });
+  const completion2 = await response.text();
+  if (!response.ok) {
+    throw new Error(
+      `Multipart completion failed (${response.status}): ${completion2}`
+    );
+  }
+  if (completion2.includes("<Error>")) {
+    throw new Error(
+      `Multipart completion for ${entry.file.name} reported an error: ${completion2}`
+    );
+  }
+}
+async function requestStorageWithRetry(request, url, init, signal, label) {
+  let lastError;
+  for (let attempt = 1; attempt <= STORAGE_PUT_ATTEMPTS; attempt += 1) {
+    let response;
+    try {
+      response = await request(url, {
+        ...init,
+        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 response;
+    if (!isRetryableStatus(response.status) || attempt === STORAGE_PUT_ATTEMPTS) {
+      throw new Error(
+        `Storage ${label} failed (${response.status}): ${await response.text()}`
+      );
+    }
+    lastError = new Error(`Storage ${label} failed (${response.status}).`);
+    await waitForRetry(attempt, signal);
+  }
+  throw lastError instanceof Error ? lastError : new Error(`Storage ${label} failed.`);
+}
+function escapeXml(value) {
+  return value.replace(/&/gu, "&amp;").replace(/</gu, "&lt;").replace(/>/gu, "&gt;").replace(/"/gu, "&quot;").replace(/'/gu, "&apos;");
+}
 function isRetryableStatus(status) {
   return status === 408 || status === 429 || status >= 500;
 }
@@ -120975,13 +123093,14 @@ async function waitForRetry(attempt, signal) {
 async function mapWithConcurrency(values, concurrency, run) {
   let nextIndex = 0;
   let firstError;
+  const results = new Array(values.length);
   const worker = async () => {
     while (firstError === void 0) {
       const index = nextIndex;
       nextIndex += 1;
       if (index >= values.length) return;
       try {
-        await run(values[index]);
+        results[index] = await run(values[index]);
       } catch (error) {
         firstError ??= error;
       }
@@ -120991,6 +123110,7 @@ async function mapWithConcurrency(values, concurrency, run) {
     Array.from({ length: Math.min(concurrency, values.length) }, worker)
   );
   if (firstError !== void 0) throw firstError;
+  return results;
 }
 function combineSignals(...signals) {
   const defined = signals.filter(
@@ -121018,7 +123138,7 @@ function uploadHeaders(entry, objectInfo, mimeType) {
 function versionPath(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 UPLOAD_CONCURRENCY, PRESIGN_BATCH_SIZE, MULTIPART_PART_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";
@@ -121026,6 +123146,11 @@ var init_project_file_push = __esm({
     init_projection();
     init_src();
     UPLOAD_CONCURRENCY = 6;
+    PRESIGN_BATCH_SIZE = Math.min(
+      UPLOAD_CONCURRENCY,
+      PROJECT_FILE_UPLOAD_BATCH_SIZE
+    );
+    MULTIPART_PART_CONCURRENCY = 4;
     PRESIGN_TIMEOUT_MS = 3e4;
     PRESIGN_ATTEMPTS = 3;
     STORAGE_PUT_TIMEOUT_MS = 12e4;
@@ -121243,7 +123368,7 @@ __export(push_exports, {
   runPush: () => runPush,
   stripServerDerivedNeoScript: () => stripServerDerivedNeoScript
 });
-import { createHash as createHash10, randomUUID as randomUUID2 } from "node:crypto";
+import { createHash as createHash10, randomUUID as randomUUID3 } from "node:crypto";
 import {
   mkdirSync as mkdirSync10,
   writeFileSync as writeFileSync10,
@@ -121289,7 +123414,7 @@ function assignPendingIds(changes, authoredValueSeeds, reconstructed3, localInit
       assigned.set(pendingId2, derived);
       return derived;
     }
-    const fresh = randomUUID2();
+    const fresh = randomUUID3();
     assigned.set(pendingId2, fresh);
     return fresh;
   };
@@ -121988,6 +124113,7 @@ async function runPush(workspace, options, preparationOverride) {
       json: options.json === true,
       includeDocument: verifiesConfiguredHook,
       identifyArtifactErrors: true,
+      refreshDerivedEdgeVersion: options.dryRun,
       onPhase: (label) => preparation?.update(label)
     });
   } catch (error) {
@@ -122155,6 +124281,7 @@ async function runPush(workspace, options, preparationOverride) {
   }
   const stagePreparedPush = async () => {
     const client2 = NeoApiClient.forBaseUrl(workspace.config.apiBaseUrl);
+    const stagedUploadSessionId2 = preparedLocal.preparedFiles.length > 0 ? randomUUID3() : null;
     const stagedFiles2 = await stageProjectFilePushesV4({
       workspace,
       changes: status.changes,
@@ -122162,13 +124289,19 @@ async function runPush(workspace, options, preparationOverride) {
       assignedIds: preparedLocal.pendingAssignment.assigned,
       client: client2,
       prepared: preparedLocal.preparedFiles,
+      ...stagedUploadSessionId2 === null ? {} : { stagedUploadSessionId: stagedUploadSessionId2 },
       onProgress: (upload) => progress.report({
         type: "push-progress",
         phase: "uploading",
         ...upload
       })
     });
-    return { ...preparedLocal, client: client2, stagedFiles: stagedFiles2 };
+    return {
+      ...preparedLocal,
+      client: client2,
+      stagedFiles: stagedFiles2,
+      stagedUploadSessionId: stagedUploadSessionId2
+    };
   };
   let preparedPush;
   try {
@@ -122189,9 +124322,9 @@ async function runPush(workspace, options, preparationOverride) {
     client,
     transportChanges,
     transportSeeds,
-    preparedFiles
+    stagedUploadSessionId
   } = preparedPush;
-  let { stagedFiles } = preparedPush;
+  const { stagedFiles } = preparedPush;
   const commit = async (force) => await client.post(
     `/api/projects/${workspace.config.projectId}/versions/${workspace.config.versionId}/schema/commit`,
     {
@@ -122200,12 +124333,14 @@ async function runPush(workspace, options, preparationOverride) {
       authoredValueSeeds: transportSeeds,
       initializerMaterialization: pendingAssignment.localInitializerMaterialization ?? { roots: [] },
       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
     },
     force ? { "x-neo-force-project-version-write": "true" } : void 0
@@ -122369,40 +124504,29 @@ async function runPush(workspace, options, preparationOverride) {
         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,
-            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) {
+            if (isDefinitiveSchemaCommitRejection(retryError)) {
+              await cleanupRejectedProjectFilePushesV4({
+                workspace,
+                client,
+                stagedUploadSessionId
+              });
+            }
             reportPushRejection(retryError.status, retryError.body);
             process.exitCode = 1;
             return;
@@ -122412,16 +124536,31 @@ async function runPush(workspace, options, preparationOverride) {
         await finishCommitResponse(result, progress);
         return;
       }
+      await cleanupRejectedProjectFilePushesV4({
+        workspace,
+        client,
+        stagedUploadSessionId
+      });
       console.log("Push cancelled.");
       process.exitCode = 1;
       return;
     }
+    if (isDefinitiveSchemaCommitRejection(error)) {
+      await cleanupRejectedProjectFilePushesV4({
+        workspace,
+        client,
+        stagedUploadSessionId
+      });
+    }
     reportPushRejection(error.status, rejection);
     process.exitCode = 1;
     return;
   }
   await finishCommitResponse(result, progress);
 }
+function isDefinitiveSchemaCommitRejection(error) {
+  return error.status === 400 || error.status === 401 || error.status === 403 || error.status === 404 || error.status === 409;
+}
 async function prepareLocalPushArtifactsV4(workspace, status, onPhase = () => void 0, options = {
   fullValidation: true,
   forceRecompile: false
@@ -122533,6 +124672,14 @@ async function prepareLocalCandidateV4(workspace, options = {}) {
   if (status.changes.length > 0 || status.authoredValueSeeds.size > 0) {
     try {
       documentStatus = pushOptions.dryRun ? cloneStatusForDryRun(status) : status;
+      if (options.refreshDerivedEdgeVersion === true) {
+        const convex = await createConvexClient(workspace);
+        const signal = await convex.query(api2.projectExportData.schemaSignal, {
+          projectId: workspace.config.projectId,
+          versionId: workspace.config.versionId
+        });
+        workspace.state.derivedEdgeVersion = signal?.derivedEdgeVersion ?? null;
+      }
       preparedLocal = await prepareLocalPushArtifactsV4(
         workspace,
         documentStatus,
@@ -122968,8 +125115,10 @@ async function recoverHeadTransactionHashFromSchemaSignal(workspace) {
       versionId: workspace.config.versionId
     });
     workspace.state.headTransactionHash = signal?.transactionHash ?? null;
+    workspace.state.derivedEdgeVersion = signal?.derivedEdgeVersion ?? null;
   } catch {
     workspace.state.headTransactionHash = null;
+    delete workspace.state.derivedEdgeVersion;
   }
 }
 function immediateTransactionId(result) {
@@ -124185,6 +126334,7 @@ var init_push = __esm({
     init_merge();
     init_push_change_intent();
     init_push_body_diagnostics();
+    init_project_snapshot_derived_edges();
     ({
       compileNSVoidBody: compileNSVoidBody2,
       compileNSFunction: compileNSFunction2,
@@ -124241,7 +126391,7 @@ var init_registry2 = __esm({
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
       formatVersion: 4,
       contractVersion: "4.1",
-      cliVersion: "0.42.1",
+      cliVersion: "0.43.0",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -125664,7 +127814,7 @@ __export(test_exports, {
   maintainNeoTestBuildCache: () => maintainNeoTestBuildCache,
   runTest: () => runTest
 });
-import { createHash as createHash11, randomUUID as randomUUID3 } from "node:crypto";
+import { createHash as createHash11, randomUUID as randomUUID4 } from "node:crypto";
 import {
   existsSync as existsSync13,
   mkdirSync as mkdirSync11,
@@ -126835,7 +128985,7 @@ async function executeRegisteredSpec(registered, document, selected, timeoutMs,
 }
 function atomicWrite(path, content) {
   mkdirSync11(dirname10(path), { recursive: true });
-  const temporary = `${path}.tmp-${String(process.pid)}-${randomUUID3()}`;
+  const temporary = `${path}.tmp-${String(process.pid)}-${randomUUID4()}`;
   writeFileSync11(temporary, content, "utf8");
   renameSync5(temporary, path);
 }
@@ -127722,7 +129872,7 @@ __export(migrate_exports, {
   resolveWriteTarget: () => resolveWriteTarget,
   runMigrate: () => runMigrate
 });
-import { randomUUID as randomUUID4 } from "node:crypto";
+import { randomUUID as randomUUID5 } from "node:crypto";
 import { existsSync as existsSync15, mkdirSync as mkdirSync12, readdirSync as readdirSync6, writeFileSync as writeFileSync12 } from "node:fs";
 import { join as join17 } from "node:path";
 async function runMigrate(workspace, subcommand, positional, targetRef, json, dependencies = {}) {
@@ -128707,7 +130857,7 @@ function planCollectionMutation(args) {
         `Migration "${migrationName}" adds a non-scalar collection entry; minting nested entries is not yet supported (build the value beforehand).`
       );
     }
-    const id2 = randomUUID4();
+    const id2 = randomUUID5();
     changes.push({
       recordKind: "value",
       recordId: id2,
@@ -129497,7 +131647,7 @@ __export(content_exports, {
   runLoc: () => runLoc
 });
 import { readFileSync as readFileSync18 } from "node:fs";
-import { randomUUID as randomUUID5 } from "node:crypto";
+import { randomUUID as randomUUID6 } from "node:crypto";
 function versionPath2(workspace, suffix) {
   return `/api/projects/${workspace.config.projectId}/versions/${workspace.config.versionId}/${suffix}`;
 }
@@ -129580,7 +131730,7 @@ async function runLoc(context, subcommand, positional, file) {
     const config = isObjectRecord2(raw.localizationConfig) ? raw.localizationConfig : {};
     const statusId = config.mainLocale === locale && typeof config.mainLocaleDefaultStatusId === "string" ? config.mainLocaleDefaultStatusId : "localization-status-needs-translation";
     const now = Date.now();
-    const textId = typeof body.id === "string" ? body.id : randomUUID5();
+    const textId = typeof body.id === "string" ? body.id : randomUUID6();
     const existingHead = heads.get(`localized-text:${textId}`);
     const text = {
       id: textId,
@@ -131061,7 +133211,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.42.1");
+    console.log("0.43.0");
     return;
   }
   if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {