@neocompose/cli 0.59.0 → 0.59.2

package/dist/neo.mjs

@@ -31503,9 +31503,8 @@ var init_project_source_construction_quick_fixes = __esm({
 });
 
 // ../packages/neoscript-language/src/project-source-manifest.ts
-function compileNeoProjectSources(inputs, options = {}) {
-  const analysis = analyzeNeoProjectSources(inputs, options.parsedDocuments);
-  options.onDocuments?.(analysis.documents);
+function compileNeoProjectSources(inputs) {
+  const analysis = analyzeNeoProjectSources(inputs);
   const schemaClasses = [];
   const schemaInterfaces = [];
   const schemaEnums = [];
@@ -87808,6 +87807,15 @@ var init_project_document_read = __esm({
 });
 
 // ../src/models/search/universal-search-projection.ts
+function valueSearchClassName(name) {
+  const trimmed = typeof name === "string" ? nonEmptyTrimmed(name) : void 0;
+  return trimmed === void 0 ? null : truncateUtf8(trimmed, UNIVERSAL_SEARCH_MAX_SUBTITLE_BYTES);
+}
+function nonEmptyTrimmed(value) {
+  if (value === void 0 || value === null) return void 0;
+  const trimmed = value.trim();
+  return trimmed.length === 0 ? void 0 : trimmed;
+}
 function truncateUtf8(value, maxBytes) {
   if (value === void 0) return "";
   if (!Number.isInteger(maxBytes) || maxBytes < 0) {
@@ -87833,11 +87841,12 @@ function isAscii(value) {
   }
   return true;
 }
-var utf8Encoder;
+var UNIVERSAL_SEARCH_MAX_SUBTITLE_BYTES, utf8Encoder;
 var init_universal_search_projection = __esm({
   "../src/models/search/universal-search-projection.ts"() {
     "use strict";
     init_classes();
+    UNIVERSAL_SEARCH_MAX_SUBTITLE_BYTES = 512;
     utf8Encoder = new TextEncoder();
   }
 });
@@ -87993,7 +88002,7 @@ function projectValueHeadPlacementGraph(args) {
       valueOwnerId: ownerId,
       valueRootMemberId: item.rootMemberId,
       valueClassId: classId,
-      valueSearchClassName: schemaClass2 !== void 0 && typeof schemaClass2.name === "string" ? truncateUtf8(schemaClass2.name, 512) : null,
+      valueSearchClassName: valueSearchClassName(schemaClass2?.name),
       valueSearchPlacementPath: item.path,
       ...item.constructorParameterId === void 0 ? {} : { constructorParameterId: item.constructorParameterId },
       ...item.constructorSchemaKey === void 0 ? {} : { constructorSchemaKey: item.constructorSchemaKey }
@@ -88120,7 +88129,7 @@ function projectValueHeadPlacementGraph(args) {
       valueOwnerId: classId === null ? null : valueId,
       valueRootMemberId: null,
       valueClassId: classId,
-      valueSearchClassName: schemaClass2 !== void 0 && typeof schemaClass2.name === "string" ? truncateUtf8(schemaClass2.name, 512) : null,
+      valueSearchClassName: valueSearchClassName(schemaClass2?.name),
       valueSearchPlacementPath: null
     });
   }
@@ -92743,7 +92752,7 @@ function planCommitPreparationLoadedClosureScope(args) {
 function animationValidationScope(memberIds) {
   return memberIds.size === 0 ? {} : { animationValidationMemberIds: [...memberIds].sort() };
 }
-function withCommitPreparationInMemoryPlacement(records2) {
+function placeInMemoryRecords(records2, extractions) {
   const recordKeys = new Set(records2.map(commitPreparationRecordKey));
   const parentByChild = /* @__PURE__ */ new Map();
   const ambiguousParentsByChild = /* @__PURE__ */ new Map();
@@ -92781,7 +92790,7 @@ function withCommitPreparationInMemoryPlacement(records2) {
     }
     parentByChild.set(childKey, { ...parent, authority });
   };
-  for (const record6 of records2) {
+  for (const [index, record6] of records2.entries()) {
     const sourceKey = commitPreparationRecordKey(record6);
     if (record6.parentRecordKind !== void 0 && record6.parentRecordKind !== null && record6.parentRecordId !== void 0 && record6.parentRecordId !== null) {
       rememberParent(
@@ -92806,7 +92815,7 @@ function withCommitPreparationInMemoryPlacement(records2) {
         );
       }
     }
-    for (const edge of extractProjectSnapshotDerivedEdges(record6).edges) {
+    for (const edge of extractions[index].edges) {
       if (edge.edgeKind !== "containment-child" || edge.targetAddressing !== "record") {
         continue;
       }
@@ -92862,33 +92871,13 @@ function commitPreparationPackedRootIds(records2) {
   }
   return rootIdByChildId;
 }
-function readCommitPreparationScopeInMemory(args) {
-  const records2 = withCommitPreparationInMemoryPlacement(args.records);
-  const recordsByKey = new Map(
+function createCommitPreparationInMemoryScopeReader(args) {
+  const extractions = args.records.map(extractProjectSnapshotDerivedEdges);
+  const records2 = placeInMemoryRecords(args.records, extractions);
+  const recordByKey = new Map(
     records2.map((record6) => [commitPreparationRecordKey(record6), record6])
   );
   const packedRootIdByChildId = commitPreparationPackedRootIds(records2);
-  const exactStates = /* @__PURE__ */ new Map();
-  const packedRootKeyByExactKey = /* @__PURE__ */ new Map();
-  for (const record6 of args.request.exactRecords) {
-    const key = commitPreparationRecordKey(record6);
-    if (recordsByKey.has(key)) {
-      exactStates.set(key, "live");
-      continue;
-    }
-    const rootId = record6.recordKind === "value" ? packedRootIdByChildId.get(record6.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();
@@ -92959,63 +92948,113 @@ function readCommitPreparationScopeInMemory(args) {
       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
-        }
-      };
+  for (const index of [
+    keysByKind,
+    valueKeysByMemberId,
+    valueKeysByClassId,
+    valueKeysByContainerId,
+    valueKeysByWorldKind,
+    childKeysByParentKey
+  ]) {
+    for (const keys of index.values()) keys.sort();
+  }
+  sourceOnlyKeys.sort();
+  const persistedByPostingKey = /* @__PURE__ */ new Map();
+  let incompleteRecordKey;
+  for (const [index, record6] of records2.entries()) {
+    const extraction = extractions[index];
+    if (!extraction.complete)
+      incompleteRecordKey ??= commitPreparationRecordKey(record6);
+    for (const edge of extraction.edges) {
+      const postingKey = commitPreparationPostingRequestKey(edge);
+      const edges = persistedByPostingKey.get(postingKey) ?? [];
+      edges.push({
+        recordKind: record6.recordKind,
+        recordId: record6.recordId,
+        ...edge
+      });
+      persistedByPostingKey.set(postingKey, edges);
     }
-    rangeRecordKeys.set(
-      commitPreparationRangeRequestKey(request),
-      [...matching].sort()
-    );
   }
-  const persisted = [];
-  for (const record6 of records2) {
-    const extraction = extractProjectSnapshotDerivedEdges(record6);
-    if (!extraction.complete && args.request.postings.some(
-      (request) => request.edgeKind === "constructor-aggregate"
+  const read = (request, prepared) => {
+    const exactStates = /* @__PURE__ */ new Map();
+    const packedRootKeyByExactKey = /* @__PURE__ */ new Map();
+    for (const record6 of request.exactRecords) {
+      const key = commitPreparationRecordKey(record6);
+      if (recordByKey.has(key)) {
+        exactStates.set(key, "live");
+        continue;
+      }
+      const rootId = record6.recordKind === "value" ? packedRootIdByChildId.get(record6.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 rangeRecordKeys = /* @__PURE__ */ new Map();
+    for (const range2 of request.ranges) {
+      const matching = range2.rangeKind === "record-kind" ? keysByKind.get(range2.targetKey) ?? [] : range2.rangeKind === "source-only" ? sourceOnlyKeys : range2.rangeKind === "value-member" ? valueKeysByMemberId.get(range2.targetKey) ?? [] : range2.rangeKind === "value-class" ? valueKeysByClassId.get(range2.targetKey) ?? [] : range2.rangeKind === "container-members" ? valueKeysByContainerId.get(range2.targetKey) ?? [] : range2.rangeKind === "children" ? childKeysByParentKey.get(range2.targetKey) ?? [] : range2.rangeKind === "world-kind" ? valueKeysByWorldKind.get(range2.targetKey) ?? [] : keysByKind.get("value") ?? [];
+      if (matching.length > range2.limit) {
+        return {
+          kind: "fallback",
+          reason: {
+            code: "range-row-cap-exceeded",
+            requestKey: commitPreparationRangeRequestKey(range2),
+            observed: matching.length,
+            limit: range2.limit
+          }
+        };
+      }
+      rangeRecordKeys.set(commitPreparationRangeRequestKey(range2), matching);
+    }
+    if (incompleteRecordKey !== void 0 && request.postings.some(
+      (posting) => posting.edgeKind === "constructor-aggregate"
     )) {
       return {
         kind: "fallback",
         reason: {
           code: "derived-edge-extraction-incomplete",
-          recordKey: commitPreparationRecordKey(record6)
+          recordKey: incompleteRecordKey
         }
       };
     }
-    for (const edge of extraction.edges) {
-      persisted.push({ ...record6, ...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)
-        ])
-      )
+    const persisted = [];
+    for (const postingKey of new Set(
+      request.postings.map(commitPreparationPostingRequestKey)
+    )) {
+      for (const edge of persistedByPostingKey.get(postingKey) ?? []) {
+        persisted.push(edge);
+      }
     }
+    const overlaid = overlayCommitPreparationDerivedEdgePostings({
+      requests: request.postings,
+      persisted,
+      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)
+          ])
+        )
+      }
+    };
   };
+  return { recordByKey, read };
 }
 function commitPreparationRecordKey(record6) {
   return `${record6.recordKind}:${record6.recordId}`;
@@ -117901,7 +117940,7 @@ function computeWorkspaceStatus(workspace, options) {
         "Format-4 status requires a pulled schema base; run `neo pull --reset`."
       );
     }
-    const analysis = options.readProjectAnalysisCache?.(workspace.root, compilationSources) ?? options.compileProjectAnalysis?.(workspace.root, compilationSources) ?? compileNeoProjectSources(compilationSources);
+    const analysis = options.readProjectAnalysisCache?.(workspace.root, compilationSources) ?? compileNeoProjectSources(compilationSources);
     projectAnalysisV4 = analysis;
     for (const diagnostic of analysis.diagnostics) {
       const positioned = new SchemaSourceError(
@@ -120385,7 +120424,7 @@ function prepareAgainstPulledBase(args, base) {
     changes,
     timestamp: serverTimestamp
   });
-  const placedRecords = () => {
+  const scopeReader = () => {
     const canonicalPlacementByValueId = projectValueHeadPlacementGraph({
       rootMembers: [
         { id: document.project.rootAssetsMemberId, label: "Assets" },
@@ -120400,8 +120439,9 @@ function prepareAgainstPulledBase(args, base) {
       classes: document.classes,
       values: document.values
     });
-    return withCommitPreparationInMemoryPlacement(
-      Object.values(args.workspace.state.records).map((record6) => {
+    return createCommitPreparationInMemoryScopeReader({
+      document,
+      records: Object.values(args.workspace.state.records).map((record6) => {
         const recordKind = narrowRecordKind(
           record6.recordKind,
           `${record6.recordKind}:${record6.recordId}`
@@ -120417,7 +120457,7 @@ function prepareAgainstPulledBase(args, base) {
           }
         };
       })
-    );
+    });
   };
   const preparationArgs = {
     document,
@@ -120457,7 +120497,7 @@ function prepareAgainstPulledBase(args, base) {
   }
   return prepareWithScopedSafetyValve({
     prepareScoped: () => {
-      const records2 = placedRecords();
+      const reader = scopeReader();
       const initialScope = planCommitPreparationInitialScope({
         pass: COMMIT_PREPARATION_PASS_ORDER[0],
         document,
@@ -120467,12 +120507,7 @@ function prepareAgainstPulledBase(args, base) {
         postingLimit: COMMIT_PREPARATION_SCOPE_POSTING_ROW_LIMIT
       });
       if (initialScope.fullContentDimension) return null;
-      const scopeAnswer = readCommitPreparationScopeInMemory({
-        request: initialScope,
-        records: records2,
-        prepared: changes,
-        document
-      });
+      const scopeAnswer = reader.read(initialScope, changes);
       if (scopeAnswer.kind === "fallback") return null;
       const selectedContentKeys = /* @__PURE__ */ new Set();
       const descendantRootKeys = /* @__PURE__ */ new Set();
@@ -120486,7 +120521,7 @@ function prepareAgainstPulledBase(args, base) {
         absentExactKeys
       );
       const initialClosed = closeInMemoryLoadedScope({
-        records: records2,
+        reader,
         selected: selectedContentKeys,
         descendantRoots: descendantRootKeys,
         absentExactKeys,
@@ -120525,12 +120560,10 @@ function prepareAgainstPulledBase(args, base) {
           postingLimit: COMMIT_PREPARATION_SCOPE_POSTING_ROW_LIMIT
         });
         if (topUpRequest.fullContentDimension) return null;
-        const topUpAnswer = readCommitPreparationScopeInMemory({
-          request: topUpRequest,
-          records: records2,
-          prepared: step.value.preparedChanges,
-          document
-        });
+        const topUpAnswer = reader.read(
+          topUpRequest,
+          step.value.preparedChanges
+        );
         if (topUpAnswer.kind === "fallback") return null;
         absorbInMemoryScopeAnswer(
           selectedContentKeys,
@@ -120546,7 +120579,7 @@ function prepareAgainstPulledBase(args, base) {
           descendantRootKeys.add(`${change.recordKind}:${change.recordId}`);
         }
         if (!closeInMemoryLoadedScope({
-          records: records2,
+          reader,
           selected: selectedContentKeys,
           descendantRoots: descendantRootKeys,
           absentExactKeys,
@@ -120608,14 +120641,14 @@ function absorbInMemoryScopeAnswer(selected, answer, descendantRoots, descendant
 function closeInMemoryLoadedScope(args) {
   const animationSchema = commitPreparationAnimationSchema(args.document);
   for (; ; ) {
-    const closureRecords = args.records.filter(
-      (record6) => args.selected.has(`${record6.recordKind}:${record6.recordId}`)
-    ).map((record6) => ({
-      ...record6,
-      includeDescendants: args.descendantRoots.has(
-        `${record6.recordKind}:${record6.recordId}`
-      )
-    }));
+    const closureRecords = selectedRecords(args.reader, args.selected).map(
+      (record6) => ({
+        ...record6,
+        includeDescendants: args.descendantRoots.has(
+          `${record6.recordKind}:${record6.recordId}`
+        )
+      })
+    );
     const request = planCommitPreparationLoadedClosureScope({
       pass: args.pass,
       records: closureRecords,
@@ -120624,12 +120657,7 @@ function closeInMemoryLoadedScope(args) {
       animationSchema,
       placementCreationScope: createdWorldPlacementIds(args.prepared) !== null
     });
-    const answer = readCommitPreparationScopeInMemory({
-      request,
-      records: args.records,
-      prepared: args.prepared,
-      document: args.document
-    });
+    const answer = args.reader.read(request, args.prepared);
     if (answer.kind === "fallback") return false;
     const priorSelectedSize = args.selected.size;
     const priorDescendantSize = args.descendantRoots.size;
@@ -120643,20 +120671,26 @@ function closeInMemoryLoadedScope(args) {
     );
     if (args.selected.size === priorSelectedSize && args.descendantRoots.size === priorDescendantSize) {
       return selectedAncestorPathsIntact(
-        args.records,
+        args.reader,
         args.selected,
         args.absentExactKeys
       );
     }
   }
 }
-function selectedAncestorPathsIntact(records2, selected, absentExactKeys) {
+function selectedRecords(reader, selected) {
+  const records2 = [];
+  for (const key of selected) {
+    const record6 = reader.recordByKey.get(key);
+    if (record6 !== void 0) records2.push(record6);
+  }
+  return records2;
+}
+function selectedAncestorPathsIntact(reader, selected, absentExactKeys) {
   if (absentExactKeys.size === 0) return true;
-  const selectedRecords = records2.filter(
-    (record6) => selected.has(`${record6.recordKind}:${record6.recordId}`)
-  );
-  const packedRootIdByChildId = commitPreparationPackedRootIds(selectedRecords);
-  for (const record6 of selectedRecords) {
+  const records2 = selectedRecords(reader, selected);
+  const packedRootIdByChildId = commitPreparationPackedRootIds(records2);
+  for (const record6 of records2) {
     if (record6.recordKind !== "value") continue;
     if (record6.parentRecordKind !== "value") continue;
     const parentId = record6.parentRecordId;
@@ -129001,6 +129035,34 @@ function retainAuthoredDefinitionGroupingV4(files, recordFiles) {
   };
 }
 function emitProjectDocumentFilesV4(records2, options = {}) {
+  const emission = emitProjectDocumentSourcesV4(records2, options);
+  const analysis = compileNeoProjectSources(
+    emission.files.map((file) => {
+      const kind = neoProjectSourceKind(file.path, file.content);
+      if (kind === null || !isNeoProjectProductionSourceKind(kind)) {
+        throw new Error(
+          `Canonical projection emitted non-production source ${JSON.stringify(file.path)}.`
+        );
+      }
+      return { uri: file.path, kind, text: file.content };
+    })
+  );
+  const errors = analysis.diagnostics.filter(
+    (diagnostic) => diagnostic.severity === "error" && // Pull must expose incomplete stored objects so source can repair them.
+    // Status, tests, and push still reject these construction errors.
+    diagnostic.code !== "unsettled-required-member" && !isPullRecoveryDiagnosticCode(diagnostic.code)
+  );
+  if (errors.length > 0) {
+    throw new Error(
+      `Canonical format-4 projection produced invalid source:
+${errors.map(
+        (diagnostic) => `  ${diagnostic.uri}:${diagnostic.range.start.line + 1}:${diagnostic.range.start.character + 1} ${diagnostic.message}`
+      ).join("\n")}`
+    );
+  }
+  return { ...emission, analysis };
+}
+function emitProjectDocumentSourcesV4(records2, options = {}) {
   const schemaRecords = [];
   for (const record6 of records2.values()) {
     if (record6.deleted || !isSchemaRecordKindV4(record6.recordKind)) continue;
@@ -129129,34 +129191,9 @@ function emitProjectDocumentFilesV4(records2, options = {}) {
       STATIC_MEMBER_OWNERSHIP_RECOVERY_SOURCE
     );
   }
-  const analysis = compileNeoProjectSources(
-    files.map((file) => {
-      const kind = neoProjectSourceKind(file.path, file.content);
-      if (kind === null || !isNeoProjectProductionSourceKind(kind)) {
-        throw new Error(
-          `Canonical projection emitted non-production source ${JSON.stringify(file.path)}.`
-        );
-      }
-      return { uri: file.path, kind, text: file.content };
-    })
-  );
-  const errors = analysis.diagnostics.filter(
-    (diagnostic) => diagnostic.severity === "error" && // Pull must expose incomplete stored objects so source can repair them.
-    // Status, tests, and push still reject these construction errors.
-    diagnostic.code !== "unsettled-required-member" && !isPullRecoveryDiagnosticCode(diagnostic.code)
-  );
-  if (errors.length > 0) {
-    throw new Error(
-      `Canonical format-4 projection produced invalid source:
-${errors.map(
-        (diagnostic) => `  ${diagnostic.uri}:${diagnostic.range.start.line + 1}:${diagnostic.range.start.character + 1} ${diagnostic.message}`
-      ).join("\n")}`
-    );
-  }
   return {
     files,
     recordFiles,
-    analysis,
     materializedConstructors,
     materializedConstructorOverrideKeys,
     formAlternates: source.formAlternates.map((alternate) => ({
@@ -129278,98 +129315,6 @@ function writeProjectSourceAnalysisCacheV4(root, analysis, sources) {
   );
   renameSync5(temporary, buildFile);
 }
-function compileProjectSourceAnalysisWithBuildCacheV4(root, sources) {
-  const parsedDocuments = readProjectSourceDocumentBuildCacheV1(root, sources);
-  let documents;
-  try {
-    const analysis = compileNeoProjectSources(sources, {
-      parsedDocuments,
-      onDocuments: (result) => {
-        documents = result;
-      }
-    });
-    if (documents !== void 0) {
-      writeProjectSourceDocumentBuildCacheV1(root, sources, documents);
-    }
-    return analysis;
-  } catch (error) {
-    if (parsedDocuments.size === 0) throw error;
-    documents = void 0;
-    const analysis = compileNeoProjectSources(sources, {
-      onDocuments: (result) => {
-        documents = result;
-      }
-    });
-    if (documents !== void 0) {
-      writeProjectSourceDocumentBuildCacheV1(root, sources, documents);
-    }
-    return analysis;
-  }
-}
-function readProjectSourceDocumentBuildCacheV1(root, sources) {
-  try {
-    const parsed = JSON.parse(
-      readFileSync6(
-        join5(root, PROJECT_SOURCE_DOCUMENT_BUILD_CACHE_PATH),
-        "utf8"
-      )
-    );
-    if (parsed === null || typeof parsed !== "object") return /* @__PURE__ */ new Map();
-    const cache = parsed;
-    if (cache.revision !== PROJECT_SOURCE_DOCUMENT_BUILD_CACHE_REVISION || cache.compilerRevision !== NEOSCRIPT_COMPILER_REVISION || cache.files === null || typeof cache.files !== "object" || Array.isArray(cache.files)) {
-      return /* @__PURE__ */ new Map();
-    }
-    const files = cache.files;
-    const documents = /* @__PURE__ */ new Map();
-    for (const source of sources) {
-      const cached = files[source.uri];
-      if (cached?.fingerprint !== projectSourceFileFingerprint(source) || !isCachedProjectSourceDocument(cached.document, source)) {
-        continue;
-      }
-      documents.set(source.uri, cached.document);
-    }
-    return documents;
-  } catch {
-    return /* @__PURE__ */ new Map();
-  }
-}
-function writeProjectSourceDocumentBuildCacheV1(root, sources, documents) {
-  const file = join5(root, PROJECT_SOURCE_DOCUMENT_BUILD_CACHE_PATH);
-  mkdirSync6(dirname6(file), { recursive: true });
-  const temporary = `${file}.${process.pid}.tmp`;
-  writeFileSync6(
-    temporary,
-    `${JSON.stringify({
-      revision: PROJECT_SOURCE_DOCUMENT_BUILD_CACHE_REVISION,
-      compilerRevision: NEOSCRIPT_COMPILER_REVISION,
-      files: Object.fromEntries(
-        sources.flatMap((source) => {
-          const document = documents.get(source.uri);
-          return document === void 0 ? [] : [
-            [
-              source.uri,
-              {
-                fingerprint: projectSourceFileFingerprint(source),
-                document
-              }
-            ]
-          ];
-        })
-      )
-    })}
-`,
-    "utf8"
-  );
-  renameSync5(temporary, file);
-}
-function projectSourceFileFingerprint(source) {
-  return createHash6("sha256").update(String(PROJECT_SOURCE_DOCUMENT_BUILD_CACHE_REVISION)).update("\0").update(String(NEOSCRIPT_COMPILER_REVISION)).update("\0").update(source.kind).update("\0").update(source.text).digest("hex");
-}
-function isCachedProjectSourceDocument(value, source) {
-  if (value === null || typeof value !== "object") return false;
-  const document = value;
-  return document.kind === source.kind && document.sourceText === source.text && Array.isArray(document.declarations) && Array.isArray(document.diagnostics);
-}
 function projectSourceFingerprint(sources) {
   const hash = createHash6("sha256");
   hash.update(String(PROJECT_SOURCE_BUILD_CACHE_REVISION));
@@ -129385,7 +129330,7 @@ function projectSourceFingerprint(sources) {
   }
   return hash.digest("hex");
 }
-var PROJECT_SOURCE_BUILD_CACHE_PATH, PROJECT_SOURCE_BUILD_CACHE_REVISION, PROJECT_SOURCE_DOCUMENT_BUILD_CACHE_PATH, PROJECT_SOURCE_DOCUMENT_BUILD_CACHE_REVISION;
+var PROJECT_SOURCE_BUILD_CACHE_PATH, PROJECT_SOURCE_BUILD_CACHE_REVISION;
 var init_project_document_cache = __esm({
   "src/project-source/project-document-cache.ts"() {
     "use strict";
@@ -129393,8 +129338,6 @@ var init_project_document_cache = __esm({
     init_project_documents();
     PROJECT_SOURCE_BUILD_CACHE_PATH = ".neo/build/project-source-analysis-v4.json";
     PROJECT_SOURCE_BUILD_CACHE_REVISION = 2;
-    PROJECT_SOURCE_DOCUMENT_BUILD_CACHE_PATH = ".neo/build/project-source-documents-v1.json";
-    PROJECT_SOURCE_DOCUMENT_BUILD_CACHE_REVISION = 1;
   }
 });
 
@@ -129984,7 +129927,6 @@ function computeWorkspaceStatus2(workspace, options = {}) {
     virtualSourceFiles,
     writeProjectAnalysisCache: options.writeProjectAnalysisCache ?? writeProjectSourceAnalysisCacheV4,
     readProjectAnalysisCache: options.readProjectAnalysisCache ?? readProjectSourceAnalysisBuildCacheV4,
-    compileProjectAnalysis: options.compileProjectAnalysis ?? compileProjectSourceAnalysisWithBuildCacheV4,
     inspectProjectBinaries: inspectProjectBinaryStatusV4,
     lowerSupplementalRecords: (state, analysis, trustedPendingFiles) => lowerSupplementalProjectSourcesV4(workspace.root, state, analysis, {
       ...trustedPendingFiles === void 0 ? {} : { trustedPendingFiles }
@@ -130292,6 +130234,60 @@ var init_schema_commit_transport = __esm({
   }
 });
 
+// src/off-thread-fetch.ts
+import { Worker as Worker2 } from "node:worker_threads";
+async function fetchOffThread(url, headers, signal) {
+  signal?.throwIfAborted();
+  const worker = new Worker2(REQUEST, {
+    eval: true,
+    execArgv: [],
+    workerData: { url: url.href, headers }
+  });
+  let abort = () => void 0;
+  try {
+    const message = await new Promise((resolve5, reject) => {
+      abort = () => reject(signal?.reason);
+      signal?.addEventListener("abort", abort, { once: true });
+      worker.once("message", resolve5);
+      worker.once("error", reject);
+      worker.once(
+        "exit",
+        (code) => reject(new Error(`The request worker exited with code ${code}.`))
+      );
+    });
+    if (typeof message !== "object" || message === null)
+      throw new Error("The request worker posted a non-object result.");
+    if ("error" in message && typeof message.error === "string")
+      throw new Error(
+        message.error,
+        "cause" in message && typeof message.cause === "string" ? { cause: message.cause } : void 0
+      );
+    if (!("ok" in message) || typeof message.ok !== "boolean")
+      throw new Error('The request worker result is missing boolean "ok".');
+    if (!("status" in message) || typeof message.status !== "number")
+      throw new Error('The request worker result is missing numeric "status".');
+    if (!("body" in message) || typeof message.body !== "string")
+      throw new Error('The request worker result is missing string "body".');
+    return { ok: message.ok, status: message.status, body: message.body };
+  } finally {
+    signal?.removeEventListener("abort", abort);
+    void worker.terminate();
+  }
+}
+var REQUEST;
+var init_off_thread_fetch = __esm({
+  "src/off-thread-fetch.ts"() {
+    "use strict";
+    REQUEST = `
+const { workerData, parentPort } = require("node:worker_threads");
+fetch(workerData.url, { headers: workerData.headers, redirect: "error" }).then(
+  async (response) => parentPort.postMessage({ ok: response.ok, status: response.status, body: await response.text() }),
+  (error) => parentPort.postMessage({ error: String(error), cause: error?.cause === undefined ? null : String(error.cause) }),
+);
+`;
+  }
+});
+
 // ../convex/_generated/api.js
 var api_exports = {};
 __export(api_exports, {
@@ -130325,20 +130321,22 @@ async function mintConvexJwt(apiBaseUrl, signal, convexSiteUrl) {
     }
     const pinnedSite = loadTrustedConvexSite(apiBaseUrl);
     const direct = convexSiteUrl !== void 0 && pinnedSite === convexSiteUrl;
-    const response = await fetch(
+    const response = await fetchOffThread(
       new URL("/api/auth/convex/token", direct ? convexSiteUrl : apiBaseUrl),
-      {
-        headers: { Authorization: `Bearer ${sessionToken}` },
-        redirect: "error",
-        signal
-      }
+      { Authorization: `Bearer ${sessionToken}` },
+      signal
     );
-    const body = await response.json();
     if (!response.ok) {
       throw new Error(
-        `Convex JWT mint failed with status ${response.status}: ${JSON.stringify(body).slice(0, 200)}`
+        `Convex JWT mint failed with status ${response.status}: ${response.body.slice(0, 200)}`
       );
     }
+    let body;
+    try {
+      body = JSON.parse(response.body);
+    } catch {
+      throw new Error("Convex token response is not JSON.");
+    }
     if (typeof body !== "object" || body === null || !("token" in body) || typeof body.token !== "string")
       throw new Error('Convex token response is missing a string "token".');
     const payload = convexJwtPayload(body.token);
@@ -130520,11 +130518,45 @@ function convexHttpActionUrl(convexUrl) {
 async function createConvexPushConnection(workspace) {
   const convexUrl = await resolveConvexUrl(workspace);
   const siteUrl = convexHttpActionUrl(convexUrl);
+  const lifetime = new AbortController();
   const tokenCache = new ConvexJwtCache(
     workspace.config.apiBaseUrl,
-    void 0,
+    lifetime.signal,
     siteUrl
   );
+  void tokenCache.getToken().catch(() => void 0);
+  let subscriber;
+  let authFailed = false;
+  const fail2 = (error) => {
+    if (lifetime.signal.aborted) return;
+    if (subscriber === void 0) authFailed = true;
+    else subscriber(error);
+  };
+  const authenticate = (client) => client.setAuth(
+    async ({ forceRefreshToken }) => {
+      try {
+        return await tokenCache.getToken(forceRefreshToken);
+      } catch (error) {
+        fail2(error instanceof Error ? error : new Error(String(error)));
+        return null;
+      }
+    },
+    (authenticated) => {
+      if (!authenticated)
+        fail2(new Error("Convex rejected the session authentication."));
+    }
+  );
+  let socket;
+  const connect = () => {
+    if (socket !== void 0) return socket;
+    socket = new ConvexClient(convexUrl, {
+      initialAuthTokenReuse: true,
+      logger: false
+    });
+    authenticate(socket);
+    return socket;
+  };
+  let closing;
   return {
     async submit(body, force) {
       const json = JSON.stringify(body);
@@ -130554,6 +130586,7 @@ async function createConvexPushConnection(workspace) {
             limitBytes: SCHEMA_COMMIT_HTTP_MAX_BYTES
           }
         );
+      connect();
       const client = new NeoApiClient(siteUrl, await tokenCache.getToken());
       const path = `${SCHEMA_COMMIT_HTTP_PATH}?${new URLSearchParams({ projectId: workspace.config.projectId, versionId: workspace.config.versionId })}`;
       const finish = startPerformanceSpan("commit-transport", {
@@ -130573,28 +130606,26 @@ async function createConvexPushConnection(workspace) {
         finish();
       }
     },
-    async subscribe(signal, onError) {
-      await tokenCache.getToken(false, signal);
+    /** Routes the socket's authentication failures to `onError` until `signal` aborts. */
+    subscribe(signal, onError) {
       signal.throwIfAborted();
-      const client = new ConvexClient(convexUrl, {
-        initialAuthTokenReuse: true,
-        logger: false
-      });
-      client.setAuth(
-        async ({ forceRefreshToken }) => {
-          try {
-            return await tokenCache.getToken(forceRefreshToken, signal);
-          } catch (error) {
-            onError(error instanceof Error ? error : new Error(String(error)));
-            return null;
-          }
-        },
-        (authenticated) => {
-          if (!authenticated && !signal.aborted)
-            onError(new Error("Convex rejected the session authentication."));
-        }
-      );
+      subscriber = (error) => {
+        if (!signal.aborted) onError(error);
+      };
+      const client = connect();
+      if (authFailed) {
+        authFailed = false;
+        authenticate(client);
+      }
       return client;
+    },
+    /** Idempotent; cancels an in-flight mint and closes the socket. */
+    close() {
+      if (closing === void 0) {
+        lifetime.abort();
+        closing = socket?.close() ?? Promise.resolve();
+      }
+      return closing;
     }
   };
 }
@@ -130605,6 +130636,7 @@ var init_convex = __esm({
     init_http();
     init_schema_commit_transport();
     init_performance();
+    init_off_thread_fetch();
     init_api();
     init_token_store();
     init_workspace();
@@ -131154,9 +131186,286 @@ var init_concurrency = __esm({
   }
 });
 
+// src/project-source/project-file-pull.ts
+import {
+  existsSync as existsSync8,
+  mkdtempSync,
+  readFileSync as readFileSync11,
+  rmSync as rmSync5,
+  writeFileSync as writeFileSync8
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join as join9 } from "node:path";
+async function pullProjectBinariesV4(args) {
+  const resolvePath = createWorkspaceSourcePathResolver(args.workspace.root);
+  const plans = /* @__PURE__ */ new Map();
+  const downloads = [];
+  const localById = new Map(
+    (args.localBinaries ?? []).map((binary) => [binary.fileId, binary])
+  );
+  const states = /* @__PURE__ */ new Map();
+  const conflicts = [];
+  let downloaded = 0;
+  let conflicted = 0;
+  for (const record6 of args.document.records.values()) {
+    if (record6.deleted || record6.recordKind !== "project-file") continue;
+    if (!isObjectRecord2(record6.data)) {
+      throw new Error(`project-file:${record6.recordId} must be an object.`);
+    }
+    if (record6.data.status !== "uploaded") continue;
+    const existing = plans.get(record6.recordId);
+    if (existing !== void 0) {
+      if (existing.contentHash !== record6.contentHash)
+        throw new Error(
+          `Project file ${record6.recordId} appears with conflicting content hashes in the pulled document.`
+        );
+      continue;
+    }
+    const key = `project-file:${record6.recordId}`;
+    const previous = args.previousRecords[key];
+    const localStatus = localById.get(record6.recordId);
+    const declarationPresent = args.destructive === true || args.localBinaries === void 0 || previous === void 0 || localStatus !== void 0;
+    const path = localStatus?.path ?? previous?.projectBinary?.path ?? canonicalProjectBinaryPathV42(record6.data);
+    const absolute = resolvePath(path);
+    const localDigest = existsSync8(absolute) ? sha256File(absolute) : null;
+    const baseDigest = previous?.projectBinary?.sha256 ?? readSha256(previous?.data) ?? null;
+    const remoteDigest = requiredSha256(
+      record6.data,
+      `project-file:${record6.recordId} metadata`
+    );
+    let action = planBinaryMergeV4({
+      baseDigest,
+      localDigest,
+      remoteDigest,
+      declarationPresent,
+      hadLocalBytes: previous?.projectBinary !== void 0
+    });
+    if (args.destructive === true) {
+      action = localDigest === remoteDigest ? "unchanged" : "download";
+    }
+    const plan = {
+      key,
+      fileId: record6.recordId,
+      contentHash: record6.contentHash,
+      data: record6.data,
+      previous,
+      path,
+      baseDigest,
+      remoteDigest,
+      action
+    };
+    plans.set(record6.recordId, plan);
+    if (action === "download" || action === "conflict") downloads.push(plan);
+  }
+  let stagingDirectory;
+  try {
+    const stagedPaths = /* @__PURE__ */ new Map();
+    if (downloads.length > 0) {
+      stagingDirectory = mkdtempSync(join9(tmpdir(), "neo-pull-files-"));
+      const directory = stagingDirectory;
+      const client = args.client ?? NeoApiClient.forBaseUrl(args.workspace.config.apiBaseUrl);
+      await mapWithConcurrency(
+        downloads,
+        DOWNLOAD_CONCURRENCY,
+        async (plan, index) => {
+          const response = await download(
+            plan.data,
+            plan.fileId,
+            client,
+            args.workspace
+          );
+          if (response.sha256 !== plan.remoteDigest) {
+            throw new Error(
+              `Project file ${plan.fileId} content changed while pull was in progress (${plan.remoteDigest} -> ${response.sha256}). Pull again against a stable version head.`
+            );
+          }
+          const stagedPath = join9(directory, String(index));
+          writeFileSync8(stagedPath, response.bytes);
+          stagedPaths.set(plan.fileId, stagedPath);
+        }
+      );
+    }
+    for (const plan of plans.values()) {
+      const {
+        key,
+        fileId,
+        data,
+        previous,
+        path,
+        baseDigest,
+        remoteDigest,
+        action
+      } = plan;
+      const absolute = resolvePath(path);
+      const stagedPath = stagedPaths.get(fileId);
+      const remoteBytes = stagedPath === void 0 ? null : readFileSync11(stagedPath);
+      if (action === "download") {
+        if (remoteBytes === null) {
+          throw new Error(
+            `Project file ${fileId} download plan has no verified remote bytes.`
+          );
+        }
+        writeVerifiedBinaryDownloadV4(absolute, remoteBytes, remoteDigest);
+        downloaded += 1;
+        states.set(key, binaryState(path, remoteDigest, data));
+        continue;
+      }
+      if (action === "conflict") {
+        if (remoteBytes === null) {
+          throw new Error(
+            `Project file ${fileId} conflict plan has no verified remote bytes.`
+          );
+        }
+        const artifactPath = writeBinaryConflictArtifactV4(
+          args.workspace.root,
+          fileId,
+          fileName(data),
+          remoteBytes,
+          remoteDigest
+        );
+        const state = binaryState(path, baseDigest, data);
+        states.set(key, {
+          ...state,
+          conflict: {
+            action: "conflict",
+            remoteSha256: remoteDigest,
+            artifactPath
+          }
+        });
+        conflicts.push(path);
+        conflicted += 1;
+        continue;
+      }
+      if (action === "converged" || action === "unchanged") {
+        states.set(key, binaryState(path, remoteDigest, data));
+        removePreviousConflict(args.workspace.root, previous?.projectBinary);
+        continue;
+      }
+      states.set(key, binaryState(path, baseDigest, data));
+    }
+    for (const [key, previous] of Object.entries(args.previousRecords)) {
+      if (previous.recordKind !== "project-file") continue;
+      if (args.document.records.has(key)) continue;
+      const localStatus = localById.get(previous.recordId);
+      const path = localStatus?.path ?? previous.projectBinary?.path ?? canonicalProjectBinaryPathV42(previous.data);
+      const absolute = resolvePath(path);
+      const localDigest = existsSync8(absolute) ? sha256File(absolute) : null;
+      const baseDigest = previous.projectBinary?.sha256 ?? readSha256(previous.data) ?? null;
+      const action = planBinaryMergeV4({
+        baseDigest,
+        localDigest,
+        remoteDigest: null,
+        declarationPresent: localStatus !== void 0,
+        hadLocalBytes: previous.projectBinary !== void 0
+      });
+      if (action === "delete-modify") {
+        const data = isObjectRecord2(previous.data) ? previous.data : {};
+        states.set(key, {
+          ...binaryState(path, baseDigest, data),
+          conflict: {
+            action: "delete-modify",
+            remoteSha256: null
+          }
+        });
+        conflicts.push(path);
+        conflicted += 1;
+        continue;
+      }
+      rmSync5(absolute, { force: true });
+      removePreviousConflict(args.workspace.root, previous.projectBinary);
+    }
+    return { states, downloaded, conflicted, conflicts };
+  } finally {
+    if (stagingDirectory !== void 0)
+      rmSync5(stagingDirectory, { recursive: true, force: true });
+  }
+}
+async function download(data, fileId, client, workspace) {
+  const version = typeof data.storageETag === "string" ? `?v=${encodeURIComponent(data.storageETag)}` : "";
+  const path = `/api/projects/${workspace.config.projectId}/versions/${workspace.config.versionId}/files/${fileId}/content${version}`;
+  const response = await client.getBytes(path);
+  const computed = sha256Bytes(response.bytes);
+  const metadataDigest = requiredSha256(
+    data,
+    `project-file:${fileId} metadata`
+  );
+  const headerDigest = normalizeSha256V4(
+    response.contentSha256,
+    `download response for project file ${fileId}`
+  );
+  if (headerDigest !== null && metadataDigest !== headerDigest) {
+    throw new Error(
+      `Project file ${fileId} metadata SHA-256 ${metadataDigest} did not match authenticated content response ${headerDigest}.`
+    );
+  }
+  if (computed !== metadataDigest) {
+    throw new Error(
+      `Downloaded project file ${fileId} SHA-256 ${computed} did not match expected ${metadataDigest}.`
+    );
+  }
+  if (typeof data.byteLength === "number" && response.bytes.byteLength !== data.byteLength) {
+    throw new Error(
+      `Downloaded project file ${fileId} has ${response.bytes.byteLength} bytes; metadata requires ${data.byteLength}.`
+    );
+  }
+  if (typeof data.mimeType === "string" && response.contentType !== null && response.contentType !== data.mimeType) {
+    throw new Error(
+      `Downloaded project file ${fileId} content type ${response.contentType} did not match metadata ${data.mimeType}.`
+    );
+  }
+  return { bytes: response.bytes, sha256: computed };
+}
+function committedProjectBinaryStateV4(previous, data) {
+  return isObjectRecord2(data) ? binaryState(previous.path, readSha256(data), data) : previous;
+}
+function binaryState(path, sha256, data) {
+  return {
+    path,
+    sha256,
+    byteLength: typeof data.byteLength === "number" ? data.byteLength : 0,
+    mimeType: typeof data.mimeType === "string" ? data.mimeType : "application/octet-stream"
+  };
+}
+function readSha256(data) {
+  if (!isObjectRecord2(data)) return null;
+  return normalizeSha256V4(data.contentSha256, "project file metadata");
+}
+function requiredSha256(data, source) {
+  if (!isObjectRecord2(data)) {
+    throw new Error(`${source} must be an object.`);
+  }
+  const digest = normalizeSha256V4(data.contentSha256, source);
+  if (digest === null) {
+    throw new Error(`${source} is missing required contentSha256.`);
+  }
+  return digest;
+}
+function fileName(data) {
+  if (typeof data.name !== "string") {
+    throw new Error("Project file metadata has no filename.");
+  }
+  return data.name;
+}
+function removePreviousConflict(root, state) {
+  if (state?.conflict?.artifactPath === void 0) return;
+  rmSync5(join9(root, state.conflict.artifactPath), { force: true });
+}
+var DOWNLOAD_CONCURRENCY;
+var init_project_file_pull = __esm({
+  "src/project-source/project-file-pull.ts"() {
+    "use strict";
+    init_workspace_source_path();
+    init_concurrency();
+    init_http();
+    init_projection();
+    init_project_files();
+    DOWNLOAD_CONCURRENCY = 8;
+  }
+});
+
 // src/project-source/project-file-push.ts
-import { basename as basename2, join as join9 } from "node:path";
-import { readFileSync as readFileSync11 } from "node:fs";
+import { basename as basename2, join as join10 } from "node:path";
+import { readFileSync as readFileSync12 } from "node:fs";
 import { randomUUID as randomUUID4 } from "node:crypto";
 async function cleanupRejectedProjectFilePushesV4(args) {
   if (args.stagedUploadSessionId === null) return;
@@ -131212,8 +131521,8 @@ function prepareProjectFilePushesV4(args) {
         `Project file ${recordId} has upload bytes but its source change has no record data.`
       );
     }
-    const absolute = join9(args.workspace.root, binary.path);
-    const bytes = new Uint8Array(readFileSync11(absolute));
+    const absolute = join10(args.workspace.root, binary.path);
+    const bytes = new Uint8Array(readFileSync12(absolute));
     const digest = sha256Bytes(bytes);
     if (binary.localSha256 !== null && digest !== binary.localSha256) {
       throw new Error(
@@ -131829,8 +132138,8 @@ var init_project_version_validation = __esm({
 });
 
 // src/commands/push-body-diagnostics.ts
-import { existsSync as existsSync8, readFileSync as readFileSync12 } from "node:fs";
-import { join as join10 } from "node:path";
+import { existsSync as existsSync9, readFileSync as readFileSync13 } from "node:fs";
+import { join as join11 } from "node:path";
 function createNeoScriptBodySourceLocator(workspace, status) {
   const textByFile = /* @__PURE__ */ new Map();
   return {
@@ -131852,8 +132161,8 @@ function createNeoScriptBodySourceLocator(workspace, status) {
     textOf(file) {
       const cached = textByFile.get(file);
       if (cached !== void 0) return cached;
-      const path = join10(workspace.root, file);
-      const text = existsSync8(path) ? readFileSync12(path, "utf8") : null;
+      const path = join11(workspace.root, file);
+      const text = existsSync9(path) ? readFileSync13(path, "utf8") : null;
       textByFile.set(file, text);
       return text;
     }
@@ -132011,13 +132320,13 @@ __export(push_exports, {
 import { createHash as createHash10, randomUUID as randomUUID5 } from "node:crypto";
 import {
   mkdirSync as mkdirSync8,
-  writeFileSync as writeFileSync8,
-  rmSync as rmSync5,
-  existsSync as existsSync9,
-  readFileSync as readFileSync13,
+  writeFileSync as writeFileSync9,
+  rmSync as rmSync6,
+  existsSync as existsSync10,
+  readFileSync as readFileSync14,
   statSync
 } from "node:fs";
-import { join as join11, relative as relative6, sep as sep6 } from "node:path";
+import { join as join12, relative as relative6, sep as sep6 } from "node:path";
 function assignPendingIds(changes, authoredValueSeeds, reconstructed3) {
   const assigned = /* @__PURE__ */ new Map();
   const assign = (pendingId2) => {
@@ -132250,9 +132559,9 @@ async function commitProjectVersionChanges(args) {
     errorCode: null,
     errorMessage: null
   });
+  const connection = createConvexPushConnection(workspace);
   try {
-    const connection = await createConvexPushConnection(workspace);
-    const response = await connection.submit(body, false);
+    const response = await (await connection).submit(body, false);
     const accepted = readAcceptedProjectVersionCommitResponse(response);
     if (accepted === null) {
       if (!isObjectRecord2(response) || typeof response.kind !== "string") {
@@ -132269,7 +132578,7 @@ async function commitProjectVersionChanges(args) {
       workspace,
       accepted,
       reporter,
-      connection
+      connection: await connection
     });
     return {
       kind: completed.totalChangeCount === 0 ? "noop" : "committed",
@@ -132277,8 +132586,15 @@ async function commitProjectVersionChanges(args) {
     };
   } finally {
     reporter.stop();
+    await closePushConnection(connection);
   }
 }
+async function closePushConnection(connection) {
+  await connection.then(
+    (opened) => opened.close(),
+    () => void 0
+  );
+}
 function clientPreparedCommitBody(args) {
   return {
     operation: args.operation,
@@ -132302,7 +132618,7 @@ function readAcceptedProjectVersionCommitResponse(value) {
     throw new Error("Accepted project transaction is missing transactionId.");
   }
   const rawStatus = value.commitStatus ?? value.status;
-  if (rawStatus !== "preparing" && rawStatus !== "waiting" && rawStatus !== "queued" && rawStatus !== "applying" && rawStatus !== "reverting" && rawStatus !== "committed" && rawStatus !== "failed") {
+  if (!isProjectVersionTransactionCommitStatus(rawStatus)) {
     throw new Error(
       `Accepted project transaction "${value.transactionId}" has invalid commitStatus ${JSON.stringify(rawStatus)}.`
     );
@@ -132330,7 +132646,70 @@ function readAcceptedProjectVersionCommitResponse(value) {
     totalChangeCount,
     appliedChangeCount,
     totalChunkCount,
-    appliedChunkCount
+    appliedChunkCount,
+    ...value.completion === void 0 ? {} : {
+      completion: readAcceptedCompletion(
+        value.completion,
+        value.transactionId
+      )
+    }
+  };
+}
+function readAcceptedCompletion(value, transactionId) {
+  const status = readProjectVersionTransactionStatus(value, transactionId);
+  if (status.commitStatus !== "committed" && status.commitStatus !== "noop" && status.commitStatus !== "failed") {
+    throw new Error(
+      `Accepted project transaction "${transactionId}" reported a completion with commitStatus "${status.commitStatus}".`
+    );
+  }
+  const resultPage = isObjectRecord2(value) ? value.resultPage : void 0;
+  return resultPage === void 0 ? { status } : {
+    status,
+    resultPage: readStoredResultPage(resultPage, transactionId)
+  };
+}
+function readStoredResultPage(value, transactionId) {
+  const label = `Project transaction "${transactionId}" completion result page`;
+  if (!isObjectRecord2(value)) {
+    throw new Error(`${label} must be an object.`);
+  }
+  if (value.transactionId !== transactionId) {
+    throw new Error(
+      `${label} expected transactionId "${transactionId}"; received ${JSON.stringify(value.transactionId)}.`
+    );
+  }
+  if (!Array.isArray(value.chunks)) {
+    throw new Error(`${label} chunks must be an array.`);
+  }
+  const chunks = [];
+  for (const [index, chunk] of value.chunks.entries()) {
+    const chunkLabel = `${label} chunk ${index}`;
+    if (!isObjectRecord2(chunk)) {
+      throw new Error(`${chunkLabel} must be an object.`);
+    }
+    if (typeof chunk.assignmentsJson !== "string") {
+      throw new Error(`${chunkLabel} assignmentsJson must be a string.`);
+    }
+    if (typeof chunk.changedRecordsJson !== "string") {
+      throw new Error(`${chunkLabel} changedRecordsJson must be a string.`);
+    }
+    chunks.push({
+      chunkIndex: readCount(chunk.chunkIndex, `${chunkLabel} chunkIndex`),
+      assignmentsJson: chunk.assignmentsJson,
+      changedRecordsJson: chunk.changedRecordsJson
+    });
+  }
+  if (typeof value.isDone !== "boolean") {
+    throw new Error(`${label} isDone must be a boolean.`);
+  }
+  return {
+    transactionId,
+    chunks,
+    continueCursor: readNullableString(
+      value.continueCursor,
+      `${label} continueCursor`
+    ),
+    isDone: value.isDone
   };
 }
 function readProjectVersionTransactionStatus(value, transactionId) {
@@ -132599,24 +132978,20 @@ function progressEventFromStatus(status) {
   };
 }
 async function waitForAcceptedProjectVersionTransaction(args) {
-  const { workspace, accepted, reporter } = args;
+  const { workspace, accepted, reporter, connection } = args;
   const { projectId, versionId } = workspace.config;
   const controller = new AbortController();
   const interrupt = () => controller.abort(
     new ProjectTransactionInterruptedError(accepted.transactionId)
   );
   process.once("SIGINT", interrupt);
-  reporter.report(progressEventFromAccepted(accepted));
+  if (accepted.completion === void 0)
+    reporter.report(progressEventFromAccepted(accepted));
   const finishWait = startPerformanceSpan("transaction-wait");
-  let client;
   let unsubscribe;
   let progressTimer;
   let settled = false;
   try {
-    const connection = args.connection ?? await withTransactionAbort(
-      createConvexPushConnection(workspace),
-      controller.signal
-    );
     let failed = () => void 0;
     let updated = () => void 0;
     let firstResultPage;
@@ -132651,24 +133026,19 @@ async function waitForAcceptedProjectVersionTransaction(args) {
         };
       }
     );
-    void terminal2.catch(() => void 0);
-    client = await connection.subscribe(controller.signal, (error) => {
+    const client = connection.subscribe(controller.signal, (error) => {
       controller.abort(error);
       failed(error);
     });
-    const progressClient = client;
     const refreshProgress = async () => {
       if (settled || controller.signal.aborted) return;
       try {
         const response = await withTransactionAbort(
-          progressClient.query(
-            api2.projectVersionTransactionJobs.getTransactionStatus,
-            {
-              projectId,
-              versionId,
-              transactionId: accepted.transactionId
-            }
-          ),
+          client.query(api2.projectVersionTransactionJobs.getTransactionStatus, {
+            projectId,
+            versionId,
+            transactionId: accepted.transactionId
+          }),
           controller.signal
         );
         if (settled || controller.signal.aborted) return;
@@ -132688,29 +133058,36 @@ async function waitForAcceptedProjectVersionTransaction(args) {
     const finishFirstStatus = startPerformanceSpan("transaction-first-status");
     let firstStatus = true;
     try {
-      unsubscribe = client.onUpdate(
-        api2.projectVersionTransactionJobs.getTransactionCompletion,
-        {
-          projectId,
-          versionId,
-          transactionId: accepted.transactionId,
-          includeResultPage: true
-        },
-        (response) => {
-          if (firstStatus) {
-            firstStatus = false;
-            finishFirstStatus();
-          }
-          if (settled) return;
-          firstResultPage = response?.resultPage;
-          updated(response);
-        },
-        failed
-      );
+      if (accepted.completion === void 0) {
+        unsubscribe = client.onUpdate(
+          api2.projectVersionTransactionJobs.getTransactionCompletion,
+          {
+            projectId,
+            versionId,
+            transactionId: accepted.transactionId,
+            includeResultPage: true
+          },
+          (response) => {
+            if (firstStatus) {
+              firstStatus = false;
+              finishFirstStatus();
+            }
+            if (settled) return;
+            firstResultPage = response?.resultPage;
+            updated(response);
+          },
+          failed
+        );
+      } else {
+        firstStatus = false;
+        finishFirstStatus();
+        firstResultPage = accepted.completion.resultPage;
+        updated(accepted.completion.status);
+      }
       if (!settled)
         progressTimer = setTimeout(() => void refreshProgress(), 5e3);
       const status = await withTransactionAbort(terminal2, controller.signal);
-      unsubscribe();
+      unsubscribe?.();
       unsubscribe = void 0;
       const finishDownload = startPerformanceSpan("result-download");
       try {
@@ -132734,7 +133111,6 @@ async function waitForAcceptedProjectVersionTransaction(args) {
     clearTimeout(progressTimer);
     unsubscribe?.();
     controller.abort();
-    if (client !== void 0) await client.close();
     finishWait();
     process.removeListener("SIGINT", interrupt);
   }
@@ -132925,6 +133301,19 @@ async function runPush(workspace, options, preparationOverride) {
       `neo push cannot run from configured hook ${JSON.stringify(process.env.NEO_HOOK)}. Nested pushes are always blocked; run the intended validation command directly.`
     );
   }
+  if (options.dryRun) {
+    await pushWorkspace(workspace, options, preparationOverride, void 0);
+    return;
+  }
+  const connection = createConvexPushConnection(workspace);
+  await connection.catch(() => void 0);
+  try {
+    await pushWorkspace(workspace, options, preparationOverride, connection);
+  } finally {
+    await closePushConnection(connection);
+  }
+}
+async function pushWorkspace(workspace, options, preparationOverride, connection) {
   const configuredHook = options.dryRun ? workspace.config.prePushDryRunHook : workspace.config.prePushHook;
   const verifiesConfiguredHook = options.noVerify !== true && configuredHook !== void 0;
   const preparedInputFingerprint = verifiesConfiguredHook ? fingerprintPushInputs(workspace) : void 0;
@@ -132984,7 +133373,7 @@ async function runPush(workspace, options, preparationOverride) {
     );
   }
   if (options.noVerify !== true) {
-    const preparedBuildDir = configuredHook === void 0 ? void 0 : join11(
+    const preparedBuildDir = configuredHook === void 0 ? void 0 : join12(
       workspace.root,
       ".neo",
       "test-build",
@@ -133000,8 +133389,8 @@ async function runPush(workspace, options, preparationOverride) {
       }
       const documentJson = JSON.stringify(candidate.document);
       mkdirSync8(preparedBuildDir, { recursive: true });
-      writeFileSync8(
-        join11(preparedBuildDir, "candidate.json"),
+      writeFileSync9(
+        join12(preparedBuildDir, "candidate.json"),
         `${JSON.stringify({
           version: 1,
           projectFingerprint: `sha256:${preparedLocal.source.sourceHash}`,
@@ -133023,7 +133412,7 @@ async function runPush(workspace, options, preparationOverride) {
       });
     } finally {
       if (preparedBuildDir !== void 0) {
-        rmSync5(preparedBuildDir, { recursive: true, force: true });
+        rmSync6(preparedBuildDir, { recursive: true, force: true });
       }
     }
   } else {
@@ -133077,6 +133466,8 @@ async function runPush(workspace, options, preparationOverride) {
     }
   }
   if (options.dryRun) return;
+  if (connection === void 0)
+    throw new Error("A committing push has no connection to commit through.");
   if (isInteractive() && !await promptConfirm({
     message: `Push ${status.changes.length} change(s)?`,
     fallback: true
@@ -133158,7 +133549,6 @@ async function runPush(workspace, options, preparationOverride) {
     stagedUploadSessionId
   } = preparedPush;
   const { stagedFiles } = preparedPush;
-  let pushConnection;
   const commit = async (force) => {
     const body = clientPreparedCommitBody({
       workspace,
@@ -133170,8 +133560,7 @@ async function runPush(workspace, options, preparationOverride) {
       pendingIdAssignments: Object.fromEntries(pendingAssignment.assigned),
       summary: options.summary ?? "neo push"
     });
-    pushConnection ??= await createConvexPushConnection(workspace);
-    return await pushConnection.submit(body, force);
+    return await (await connection).submit(body, force);
   };
   const finishCommitResponse = async (response, reporter) => {
     let accepted;
@@ -133217,13 +133606,14 @@ async function runPush(workspace, options, preparationOverride) {
       if (options.json !== true) success("Push complete.");
       return true;
     }
+    const opened = await connection;
     let completed;
     try {
       completed = await waitForAcceptedProjectVersionTransaction({
         workspace,
         accepted,
         reporter,
-        connection: pushConnection
+        connection: opened
       });
     } catch (error) {
       if (error instanceof ProjectTransactionInterruptedError) {
@@ -133268,6 +133658,7 @@ async function runPush(workspace, options, preparationOverride) {
       reporter.stop();
       throw error;
     }
+    void opened.close();
     try {
       const finishApply = startPerformanceSpan("apply-result");
       try {
@@ -134223,7 +134614,8 @@ ${blockingErrors.map((error) => `  ${error.message}`).join("\n")}`
         valueIds: binding.valueIds.map(
           (id2) => rewriteAssignedString(id2, replacements)
         )
-      }))
+      })),
+      localStatus.sourceSnapshot
     );
   } catch (error) {
     workspace.state = {
@@ -134253,7 +134645,7 @@ function statusForPushResult(workspace, submitted) {
     const input = snapshot.inputs[index];
     if (input?.uri !== relative6(workspace.root, path).split(sep6).join("/"))
       return computeWorkspaceStatus2(workspace);
-    if (input.text !== readFileSync13(path, "utf8"))
+    if (input.text !== readFileSync14(path, "utf8"))
       return computeWorkspaceStatus2(workspace);
   }
   const binaries = inspectProjectBinaryStatusV4(
@@ -134422,13 +134814,14 @@ function foldChangedRecords(previous, changedRecords) {
         `Changed record "${key}" response is missing its snapshot content hash.`
       );
     }
+    const projectBinary = records2[key]?.projectBinary;
     records2[key] = {
       recordKind,
       recordId,
       contentHash: snapshot.contentHash,
       data: changed.data,
       file: records2[key]?.file,
-      projectBinary: records2[key]?.projectBinary
+      projectBinary: projectBinary && committedProjectBinaryStateV4(projectBinary, changed.data)
     };
   }
   return records2;
@@ -134459,8 +134852,8 @@ function authoredMemberFormsByFile(root, alternates) {
   for (const alternate of alternates) {
     let existing = contents.get(alternate.path);
     if (existing === void 0) {
-      const absolute = join11(root, alternate.path);
-      existing = existsSync9(absolute) ? readFileSync13(absolute, "utf8") : null;
+      const absolute = join12(root, alternate.path);
+      existing = existsSync10(absolute) ? readFileSync14(absolute, "utf8") : null;
       contents.set(alternate.path, existing);
     }
     if (existing === null || !existing.includes(alternate.block)) continue;
@@ -134509,8 +134902,8 @@ function rewriteFilesFromState(workspace, records2 = new Map(
       data: recordState.data
     }
   ])
-), preservedSourceFiles = /* @__PURE__ */ new Map(), recordFiles = /* @__PURE__ */ new Map(), localValues = workspace.state.localValues) {
-  const result = emitProjectDocumentFilesV4(
+), preservedSourceFiles = /* @__PURE__ */ new Map(), recordFiles = /* @__PURE__ */ new Map(), localValues = workspace.state.localValues, sourceSnapshot) {
+  const result = emitProjectDocumentSourcesV4(
     candidateValueRecordsForEmissionV4(
       records2,
       workspace.state.records,
@@ -134549,11 +134942,15 @@ function rewriteFilesFromState(workspace, records2 = new Map(
     }
     return { uri: file.path, kind, text: file.content };
   });
-  const finalAnalysis = files.every(
-    (file, index) => file.content === result.files[index]?.content
-  ) ? result.analysis : compileNeoProjectSources(finalInputs);
+  const unchanged = sourceSnapshot !== void 0 && sameCompilationInputs(finalInputs, sourceSnapshot.inputs);
+  const finalAnalysis = unchanged ? sourceSnapshot.analysis : compileNeoProjectSources(finalInputs);
   assertAssignedIdSourceRewriteValid(finalAnalysis);
-  writeProjectSourceAnalysisCacheV4(workspace.root, finalAnalysis, finalInputs);
+  if (!unchanged)
+    writeProjectSourceAnalysisCacheV4(
+      workspace.root,
+      finalAnalysis,
+      finalInputs
+    );
   const resolveSourcePath = createWorkspaceSourcePathResolver(workspace.root);
   const emittedEntries = new Set(
     files.map((file) => fileSystemEntryKey(resolveSourcePath(file.path)))
@@ -134561,15 +134958,13 @@ function rewriteFilesFromState(workspace, records2 = new Map(
   const output = new Map(
     files.map((file) => [file.path, file.content])
   );
-  const previousPaths = [
-    ...Object.values(workspace.state.records).flatMap(
-      (record6) => record6.file === void 0 ? [] : [record6.file]
-    ),
-    ...preservedSourceFiles.keys()
-  ];
+  const previousPaths = new Set(preservedSourceFiles.keys());
+  for (const record6 of Object.values(workspace.state.records)) {
+    if (record6.file !== void 0) previousPaths.add(record6.file);
+  }
   for (const path of previousPaths) {
     const absolute = resolveSourcePath(path);
-    if (!existsSync9(absolute) || emittedEntries.has(fileSystemEntryKey(absolute)))
+    if (!existsSync10(absolute) || emittedEntries.has(fileSystemEntryKey(absolute)))
       continue;
     output.set(normalizeWorkspaceSourcePath(path), null);
   }
@@ -134577,7 +134972,7 @@ function rewriteFilesFromState(workspace, records2 = new Map(
     const absolute = resolveSourcePath(path);
     return {
       path,
-      before: existsSync9(absolute) ? readFileSync13(absolute, "utf8") : null,
+      before: existsSync10(absolute) ? readFileSync14(absolute, "utf8") : null,
       after
     };
   });
@@ -134603,6 +134998,13 @@ function rewriteFilesFromState(workspace, records2 = new Map(
   writeWorkspaceState(workspace.root, workspace.state);
   finishCommittedPushProjection(workspace);
 }
+function sameCompilationInputs(left, right) {
+  if (left.length !== right.length) return false;
+  return left.every((input, index) => {
+    const other = right[index];
+    return input.uri === other?.uri && input.kind === other.kind && input.text === other.text;
+  });
+}
 function assertAssignedIdSourceRewriteValid(analysis) {
   const finalErrors = analysis.diagnostics.filter(
     (diagnostic) => diagnostic.severity === "error" && !isPullRecoveryDiagnosticCode(diagnostic.code)
@@ -134629,7 +135031,7 @@ function materializeAssignedSchemaIdsInAuthoredSource(workspace, replacements, p
   if (pendingIdsByUri.size === 0) return /* @__PURE__ */ new Map();
   const inputs = options.sourceSnapshot?.inputs ?? listProjectSourceFilesV4(workspace.root).map((absolutePath) => {
     const uri = relative6(workspace.root, absolutePath).split(sep6).join("/");
-    const text = readFileSync13(absolutePath, "utf8");
+    const text = readFileSync14(absolutePath, "utf8");
     const kind = neoProjectSourceKind(uri, text);
     if (kind === null || !isNeoProjectProductionSourceKind(kind)) {
       throw new Error(
@@ -135433,6 +135835,7 @@ var init_push = __esm({
     init_project_documents();
     init_project_document_cache();
     init_project_files();
+    init_project_file_pull();
     init_workspace_status();
     init_lower_support();
     init_init_conversion();
@@ -136190,13 +136593,13 @@ var init_source_record_comparison = __esm({
 
 // src/project-source/reset.ts
 import {
-  existsSync as existsSync10,
+  existsSync as existsSync11,
   mkdirSync as mkdirSync9,
-  readFileSync as readFileSync14,
-  rmSync as rmSync6,
-  writeFileSync as writeFileSync9
+  readFileSync as readFileSync15,
+  rmSync as rmSync7,
+  writeFileSync as writeFileSync10
 } from "node:fs";
-import { dirname as dirname8, join as join12, relative as relative7, sep as sep7 } from "node:path";
+import { dirname as dirname8, join as join13, relative as relative7, sep as sep7 } from "node:path";
 function prepareWorkspaceResetV4(workspace, document, options = {}) {
   const emissionRecords = options.regenerateSourceNames ? regenerateDialogueSourceNamesV4(document.records) : document.records;
   const layoutWorkspace = workspaceForSourceLayoutV4(workspace, document);
@@ -136226,21 +136629,21 @@ function resetWorkspaceToProjectSourcesV4(workspace, document, options = {}) {
   }
   for (const file of emitted.files) obsolete.delete(file.path);
   for (const path of obsolete) {
-    rmSync6(resolveSourcePath(path), { force: true });
+    rmSync7(resolveSourcePath(path), { force: true });
   }
   for (const file of LEGACY_ROOT_FILES) {
-    rmSync6(join12(workspace.root, file), { force: true });
+    rmSync7(join13(workspace.root, file), { force: true });
   }
   for (const privatePath of LEGACY_PRIVATE_PATHS) {
-    rmSync6(join12(workspace.root, privatePath), { recursive: true, force: true });
+    rmSync7(join13(workspace.root, privatePath), { recursive: true, force: true });
   }
   for (const file of emitted.files) {
     const absolute = resolveSourcePath(file.path);
     mkdirSync9(dirname8(absolute), { recursive: true });
-    if (existsSync10(absolute) && readFileSync14(absolute, "utf8") === file.content) {
+    if (existsSync11(absolute) && readFileSync15(absolute, "utf8") === file.content) {
       continue;
     }
-    writeFileSync9(absolute, file.content, "utf8");
+    writeFileSync10(absolute, file.content, "utf8");
   }
   writeProjectSourceAnalysisCacheV4(workspace.root, emitted.analysis);
   const records2 = {};
@@ -136281,7 +136684,7 @@ function trackedProductionSourcesBeforeReset(workspace, resolveSourcePath) {
       continue;
     }
     const absolute = resolveSourcePath(path);
-    if (existsSync10(absolute)) paths.add(path);
+    if (existsSync11(absolute)) paths.add(path);
   }
   return paths;
 }
@@ -136325,280 +136728,6 @@ var init_reset = __esm({
   }
 });
 
-// src/project-source/project-file-pull.ts
-import {
-  existsSync as existsSync11,
-  mkdtempSync,
-  readFileSync as readFileSync15,
-  rmSync as rmSync7,
-  writeFileSync as writeFileSync10
-} from "node:fs";
-import { tmpdir } from "node:os";
-import { join as join13 } from "node:path";
-async function pullProjectBinariesV4(args) {
-  const resolvePath = createWorkspaceSourcePathResolver(args.workspace.root);
-  const plans = /* @__PURE__ */ new Map();
-  const downloads = [];
-  const localById = new Map(
-    (args.localBinaries ?? []).map((binary) => [binary.fileId, binary])
-  );
-  const states = /* @__PURE__ */ new Map();
-  const conflicts = [];
-  let downloaded = 0;
-  let conflicted = 0;
-  for (const record6 of args.document.records.values()) {
-    if (record6.deleted || record6.recordKind !== "project-file") continue;
-    if (!isObjectRecord2(record6.data)) {
-      throw new Error(`project-file:${record6.recordId} must be an object.`);
-    }
-    if (record6.data.status !== "uploaded") continue;
-    const existing = plans.get(record6.recordId);
-    if (existing !== void 0) {
-      if (existing.contentHash !== record6.contentHash)
-        throw new Error(
-          `Project file ${record6.recordId} appears with conflicting content hashes in the pulled document.`
-        );
-      continue;
-    }
-    const key = `project-file:${record6.recordId}`;
-    const previous = args.previousRecords[key];
-    const localStatus = localById.get(record6.recordId);
-    const declarationPresent = args.destructive === true || args.localBinaries === void 0 || previous === void 0 || localStatus !== void 0;
-    const path = localStatus?.path ?? previous?.projectBinary?.path ?? canonicalProjectBinaryPathV42(record6.data);
-    const absolute = resolvePath(path);
-    const localDigest = existsSync11(absolute) ? sha256File(absolute) : null;
-    const baseDigest = previous?.projectBinary?.sha256 ?? readSha256(previous?.data) ?? null;
-    const remoteDigest = requiredSha256(
-      record6.data,
-      `project-file:${record6.recordId} metadata`
-    );
-    let action = planBinaryMergeV4({
-      baseDigest,
-      localDigest,
-      remoteDigest,
-      declarationPresent,
-      hadLocalBytes: previous?.projectBinary !== void 0
-    });
-    if (args.destructive === true) {
-      action = localDigest === remoteDigest ? "unchanged" : "download";
-    }
-    const plan = {
-      key,
-      fileId: record6.recordId,
-      contentHash: record6.contentHash,
-      data: record6.data,
-      previous,
-      path,
-      baseDigest,
-      remoteDigest,
-      action
-    };
-    plans.set(record6.recordId, plan);
-    if (action === "download" || action === "conflict") downloads.push(plan);
-  }
-  let stagingDirectory;
-  try {
-    const stagedPaths = /* @__PURE__ */ new Map();
-    if (downloads.length > 0) {
-      stagingDirectory = mkdtempSync(join13(tmpdir(), "neo-pull-files-"));
-      const directory = stagingDirectory;
-      const client = args.client ?? NeoApiClient.forBaseUrl(args.workspace.config.apiBaseUrl);
-      await mapWithConcurrency(
-        downloads,
-        DOWNLOAD_CONCURRENCY,
-        async (plan, index) => {
-          const response = await download(
-            plan.data,
-            plan.fileId,
-            client,
-            args.workspace
-          );
-          if (response.sha256 !== plan.remoteDigest) {
-            throw new Error(
-              `Project file ${plan.fileId} content changed while pull was in progress (${plan.remoteDigest} -> ${response.sha256}). Pull again against a stable version head.`
-            );
-          }
-          const stagedPath = join13(directory, String(index));
-          writeFileSync10(stagedPath, response.bytes);
-          stagedPaths.set(plan.fileId, stagedPath);
-        }
-      );
-    }
-    for (const plan of plans.values()) {
-      const {
-        key,
-        fileId,
-        data,
-        previous,
-        path,
-        baseDigest,
-        remoteDigest,
-        action
-      } = plan;
-      const absolute = resolvePath(path);
-      const stagedPath = stagedPaths.get(fileId);
-      const remoteBytes = stagedPath === void 0 ? null : readFileSync15(stagedPath);
-      if (action === "download") {
-        if (remoteBytes === null) {
-          throw new Error(
-            `Project file ${fileId} download plan has no verified remote bytes.`
-          );
-        }
-        writeVerifiedBinaryDownloadV4(absolute, remoteBytes, remoteDigest);
-        downloaded += 1;
-        states.set(key, binaryState(path, remoteDigest, data));
-        continue;
-      }
-      if (action === "conflict") {
-        if (remoteBytes === null) {
-          throw new Error(
-            `Project file ${fileId} conflict plan has no verified remote bytes.`
-          );
-        }
-        const artifactPath = writeBinaryConflictArtifactV4(
-          args.workspace.root,
-          fileId,
-          fileName(data),
-          remoteBytes,
-          remoteDigest
-        );
-        const state = binaryState(path, baseDigest, data);
-        states.set(key, {
-          ...state,
-          conflict: {
-            action: "conflict",
-            remoteSha256: remoteDigest,
-            artifactPath
-          }
-        });
-        conflicts.push(path);
-        conflicted += 1;
-        continue;
-      }
-      if (action === "converged" || action === "unchanged") {
-        states.set(key, binaryState(path, remoteDigest, data));
-        removePreviousConflict(args.workspace.root, previous?.projectBinary);
-        continue;
-      }
-      states.set(key, binaryState(path, baseDigest, data));
-    }
-    for (const [key, previous] of Object.entries(args.previousRecords)) {
-      if (previous.recordKind !== "project-file") continue;
-      if (args.document.records.has(key)) continue;
-      const localStatus = localById.get(previous.recordId);
-      const path = localStatus?.path ?? previous.projectBinary?.path ?? canonicalProjectBinaryPathV42(previous.data);
-      const absolute = resolvePath(path);
-      const localDigest = existsSync11(absolute) ? sha256File(absolute) : null;
-      const baseDigest = previous.projectBinary?.sha256 ?? readSha256(previous.data) ?? null;
-      const action = planBinaryMergeV4({
-        baseDigest,
-        localDigest,
-        remoteDigest: null,
-        declarationPresent: localStatus !== void 0,
-        hadLocalBytes: previous.projectBinary !== void 0
-      });
-      if (action === "delete-modify") {
-        const data = isObjectRecord2(previous.data) ? previous.data : {};
-        states.set(key, {
-          ...binaryState(path, baseDigest, data),
-          conflict: {
-            action: "delete-modify",
-            remoteSha256: null
-          }
-        });
-        conflicts.push(path);
-        conflicted += 1;
-        continue;
-      }
-      rmSync7(absolute, { force: true });
-      removePreviousConflict(args.workspace.root, previous.projectBinary);
-    }
-    return { states, downloaded, conflicted, conflicts };
-  } finally {
-    if (stagingDirectory !== void 0)
-      rmSync7(stagingDirectory, { recursive: true, force: true });
-  }
-}
-async function download(data, fileId, client, workspace) {
-  const version = typeof data.storageETag === "string" ? `?v=${encodeURIComponent(data.storageETag)}` : "";
-  const path = `/api/projects/${workspace.config.projectId}/versions/${workspace.config.versionId}/files/${fileId}/content${version}`;
-  const response = await client.getBytes(path);
-  const computed = sha256Bytes(response.bytes);
-  const metadataDigest = requiredSha256(
-    data,
-    `project-file:${fileId} metadata`
-  );
-  const headerDigest = normalizeSha256V4(
-    response.contentSha256,
-    `download response for project file ${fileId}`
-  );
-  if (headerDigest !== null && metadataDigest !== headerDigest) {
-    throw new Error(
-      `Project file ${fileId} metadata SHA-256 ${metadataDigest} did not match authenticated content response ${headerDigest}.`
-    );
-  }
-  if (computed !== metadataDigest) {
-    throw new Error(
-      `Downloaded project file ${fileId} SHA-256 ${computed} did not match expected ${metadataDigest}.`
-    );
-  }
-  if (typeof data.byteLength === "number" && response.bytes.byteLength !== data.byteLength) {
-    throw new Error(
-      `Downloaded project file ${fileId} has ${response.bytes.byteLength} bytes; metadata requires ${data.byteLength}.`
-    );
-  }
-  if (typeof data.mimeType === "string" && response.contentType !== null && response.contentType !== data.mimeType) {
-    throw new Error(
-      `Downloaded project file ${fileId} content type ${response.contentType} did not match metadata ${data.mimeType}.`
-    );
-  }
-  return { bytes: response.bytes, sha256: computed };
-}
-function binaryState(path, sha256, data) {
-  return {
-    path,
-    sha256,
-    byteLength: typeof data.byteLength === "number" ? data.byteLength : 0,
-    mimeType: typeof data.mimeType === "string" ? data.mimeType : "application/octet-stream"
-  };
-}
-function readSha256(data) {
-  if (!isObjectRecord2(data)) return null;
-  return normalizeSha256V4(data.contentSha256, "project file metadata");
-}
-function requiredSha256(data, source) {
-  if (!isObjectRecord2(data)) {
-    throw new Error(`${source} must be an object.`);
-  }
-  const digest = normalizeSha256V4(data.contentSha256, source);
-  if (digest === null) {
-    throw new Error(`${source} is missing required contentSha256.`);
-  }
-  return digest;
-}
-function fileName(data) {
-  if (typeof data.name !== "string") {
-    throw new Error("Project file metadata has no filename.");
-  }
-  return data.name;
-}
-function removePreviousConflict(root, state) {
-  if (state?.conflict?.artifactPath === void 0) return;
-  rmSync7(join13(root, state.conflict.artifactPath), { force: true });
-}
-var DOWNLOAD_CONCURRENCY;
-var init_project_file_pull = __esm({
-  "src/project-source/project-file-pull.ts"() {
-    "use strict";
-    init_workspace_source_path();
-    init_concurrency();
-    init_http();
-    init_projection();
-    init_project_files();
-    DOWNLOAD_CONCURRENCY = 8;
-  }
-});
-
 // src/project-source/static-value-seed-records.ts
 function staticValueSeedEmitRecords(status, present, projectId, mainLocale) {
   const records2 = /* @__PURE__ */ new Map();
@@ -140752,7 +140881,7 @@ var init_registry2 = __esm({
   "schema-contract/registry.mjs"() {
     "use strict";
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
-      cliVersion: "0.59.0",
+      cliVersion: "0.59.2",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -148573,7 +148702,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.59.0");
+    console.log("0.59.2");
     return;
   }
   if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {