@neocompose/cli 0.58.1 → 0.58.3

package/dist/neo.mjs

@@ -86570,6 +86570,54 @@ var init_materialize_values = __esm({
   }
 });
 
+// ../convex/convexValues.ts
+function decodeConvexOpaqueJson(value, context) {
+  if (typeof value !== "string") {
+    throw new Error(`${context} must be an encoded JSON string.`);
+  }
+  try {
+    return JSON.parse(value);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`${context} could not be parsed as JSON: ${message}`);
+  }
+}
+var CONVEX_DOCUMENT_WARNING_BYTES, CONVEX_DOCUMENT_MAX_BYTES;
+var init_convexValues = __esm({
+  "../convex/convexValues.ts"() {
+    "use strict";
+    CONVEX_DOCUMENT_WARNING_BYTES = 750 * 1024;
+    CONVEX_DOCUMENT_MAX_BYTES = 1024 * 1024;
+  }
+});
+
+// ../convex/projectRecordSnapshotStorage.ts
+function decodeProjectRecordSnapshotData(snapshot, context = `Project record snapshot for ${snapshot.recordKind} "${snapshot.recordId}" dataJson`) {
+  const decoded = decodeConvexOpaqueJson(snapshot.dataJson, context);
+  if (!isPlainRecord(decoded)) return decoded;
+  const hydratedData = { ...decoded };
+  if (snapshot.recordKind === "enum" && !Object.hasOwn(hydratedData, "optionKeyOrder") && isPlainRecord(hydratedData.options)) {
+    hydratedData.optionKeyOrder = Object.keys(hydratedData.options);
+  }
+  hydratedData.id = snapshot.recordId;
+  if (snapshot.recordKind !== "project") {
+    hydratedData.projectId = snapshot.projectId;
+  }
+  if (!Object.hasOwn(hydratedData, "updatedAt")) {
+    hydratedData.updatedAt = snapshot.createdAt;
+  }
+  return hydratedData;
+}
+function isPlainRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var init_projectRecordSnapshotStorage = __esm({
+  "../convex/projectRecordSnapshotStorage.ts"() {
+    "use strict";
+    init_convexValues();
+  }
+});
+
 // ../src/database/project-read-base.ts
 import { ConvexError } from "convex/values";
 function readProjectReadBase(value) {
@@ -86887,6 +86935,7 @@ var project_document_read_exports = {};
 __export(project_document_read_exports, {
   DOCUMENT_MANIFEST_PAGE_SIZE: () => DOCUMENT_MANIFEST_PAGE_SIZE,
   assembleProjectDocumentRaw: () => assembleProjectDocumentRaw,
+  createDocumentPageReader: () => createDocumentPageReader,
   fetchProjectDocumentPartitionRecords: () => fetchProjectDocumentPartitionRecords,
   fetchProjectDocumentRawChunked: () => fetchProjectDocumentRawChunked,
   fetchProjectDocumentRawChunkedOnce: () => fetchProjectDocumentRawChunkedOnce,
@@ -86944,46 +86993,14 @@ async function fetchProjectDocumentRawChunkedOnce(runner, options = {}) {
   };
   try {
     await rememberRecords(firstPage);
-    const fetchRemainingPages = async (mapKey, initialCursor) => {
-      let cursor = initialCursor;
-      while (cursor !== null) {
-        const pageResult = await runner.fetchPage(
-          {
-            numItems: DOCUMENT_MANIFEST_PAGE_SIZE,
-            cursor
-          },
-          mapKey,
-          readBase
-        );
-        if (pageResult === null) {
-          throw new Error(
-            "Convex project document manifest returned null for a continuation page."
-          );
-        }
-        const page = readProjectDocumentPage(pageResult);
-        assertProjectReadBase(readBase, page.readBase);
-        await rememberRecords(page);
-        cursor = page.continueCursor;
-      }
-    };
-    await fetchRemainingPages(firstMapKey, firstPage.continueCursor);
-    for (const mapKey of mapKeys.slice(1)) {
-      const pageResult = await runner.fetchPage(
-        { numItems: DOCUMENT_MANIFEST_PAGE_SIZE, cursor: null },
-        mapKey,
-        readBase,
-        "omit"
-      );
-      if (pageResult === null) {
-        throw new Error(
-          `Convex project document manifest returned null for partition "${mapKey ?? "all"}".`
-        );
-      }
-      const page = readProjectDocumentPage(pageResult);
-      assertProjectReadBase(readBase, page.readBase);
-      await rememberRecords(page);
-      await fetchRemainingPages(mapKey, page.continueCursor);
-    }
+    const pages = createDocumentPageReader(runner, firstPage.readConcurrency);
+    await drainDocumentReads([
+      pages.remaining(firstPage, firstMapKey, readBase, rememberRecords),
+      ...mapKeys.slice(1).map(async (mapKey) => {
+        const page = await pages.first(mapKey, readBase, rememberRecords);
+        await pages.remaining(page, mapKey, readBase, rememberRecords);
+      })
+    ]);
     const snapshotsById = await snapshots.finish();
     if (options.mapKeys !== void 0 && !options.mapKeys.includes("all")) {
       const members = [];
@@ -87043,28 +87060,15 @@ async function fetchProjectDocumentPartitionRecords(runner, mapKey, readBase) {
     (ids) => fetchScopedSnapshotBatch(runner, ids, readBase)
   );
   try {
-    let cursor = null;
-    do {
-      const pageResult = await runner.fetchPage(
-        { numItems: DOCUMENT_MANIFEST_PAGE_SIZE, cursor },
-        mapKey,
-        readBase,
-        "omit"
-      );
-      if (pageResult === null) {
-        throw new Error(
-          `Convex project document manifest returned null for partition "${mapKey}".`
-        );
-      }
-      const page = readProjectDocumentPage(pageResult);
-      assertProjectReadBase(readBase, page.readBase);
-      for (const record6 of page.records) {
+    const pages = createDocumentPageReader(runner);
+    const remember = async (page) => {
+      for (const record6 of page.records)
         recordsByKey.set(`${record6.recordKind} ${record6.recordId}`, record6);
-      }
       if (page.snapshots !== void 0) snapshots.seed(page.snapshots);
       await snapshots.enqueue(page.records.map((record6) => record6.snapshotId));
-      cursor = page.continueCursor;
-    } while (cursor !== null);
+    };
+    const first = await pages.first(mapKey, readBase, remember);
+    await pages.remaining(first, mapKey, readBase, remember);
     const snapshotsById = await snapshots.finish();
     await runner.validateReadBase(readBase);
     return [...recordsByKey.values()].map((record6) => {
@@ -87086,6 +87090,84 @@ async function fetchProjectDocumentPartitionRecords(runner, mapKey, readBase) {
     await snapshots.stop();
   }
 }
+function createDocumentPageReader(runner, concurrency) {
+  let active = 0;
+  let nextWaiter = 0;
+  let waiters = [];
+  let failure;
+  const readPage = async (pagination, mapKey, readBase, remember) => {
+    if (active >= (concurrency ?? 1))
+      await new Promise((resolve5) => waiters.push(resolve5));
+    else active++;
+    try {
+      if (failure !== void 0) throw failure.error;
+      const raw = await runner.fetchPage(pagination, mapKey, readBase, "omit");
+      if (raw === null)
+        throw new Error(
+          `Missing document page for partition "${mapKey ?? "all"}".`
+        );
+      const page = readProjectDocumentPage(raw);
+      assertProjectReadBase(readBase, page.readBase);
+      concurrency ??= page.readConcurrency ?? 1;
+      if (pagination.cursor !== null && page.continueCursor === pagination.cursor)
+        throw new Error("Document continuation made no progress.");
+      if (pagination.endCursor != null && page.continueCursor === null)
+        throw new Error("Document range ended before its endpoint.");
+      await remember(page, pagination.cursor);
+      return page;
+    } catch (error) {
+      failure ??= { error };
+      throw error;
+    } finally {
+      const next = waiters[nextWaiter++];
+      if (next !== void 0) next();
+      else {
+        active--;
+        nextWaiter = 0;
+        waiters = [];
+      }
+    }
+  };
+  return {
+    first(mapKey, readBase, remember) {
+      return readPage(
+        { numItems: DOCUMENT_MANIFEST_PAGE_SIZE, cursor: null },
+        mapKey,
+        readBase,
+        remember
+      );
+    },
+    async remaining(first, mapKey, readBase, remember) {
+      if (first.continueCursor === null) return;
+      const ranges = first.remainingRanges ?? [
+        { cursor: first.continueCursor, endCursor: null }
+      ];
+      await drainDocumentReads(
+        ranges.map(async (range2) => {
+          let cursor = range2.cursor;
+          while (cursor !== null && cursor !== range2.endCursor) {
+            const page = await readPage(
+              {
+                numItems: DOCUMENT_MANIFEST_PAGE_SIZE,
+                cursor,
+                endCursor: range2.endCursor
+              },
+              mapKey,
+              readBase,
+              remember
+            );
+            cursor = page.continueCursor;
+          }
+        })
+      );
+    }
+  };
+}
+async function drainDocumentReads(reads) {
+  const results = await Promise.allSettled(reads);
+  for (const result of results)
+    if (result.status === "rejected") throw result.reason;
+}
 async function fetchProjectDocumentValueRecords(runner, valueIds, readBase) {
   if (runner.fetchValueSnapshotsPage === void 0) {
     throw new Error(
@@ -87151,6 +87233,41 @@ function readProjectDocumentPage(value) {
       "Convex project document manifest page continueCursor must be a string or null."
     );
   }
+  let remainingRanges;
+  if (value.remainingRanges !== void 0) {
+    if (!Array.isArray(value.remainingRanges))
+      throw new Error("Snapshot remaining ranges must be an array.");
+    remainingRanges = [];
+    let expectedCursor = continueCursor;
+    for (const range2 of value.remainingRanges) {
+      if (!isObject4(range2))
+        throw new Error("Snapshot range must be an object.");
+      if (typeof range2.cursor !== "string")
+        throw new Error("Snapshot range cursor must be a string.");
+      if (range2.endCursor !== null && typeof range2.endCursor !== "string")
+        throw new Error("Snapshot range end cursor must be a string or null.");
+      if (range2.cursor !== expectedCursor)
+        throw new Error("Snapshot ranges must form a contiguous continuation.");
+      if (range2.cursor === range2.endCursor)
+        throw new Error("Snapshot range must make progress.");
+      remainingRanges.push({
+        cursor: range2.cursor,
+        endCursor: range2.endCursor
+      });
+      expectedCursor = range2.endCursor;
+    }
+    if (expectedCursor !== null)
+      throw new Error("Snapshot ranges must cover the entire remaining tail.");
+  }
+  const readConcurrency = value.readConcurrency;
+  if (readConcurrency !== void 0) {
+    if (typeof readConcurrency !== "number")
+      throw new Error("Document read concurrency must be a number.");
+    if (!Number.isSafeInteger(readConcurrency))
+      throw new Error("Document read concurrency must be a safe integer.");
+    if (readConcurrency < 1)
+      throw new Error("Document read concurrency must be positive.");
+  }
   const metadata = value.metadata ?? null;
   if (metadata !== null && !isObject4(metadata)) {
     throw new Error(
@@ -87167,6 +87284,8 @@ function readProjectDocumentPage(value) {
       releaseChannels: metadata.releaseChannels,
       documentRevision: metadata.documentRevision
     },
+    ...remainingRanges === void 0 ? {} : { remainingRanges },
+    ...readConcurrency === void 0 ? {} : { readConcurrency },
     ...snapshots === void 0 ? {} : { snapshots },
     records: snapshots === void 0 ? readProjectDocumentManifestRecords(value.records) : snapshots.map((snapshot) => ({
       recordKind: snapshot.recordKind,
@@ -87220,7 +87339,21 @@ function readProjectDocumentManifestPageRecords(value) {
   if (!isObject4(value)) {
     throw new Error("Convex project document manifest page must be an object.");
   }
-  return readProjectDocumentPage(value).records;
+  if (value.snapshots === void 0)
+    return readProjectDocumentManifestRecords(value.records);
+  if (!Array.isArray(value.snapshots))
+    throw new Error("Snapshot page snapshots must be an array.");
+  return readProjectDocumentManifestRecords(
+    value.snapshots.map((snapshot) => {
+      if (!isObject4(snapshot))
+        throw new Error("Snapshot page entry must be an object.");
+      return {
+        recordKind: snapshot.recordKind,
+        recordId: snapshot.recordId,
+        snapshotId: snapshot.id
+      };
+    })
+  );
 }
 async function fetchProjectDocumentSnapshots(fetchBatch, snapshotIds) {
   const loader = createProjectDocumentSnapshotLoader(fetchBatch);
@@ -87236,6 +87369,7 @@ function createProjectDocumentSnapshotLoader(fetchBatch) {
   const snapshotsById = /* @__PURE__ */ new Map();
   const active = /* @__PURE__ */ new Set();
   let pending = [];
+  let enqueued = Promise.resolve();
   let stopped = false;
   let failure;
   const checkFailure = () => {
@@ -87272,17 +87406,21 @@ function createProjectDocumentSnapshotLoader(fetchBatch) {
         snapshotsById.set(snapshot.id, snapshot);
       }
     },
-    async enqueue(snapshotIds) {
-      checkFailure();
-      for (const id2 of snapshotIds) {
-        if (seen.has(id2)) continue;
-        seen.add(id2);
-        pending.push(id2);
-        if (pending.length === DOCUMENT_SNAPSHOT_FETCH_CHUNK_SIZE)
-          await flush();
-      }
+    enqueue(snapshotIds) {
+      enqueued = enqueued.then(async () => {
+        checkFailure();
+        for (const id2 of snapshotIds) {
+          if (seen.has(id2)) continue;
+          seen.add(id2);
+          pending.push(id2);
+          if (pending.length === DOCUMENT_SNAPSHOT_FETCH_CHUNK_SIZE)
+            await flush();
+        }
+      });
+      return enqueued;
     },
     async finish() {
+      await enqueued;
       await flush();
       await Promise.all(active);
       checkFailure();
@@ -87290,6 +87428,8 @@ function createProjectDocumentSnapshotLoader(fetchBatch) {
     },
     async stop() {
       stopped = true;
+      await enqueued.catch(() => {
+      });
       await Promise.all(active);
     }
   };
@@ -87361,6 +87501,30 @@ function readProjectDocumentSnapshotBatch(value, requestedIds) {
         `Convex project record snapshot "${snapshot.id}" is missing a content hash.`
       );
     }
+    let data = snapshot.data;
+    if ("dataJson" in snapshot) {
+      if (typeof snapshot.dataJson !== "string")
+        throw new Error(`Snapshot "${snapshot.id}" dataJson must be a string.`);
+      if (typeof snapshot.projectId !== "string")
+        throw new Error(
+          `Snapshot "${snapshot.id}" projectId must be a string.`
+        );
+      if (typeof snapshot.createdAt !== "number")
+        throw new Error(
+          `Snapshot "${snapshot.id}" createdAt must be a number.`
+        );
+      if (!Number.isFinite(snapshot.createdAt))
+        throw new Error(
+          `Snapshot "${snapshot.id}" createdAt must be finite milliseconds.`
+        );
+      data = decodeProjectRecordSnapshotData({
+        projectId: snapshot.projectId,
+        recordKind,
+        recordId: snapshot.recordId,
+        createdAt: snapshot.createdAt,
+        dataJson: snapshot.dataJson
+      });
+    }
     return {
       id: snapshot.id,
       recordKind,
@@ -87371,7 +87535,7 @@ function readProjectDocumentSnapshotBatch(value, requestedIds) {
       data: readCurrentProjectRecordData({
         recordKind,
         dataSchemaVersion: snapshot.dataSchemaVersion,
-        data: snapshot.data
+        data
       })
     };
   });
@@ -87693,6 +87857,7 @@ var DOCUMENT_MANIFEST_PAGE_SIZE, DOCUMENT_SNAPSHOT_FETCH_CHUNK_SIZE, DOCUMENT_SN
 var init_project_document_read = __esm({
   "../src/database/project-document-read.ts"() {
     "use strict";
+    init_projectRecordSnapshotStorage();
     init_project_read_base();
     init_project2();
     init_members();
@@ -87711,7 +87876,7 @@ var init_project_document_read = __esm({
     init_projectRecordBuckets();
     init_project_record_migrations();
     init_member_default_reference_ids();
-    DOCUMENT_MANIFEST_PAGE_SIZE = 2048;
+    DOCUMENT_MANIFEST_PAGE_SIZE = 8192;
     DOCUMENT_SNAPSHOT_FETCH_CHUNK_SIZE = 128;
     DOCUMENT_SNAPSHOT_FETCH_CONCURRENCY = 4;
   }
@@ -88394,7 +88559,7 @@ var init_commit_preparation_scope_planner = __esm({
 
 // ../src/database/project-record-semantics.ts
 function projectRecordSemanticData(value) {
-  if (!isPlainRecord(value)) return value;
+  if (!isPlainRecord2(value)) return value;
   const semantic = {};
   for (const [key, child] of Object.entries(value)) {
     if (SERVER_MANAGED_PROJECT_RECORD_FIELDS.has(key)) continue;
@@ -88431,7 +88596,7 @@ function toCanonicalJsonValue2(value) {
   if (Array.isArray(value)) {
     return value.map((item) => toCanonicalJsonValue2(item) ?? null);
   }
-  if (!isPlainRecord(value)) {
+  if (!isPlainRecord2(value)) {
     throw new Error("Cannot canonicalize a non-plain object.");
   }
   const canonical = {};
@@ -88445,7 +88610,7 @@ function toCanonicalJsonValue2(value) {
   }
   return canonical;
 }
-function isPlainRecord(value) {
+function isPlainRecord2(value) {
   if (value === null || typeof value !== "object") return false;
   const prototype = Object.getPrototypeOf(value);
   return prototype === Object.prototype || prototype === null;
@@ -88479,7 +88644,7 @@ function stagedChangesAffectClassRelations(current, changes) {
       const before2 = classesById.get(change.recordId);
       if (before2 === void 0) return true;
       const after = change.nextData;
-      if (!isPlainRecord2(after)) return true;
+      if (!isPlainRecord3(after)) return true;
       if (before2.extendsClassId !== after.extendsClassId) return true;
       continue;
     }
@@ -88498,11 +88663,11 @@ function valueCreateCannotAffectClassRelations(change, before) {
   return before === void 0;
 }
 function relationEndpointClassId(record6) {
-  if (!isPlainRecord2(record6)) return void 0;
+  if (!isPlainRecord3(record6)) return void 0;
   if (typeof record6.classId === "string") return record6.classId;
   return void 0;
 }
-function isPlainRecord2(value) {
+function isPlainRecord3(value) {
   if (value === null || typeof value !== "object") return false;
   return !Array.isArray(value);
 }
@@ -88558,7 +88723,7 @@ function assertWorldFootprintEntryTypes(document, changes) {
     if (change.recordKind !== "value" || change.operation === "delete" || change.deleted)
       continue;
     referencedIds2.add(change.recordId);
-    if (isPlainRecord3(change.nextData) && Array.isArray(change.nextData.value)) {
+    if (isPlainRecord4(change.nextData) && Array.isArray(change.nextData.value)) {
       for (const id2 of change.nextData.value)
         if (typeof id2 === "string") referencedIds2.add(id2);
     }
@@ -88595,14 +88760,14 @@ function createdWorldPlacementIds(changes, worldKinds) {
 }
 function hasWorldPlacementBinding(value, worldKinds) {
   if (hasWorldPlacementSidecar(value)) return true;
-  if (!isPlainRecord3(value) || typeof value.containerId !== "string")
+  if (!isPlainRecord4(value) || typeof value.containerId !== "string")
     return false;
   if (typeof value.classId !== "string") return false;
   const kind = worldKinds?.get(value.classId);
   return kind === NeoWorldSystemClassKind.Tile;
 }
 function hasWorldPlacementSidecar(value) {
-  if (!isPlainRecord3(value) || !isPlainRecord3(value.value)) return false;
+  if (!isPlainRecord4(value) || !isPlainRecord4(value.value)) return false;
   const body = value.value;
   if (typeof body.assetClassId === "string") return true;
   if (typeof body.assetValueId === "string") return true;
@@ -88616,7 +88781,7 @@ function worldPlacementBindingChanged(before, after) {
   );
 }
 function worldPlacementBindingSlice(value) {
-  if (!isPlainRecord3(value) || !isPlainRecord3(value.value)) return null;
+  if (!isPlainRecord4(value) || !isPlainRecord4(value.value)) return null;
   return {
     classId: value.classId ?? null,
     containerId: value.containerId ?? null,
@@ -88635,13 +88800,13 @@ function ownedSparseValueBindingChanged(before, after) {
   );
 }
 function ownedSparseValueBindingSlice(value) {
-  if (!isPlainRecord3(value)) return null;
+  if (!isPlainRecord4(value)) return null;
   return {
     classId: value.classId ?? null,
     containerId: value.containerId ?? null
   };
 }
-function isPlainRecord3(value) {
+function isPlainRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function stagedChangesRequireWorldLayerBindingValidation(current, changes) {
@@ -88657,14 +88822,14 @@ function stagedChangesRequireWorldLayerBindingValidation(current, changes) {
       continue;
     }
     if (change.recordKind !== "class") continue;
-    if (change.operation === "create" && change.deleted !== true && !classesById.has(change.recordId) && isPlainRecord3(change.nextData) && change.nextData.extendsClassId == null && change.nextData.system == null)
+    if (change.operation === "create" && change.deleted !== true && !classesById.has(change.recordId) && isPlainRecord4(change.nextData) && change.nextData.extendsClassId == null && change.nextData.system == null)
       continue;
     if (change.operation !== "update") return true;
     if (change.deleted === true) return true;
     const before = classesById.get(change.recordId);
     if (before === void 0) return true;
     const after = change.nextData;
-    if (!isPlainRecord3(after)) return true;
+    if (!isPlainRecord4(after)) return true;
     if (before.extendsClassId !== after.extendsClassId) return true;
     if (isAbstractClass(before) !== isAbstractClass(after)) return true;
     if (!worldClassSystemBlockIsEqual(before.system, after.system)) return true;
@@ -88686,12 +88851,12 @@ function stagedChangesRequireWorldLayerBindingValidation(current, changes) {
       before,
       change.deleted === true || change.operation === "delete" ? null : change.nextData
     ) ? [before, change.nextData] : []) {
-      if (!isPlainRecord3(row) || typeof row.containerId !== "string") continue;
+      if (!isPlainRecord4(row) || typeof row.containerId !== "string") continue;
       for (const owner of [
         valuesById.get(row.containerId),
         changedValuesById.get(row.containerId)
       ]) {
-        if (isPlainRecord3(owner) && isPlainRecord3(owner.value) && owner.value.assetValueId === change.recordId)
+        if (isPlainRecord4(owner) && isPlainRecord4(owner.value) && owner.value.assetValueId === change.recordId)
           return true;
       }
     }
@@ -88714,9 +88879,9 @@ function worldClassSystemBlockIsEqual(before, after) {
   );
 }
 function hasWorldLayerOverrideMetadata(record6) {
-  if (!isPlainRecord3(record6)) return false;
+  if (!isPlainRecord4(record6)) return false;
   const value = record6.value;
-  if (!isPlainRecord3(value)) return false;
+  if (!isPlainRecord4(value)) return false;
   return typeof value.layerOverrideValueId === "string";
 }
 var init_project_world_placement_bindings = __esm({
@@ -92493,7 +92658,8 @@ function planCommitPreparationLoadedClosureScope(args) {
     if (rules.has("ancestor-paths") && record6.parentRecordKind !== null && record6.parentRecordKind !== void 0 && record6.parentRecordId !== null && record6.parentRecordId !== void 0) {
       rememberExact(record6.parentRecordKind, record6.parentRecordId);
     }
-    const canOwnStoredDescendants = record6.recordKind !== "value" || !isLiteralValueContent(record6.data) || !["string", "number", "boolean"].includes(typeof record6.data.value) || typeof record6.data.classId === "string" || isVirtualInstanceRootShape(record6.data);
+    const memberWithoutStoredChildren = record6.recordKind === "member" && isMemberBase(record6.data) && getOptionalString(record6.data, "valueId") === void 0 && record6.data.defaultValue === void 0;
+    const canOwnStoredDescendants = !memberWithoutStoredChildren && (record6.recordKind !== "value" || !isLiteralValueContent(record6.data) || !["string", "number", "boolean"].includes(typeof record6.data.value) || typeof record6.data.classId === "string" || isVirtualInstanceRootShape(record6.data));
     if (rules.has("descendants") && record6.includeDescendants !== false && canOwnStoredDescendants && (record6.recordKind === "member" || record6.recordKind === "value" || record6.recordKind === "class" || record6.recordKind === "variant")) {
       rememberRange({
         rangeKind: "children",
@@ -106578,7 +106744,7 @@ function systemProtectedWriteInheritedRecordId(write) {
     return null;
   if (write.deleted) return null;
   if (!isSystemBearingRecordKind(write.recordKind)) return null;
-  if (!isPlainRecord4(write.nextData)) return null;
+  if (!isPlainRecord5(write.nextData)) return null;
   if (readSystemMetadata(write.nextData) === null) return null;
   const extendsMemberId = write.nextData.extendsMemberId;
   if (typeof extendsMemberId !== "string") return null;
@@ -106598,7 +106764,7 @@ function assertSystemProtectedRecordWriteValid(write) {
   assertSystemMetadataUnchanged(write, base);
 }
 function readBaseRecord(write) {
-  if (!isPlainRecord4(write.baseData)) return null;
+  if (!isPlainRecord5(write.baseData)) return null;
   return {
     recordKind: write.recordKind,
     data: write.baseData,
@@ -106611,7 +106777,7 @@ function collectSystemBearingBaseRecords(document) {
     const stored = document[collection];
     if (!Array.isArray(stored)) continue;
     for (const record6 of stored) {
-      if (!isPlainRecord4(record6)) continue;
+      if (!isPlainRecord5(record6)) continue;
       const id2 = record6.id;
       if (typeof id2 !== "string") continue;
       records2.set(baseKey(recordKind, id2), {
@@ -106625,7 +106791,7 @@ function collectSystemBearingBaseRecords(document) {
 }
 function assertCreateDeclaresNoSystemMetadata(write) {
   if (!isSystemBearingRecordKind(write.recordKind)) return;
-  if (!isPlainRecord4(write.nextData)) return;
+  if (!isPlainRecord5(write.nextData)) return;
   const system = readSystemMetadata(write.nextData);
   if (system === null) return;
   if (inheritsLegacyEmittedSystemMetadata(write, system)) return;
@@ -106651,11 +106817,11 @@ function assertProtectedRecordNotEdited(change, base) {
   )) {
     return;
   }
-  if (!isPlainRecord4(change.nextData)) return;
+  if (!isPlainRecord5(change.nextData)) return;
   if (authoredFieldsEqual(change.recordKind, base.data, change.nextData)) {
     return;
   }
-  if (isInheritedWorldDefaultEdit(change) && isPlainRecord4(change.inheritedBaseData) && change.inheritedBaseData.id === base.data.extendsMemberId && systemMetadataEqual(
+  if (isInheritedWorldDefaultEdit(change) && isPlainRecord5(change.inheritedBaseData) && change.inheritedBaseData.id === base.data.extendsMemberId && systemMetadataEqual(
     base.system,
     readSystemMetadata(change.inheritedBaseData)
   ))
@@ -106667,7 +106833,7 @@ function assertProtectedRecordNotEdited(change, base) {
 function isInheritedWorldDefaultEdit(write) {
   if (write.recordKind !== "member" || write.recordId.startsWith("system_"))
     return false;
-  if (write.deleted || !isPlainRecord4(write.baseData) || !isPlainRecord4(write.nextData))
+  if (write.deleted || !isPlainRecord5(write.baseData) || !isPlainRecord5(write.nextData))
     return false;
   if (readSystemMetadata(write.baseData)?.kind !== SystemProtectionKind.WorldAuthoring)
     return false;
@@ -106683,7 +106849,7 @@ function isInheritedWorldDefaultEdit(write) {
   );
 }
 function assertSystemMetadataUnchanged(change, base) {
-  if (!isPlainRecord4(change.nextData)) return;
+  if (!isPlainRecord5(change.nextData)) return;
   const next = readSystemMetadata(change.nextData);
   if (systemMetadataEqual(base.system, next)) return;
   throw new Error(
@@ -106734,10 +106900,10 @@ function repointedChildValueIds(document, change) {
   );
   if (baseValue === void 0) return [];
   const before = baseValue.value;
-  if (!isPlainRecord4(before)) return [];
-  if (!isPlainRecord4(change.nextData)) return [];
+  if (!isPlainRecord5(before)) return [];
+  if (!isPlainRecord5(change.nextData)) return [];
   const after = change.nextData.value;
-  if (!isPlainRecord4(after)) return [];
+  if (!isPlainRecord5(after)) return [];
   return Object.entries(before).flatMap(([schemaKey, childValueId2]) => {
     if (typeof childValueId2 !== "string") return [];
     if (after[schemaKey] === childValueId2) return [];
@@ -106772,7 +106938,7 @@ function isSystemBearingRecordKind(recordKind) {
   );
 }
 function readSystemMetadata(record6) {
-  if (!isPlainRecord4(record6)) return null;
+  if (!isPlainRecord5(record6)) return null;
   const system = record6.system;
   if (!isSystemMetadata(system)) return null;
   return system;
@@ -106791,11 +106957,11 @@ function systemReason(system) {
   return SYSTEM_PROTECTION_RULES[system.kind].serverReason;
 }
 function describeChangedRecord(recordKind, recordId, record6) {
-  const name = isPlainRecord4(record6) ? record6.name : void 0;
+  const name = isPlainRecord5(record6) ? record6.name : void 0;
   if (typeof name !== "string") return `Record ${recordKind} "${recordId}"`;
   return `Record ${recordKind} "${name}" (${recordId})`;
 }
-function isPlainRecord4(value) {
+function isPlainRecord5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function baseKey(recordKind, recordId) {
@@ -106926,7 +107092,7 @@ function readWorldReferenceList(args) {
     args.keyCandidates
   );
   if (schemaKey === null) return [];
-  if (!isPlainRecord5(args.ownerValue.value)) return [];
+  if (!isPlainRecord6(args.ownerValue.value)) return [];
   const listValueId = args.ownerValue.value[schemaKey];
   if (typeof listValueId !== "string") return [];
   const listValue2 = args.graph.valuesById.get(listValueId);
@@ -106992,18 +107158,18 @@ function worldReferenceClassInherits(graph, classId, ancestorClassId) {
   return false;
 }
 function toWorldReferenceClassRecord(value) {
-  if (!isPlainRecord5(value)) return null;
+  if (!isPlainRecord6(value)) return null;
   const id2 = stringField2(value, "id");
   if (id2 === null) return null;
   return {
     id: id2,
     extendsClassId: nullableStringField(value, "extendsClassId"),
     schema: isStringRecord8(value.schema) ? value.schema : void 0,
-    system: isPlainRecord5(value.system) ? value.system : null
+    system: isPlainRecord6(value.system) ? value.system : null
   };
 }
 function toWorldReferenceValueRecord(value) {
-  if (!isPlainRecord5(value)) return null;
+  if (!isPlainRecord6(value)) return null;
   const id2 = stringField2(value, "id");
   if (id2 === null) return null;
   return {
@@ -107017,10 +107183,10 @@ function worldReferenceValueClassId(value) {
   return typeof value.classId === "string" && value.classId.length > 0 ? value.classId : null;
 }
 function isStringRecord8(value) {
-  if (!isPlainRecord5(value)) return false;
+  if (!isPlainRecord6(value)) return false;
   return Object.values(value).every((entry) => typeof entry === "string");
 }
-function isPlainRecord5(value) {
+function isPlainRecord6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function stringField2(value, key) {
@@ -107602,7 +107768,7 @@ function stagedAffectedWorldLayerLinkClassIds(args) {
       change.nextData
     ];
     for (const candidate of candidates) {
-      if (!isPlainRecord2(candidate)) continue;
+      if (!isPlainRecord3(candidate)) continue;
       const relationKind = candidate.relationKind;
       if (typeof relationKind !== "string") continue;
       if (!isStagedWorldLayerLinkTargetRelationKind(relationKind)) continue;
@@ -107787,7 +107953,7 @@ function candidateActionListenerRowIds(projected, actions) {
   for (const row of projected.values) {
     if (storedRowActionListeners(row).length > 0) candidates.add(row.id);
     if (actionSchemaKeys.size === 0) continue;
-    if (!isPlainRecord2(row.value)) continue;
+    if (!isPlainRecord3(row.value)) continue;
     for (const schemaKey of actionSchemaKeys) {
       const childId = row.value[schemaKey];
       if (typeof childId === "string") candidates.add(childId);
@@ -107797,7 +107963,7 @@ function candidateActionListenerRowIds(projected, actions) {
 }
 function storedRowActionListeners(row) {
   const body = row.value;
-  if (!isPlainRecord2(body)) return [];
+  if (!isPlainRecord3(body)) return [];
   const listeners = body.listeners;
   return Array.isArray(listeners) ? listeners : [];
 }
@@ -107875,7 +108041,7 @@ function authoredActionListeners(action) {
   if (defaultValue === void 0 || defaultValue === null) return [];
   if (!isLiteralValueContent(defaultValue)) return [];
   const body = defaultValue.value;
-  if (!isPlainRecord2(body)) return [];
+  if (!isPlainRecord3(body)) return [];
   const listeners = body.listeners;
   return Array.isArray(listeners) ? listeners : [];
 }
@@ -108237,7 +108403,7 @@ function candidateVariantRowIds(projected, variantMembers) {
       candidates.add(row.id);
     }
     if (schemaKeys.size === 0) continue;
-    if (!isPlainRecord2(row.value)) continue;
+    if (!isPlainRecord3(row.value)) continue;
     for (const [schemaKey, childId] of Object.entries(row.value)) {
       if (schemaKeys.has(schemaKey) && typeof childId === "string")
         candidates.add(childId);
@@ -130576,27 +130742,6 @@ var init_convex = __esm({
   }
 });
 
-// ../convex/convexValues.ts
-function decodeConvexOpaqueJson(value, context) {
-  if (typeof value !== "string") {
-    throw new Error(`${context} must be an encoded JSON string.`);
-  }
-  try {
-    return JSON.parse(value);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw new Error(`${context} could not be parsed as JSON: ${message}`);
-  }
-}
-var CONVEX_DOCUMENT_WARNING_BYTES, CONVEX_DOCUMENT_MAX_BYTES;
-var init_convexValues = __esm({
-  "../convex/convexValues.ts"() {
-    "use strict";
-    CONVEX_DOCUMENT_WARNING_BYTES = 750 * 1024;
-    CONVEX_DOCUMENT_MAX_BYTES = 1024 * 1024;
-  }
-});
-
 // ../src/database/project-version-transaction-result.ts
 function decodeProjectVersionTransactionResultPage(page) {
   const assignments = {};
@@ -131065,6 +131210,35 @@ var init_push_hook = __esm({
   }
 });
 
+// src/concurrency.ts
+async function mapWithConcurrency(values, concurrency, run) {
+  let nextIndex = 0;
+  let failure;
+  const results = new Array(values.length);
+  const worker = async () => {
+    while (failure === void 0) {
+      const index = nextIndex;
+      nextIndex += 1;
+      if (index >= values.length) return;
+      try {
+        results[index] = await run(values[index], index);
+      } catch (error) {
+        failure ??= { error };
+      }
+    }
+  };
+  await Promise.all(
+    Array.from({ length: Math.min(concurrency, values.length) }, worker)
+  );
+  if (failure !== void 0) throw failure.error;
+  return results;
+}
+var init_concurrency = __esm({
+  "src/concurrency.ts"() {
+    "use strict";
+  }
+});
+
 // src/project-source/project-file-push.ts
 import { basename as basename2, join as join9 } from "node:path";
 import { readFileSync as readFileSync11 } from "node:fs";
@@ -131493,28 +131667,6 @@ async function waitForRetry(attempt, signal) {
     signal.addEventListener("abort", abort, { once: true });
   });
 }
-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 {
-        results[index] = await run(values[index]);
-      } catch (error) {
-        firstError ??= error;
-      }
-    }
-  };
-  await Promise.all(
-    Array.from({ length: Math.min(concurrency, values.length) }, worker)
-  );
-  if (firstError !== void 0) throw firstError;
-  return results;
-}
 function combineSignals(...signals) {
   const defined = signals.filter(
     (signal) => signal !== void 0
@@ -131545,6 +131697,7 @@ var UPLOAD_CONCURRENCY, PRESIGN_BATCH_SIZE, MULTIPART_PART_CONCURRENCY, PRESIGN_
 var init_project_file_push = __esm({
   "src/project-source/project-file-push.ts"() {
     "use strict";
+    init_concurrency();
     init_project_files();
     init_projection();
     init_src();
@@ -136245,11 +136398,19 @@ var init_reset = __esm({
 });
 
 // src/project-source/project-file-pull.ts
-import { existsSync as existsSync11, rmSync as rmSync7 } from "node:fs";
+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);
-  let client = args.client ?? null;
+  const plans = /* @__PURE__ */ new Map();
+  const downloads = [];
   const localById = new Map(
     (args.localBinaries ?? []).map((binary) => [binary.fileId, binary])
   );
@@ -136263,7 +136424,14 @@ async function pullProjectBinariesV4(args) {
       throw new Error(`project-file:${record6.recordId} must be an object.`);
     }
     if (record6.data.status !== "uploaded") continue;
-    client ??= NeoApiClient.forBaseUrl(args.workspace.config.apiBaseUrl);
+    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);
@@ -136276,7 +136444,6 @@ async function pullProjectBinariesV4(args) {
       record6.data,
       `project-file:${record6.recordId} metadata`
     );
-    let remoteBytes = null;
     let action = planBinaryMergeV4({
       baseDigest,
       localDigest,
@@ -136287,98 +136454,142 @@ async function pullProjectBinariesV4(args) {
     if (args.destructive === true) {
       action = localDigest === remoteDigest ? "unchanged" : "download";
     }
-    if (action === "download" || action === "conflict") {
-      if (remoteBytes === null) {
-        const response = await download(
-          record6.data,
-          record6.recordId,
-          client,
-          args.workspace
-        );
-        remoteBytes = response.bytes;
-        if (response.sha256 !== remoteDigest) {
+    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 ${record6.recordId} content changed while pull was in progress (${remoteDigest} -> ${response.sha256}). Pull again against a stable version head.`
+            `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 === "download") {
-      if (remoteBytes === null) {
-        throw new Error(
-          `Project file ${record6.recordId} download plan has no verified remote bytes.`
-        );
+      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;
       }
-      writeVerifiedBinaryDownloadV4(absolute, remoteBytes, remoteDigest);
-      downloaded += 1;
-      states.set(key, binaryState(path, remoteDigest, record6.data));
-      continue;
-    }
-    if (action === "conflict") {
-      if (remoteBytes === null) {
-        throw new Error(
-          `Project file ${record6.recordId} conflict plan has no verified remote bytes.`
-        );
+      if (action === "converged" || action === "unchanged") {
+        states.set(key, binaryState(path, remoteDigest, data));
+        removePreviousConflict(args.workspace.root, previous?.projectBinary);
+        continue;
       }
-      const artifactPath = writeBinaryConflictArtifactV4(
-        args.workspace.root,
-        record6.recordId,
-        fileName(record6.data),
-        remoteBytes,
-        remoteDigest
-      );
-      const state = binaryState(path, baseDigest, record6.data);
-      states.set(key, {
-        ...state,
-        conflict: {
-          action: "conflict",
-          remoteSha256: remoteDigest,
-          artifactPath
-        }
+      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
       });
-      conflicts.push(path);
-      conflicted += 1;
-      continue;
-    }
-    if (action === "converged" || action === "unchanged") {
-      states.set(key, binaryState(path, remoteDigest, record6.data));
-      removePreviousConflict(args.workspace.root, previous?.projectBinary);
-      continue;
-    }
-    states.set(key, binaryState(path, baseDigest, record6.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;
+      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);
     }
-    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 });
   }
-  return { states, downloaded, conflicted, conflicts };
 }
 async function download(data, fileId, client, workspace) {
   const version = typeof data.storageETag === "string" ? `?v=${encodeURIComponent(data.storageETag)}` : "";
@@ -136447,13 +136658,16 @@ 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;
   }
 });
 
@@ -136578,10 +136792,10 @@ __export(pull_exports, {
 });
 import {
   mkdirSync as mkdirSync10,
-  writeFileSync as writeFileSync10,
+  writeFileSync as writeFileSync11,
   rmSync as rmSync8,
   existsSync as existsSync12,
-  readFileSync as readFileSync15
+  readFileSync as readFileSync16
 } from "node:fs";
 import { dirname as dirname9 } from "node:path";
 async function runPull(workspace, options, progress = spinner("Checking local workspace\u2026")) {
@@ -137048,7 +137262,7 @@ async function finishFormat4Pull(args) {
   let written = 0;
   for (const path of emittedPaths) {
     const absolute = resolveSourcePath(path);
-    const existing = existsSync12(absolute) ? readFileSync15(absolute, "utf8") : null;
+    const existing = existsSync12(absolute) ? readFileSync16(absolute, "utf8") : null;
     const unprojectedConflictKeys = authoredLocalConflictKeysByPath.get(path) ?? [];
     if (unprojectedConflictKeys.length > 0 && existing === null) {
       throw new Error(
@@ -137070,7 +137284,7 @@ async function finishFormat4Pull(args) {
     mkdirSync10(dirname9(absolute), { recursive: true });
     if (existing !== null && !marked && !rewritePaths.has(path)) continue;
     if (existing !== content) {
-      writeFileSync10(absolute, content, "utf8");
+      writeFileSync11(absolute, content, "utf8");
       written += 1;
     }
   }
@@ -137504,7 +137718,7 @@ var init_exports = {};
 __export(init_exports, {
   runInit: () => runInit
 });
-import { existsSync as existsSync13, mkdirSync as mkdirSync11, readFileSync as readFileSync16, writeFileSync as writeFileSync11 } from "node:fs";
+import { existsSync as existsSync13, mkdirSync as mkdirSync11, readFileSync as readFileSync17, writeFileSync as writeFileSync12 } from "node:fs";
 import { join as join14, resolve as resolve3 } from "node:path";
 async function runInit(options) {
   let projectId = options.projectId;
@@ -137629,13 +137843,13 @@ async function runInit(options) {
 }
 function ensurePrivateStateIgnored(root) {
   const path = join14(root, ".gitignore");
-  const existing = existsSync13(path) ? readFileSync16(path, "utf8") : "";
+  const existing = existsSync13(path) ? readFileSync17(path, "utf8") : "";
   if (existing.split(/\r?\n/u).some((line) => line.trim() === ".neo/" || line.trim() === ".neo")) {
     return;
   }
   const prefix = existing.length === 0 || existing.endsWith("\n") ? existing : `${existing}
 `;
-  writeFileSync11(path, `${prefix}.neo/
+  writeFileSync12(path, `${prefix}.neo/
 `, "utf8");
 }
 var init_init = __esm({
@@ -139039,7 +139253,7 @@ __export(script_exports, {
   readDocumentArrays: () => readDocumentArrays,
   runScript: () => runScript
 });
-import { readFileSync as readFileSync17 } from "node:fs";
+import { readFileSync as readFileSync18 } from "node:fs";
 function readDocumentArrays(raw) {
   const arrayOf2 = (field) => {
     const value = raw[field];
@@ -139559,9 +139773,9 @@ function buildRootValue(document, lookups) {
 }
 function readSource(options, fallback) {
   if (options.source !== null) return options.source;
-  if (options.file !== null) return readFileSync17(options.file, "utf8");
+  if (options.file !== null) return readFileSync18(options.file, "utf8");
   if (fallback !== void 0) return fallback;
-  const stdin = readFileSync17(0, "utf8");
+  const stdin = readFileSync18(0, "utf8");
   if (stdin.trim().length === 0) {
     throw new Error(
       "Provide NeoScript source as an argument, --file, or stdin."
@@ -140610,7 +140824,7 @@ var init_registry2 = __esm({
   "schema-contract/registry.mjs"() {
     "use strict";
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
-      cliVersion: "0.58.1",
+      cliVersion: "0.58.3",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -142038,12 +142252,12 @@ import {
   existsSync as existsSync14,
   mkdirSync as mkdirSync12,
   readdirSync as readdirSync4,
-  readFileSync as readFileSync18,
+  readFileSync as readFileSync19,
   realpathSync as realpathSync2,
   renameSync as renameSync7,
   rmSync as rmSync9,
   statSync as statSync2,
-  writeFileSync as writeFileSync12
+  writeFileSync as writeFileSync13
 } from "node:fs";
 import {
   basename as basename3,
@@ -142257,7 +142471,7 @@ function preparedHookCandidate(workspace) {
       );
     }
     const parsed = JSON.parse(
-      readFileSync18(join15(directory, "candidate.json"), "utf8")
+      readFileSync19(join15(directory, "candidate.json"), "utf8")
     );
     if (!isRecord10(parsed)) {
       throw new NeoTestPreparedCandidateError(
@@ -142327,7 +142541,7 @@ function testCandidateCachePath(workspace, inputFingerprint) {
 function cachedTestCandidate(workspace, inputFingerprint) {
   try {
     const candidatePath = testCandidateCachePath(workspace, inputFingerprint);
-    const parsed = JSON.parse(readFileSync18(candidatePath, "utf8"));
+    const parsed = JSON.parse(readFileSync19(candidatePath, "utf8"));
     if (!isRecord10(parsed)) return null;
     if (parsed.version !== 1) return null;
     if (parsed.candidateRevision !== TEST_CANDIDATE_CACHE_REVISION) return null;
@@ -142338,7 +142552,7 @@ function cachedTestCandidate(workspace, inputFingerprint) {
       return null;
     }
     if (typeof parsed.documentSha256 !== "string") return null;
-    const documentJson = readFileSync18(
+    const documentJson = readFileSync19(
       join15(dirname10(candidatePath), "document.json"),
       "utf8"
     );
@@ -142378,7 +142592,7 @@ function cacheTestCandidate(workspace, inputFingerprint, candidate) {
 function compileSpec(workspace, document, absolutePath, projectCompilationHash2) {
   const scriptDocument = readDocumentArrays(document);
   const path = relative8(workspace.root, absolutePath).split(sep8).join("/");
-  const source = readFileSync18(absolutePath, "utf8");
+  const source = readFileSync19(absolutePath, "utf8");
   const sourceHash = createHash11("sha256").update(source).digest("hex");
   const artifactPath = join15(
     workspace.root,
@@ -142389,7 +142603,7 @@ function compileSpec(workspace, document, absolutePath, projectCompilationHash2)
     `${sourceHash}.json`
   );
   try {
-    const cached = JSON.parse(readFileSync18(artifactPath, "utf8"));
+    const cached = JSON.parse(readFileSync19(artifactPath, "utf8"));
     if (isRecord10(cached) && cached.version === 1 && cached.compilerRevision === NEOSCRIPT_COMPILER_REVISION && cached.projectCompilationHash === projectCompilationHash2 && cached.sourceHash === sourceHash && isRecord10(cached.action) && typeof cached.artifactSha256 === "string" && createHash11("sha256").update(JSON.stringify(cached.action)).digest("hex") === cached.artifactSha256 && cached.action.compilerRevision === NEOSCRIPT_COMPILER_REVISION && Array.isArray(cached.action.parameters) && Array.isArray(cached.action.instructions) && isRecord10(cached.action.typeInfo)) {
       return {
         path,
@@ -143206,7 +143420,7 @@ async function executeRegisteredSpec(registered, document, selected, timeoutMs,
 function atomicWrite(path, content) {
   mkdirSync12(dirname10(path), { recursive: true });
   const temporary = `${path}.tmp-${String(process.pid)}-${randomUUID6()}`;
-  writeFileSync12(temporary, content, "utf8");
+  writeFileSync13(temporary, content, "utf8");
   renameSync7(temporary, path);
 }
 function testBuildFiles(root) {
@@ -143752,7 +143966,7 @@ import {
   constants as fsConstants,
   accessSync,
   existsSync as existsSync15,
-  readFileSync as readFileSync19
+  readFileSync as readFileSync20
 } from "node:fs";
 import { extname as extname2, isAbsolute as isAbsolute4, join as join16, relative as relative9, sep as sep9 } from "node:path";
 function inspectNeoDoctor(workspace) {
@@ -143837,7 +144051,7 @@ function inspectSourceContract(workspace) {
   );
   try {
     const inputs = files.map((file, index) => {
-      const text = readFileSync19(file, "utf8");
+      const text = readFileSync20(file, "utf8");
       return {
         uri: relativeFiles[index],
         kind: requiredProjectSourceKindV4(relativeFiles[index], text),
@@ -143885,7 +144099,7 @@ function inspectExtensionContract(root) {
     };
   }
   try {
-    const value = JSON.parse(readFileSync19(cachePath, "utf8"));
+    const value = JSON.parse(readFileSync20(cachePath, "utf8"));
     assertProjectSourceAnalysisV4(value);
     return {
       id: NEO_VSCODE_EXTENSION_ID,
@@ -144231,7 +144445,7 @@ __export(migrate_exports, {
   runMigrate: () => runMigrate
 });
 import { randomUUID as randomUUID7 } from "node:crypto";
-import { existsSync as existsSync16, mkdirSync as mkdirSync13, readFileSync as readFileSync20, writeFileSync as writeFileSync13 } from "node:fs";
+import { existsSync as existsSync16, mkdirSync as mkdirSync13, readFileSync as readFileSync21, writeFileSync as writeFileSync14 } from "node:fs";
 import { join as join17, relative as relative10 } from "node:path";
 async function runMigrate(workspace, subcommand, positional, targetRef, json, dependencies = {}) {
   if (subcommand === "new") {
@@ -144245,7 +144459,7 @@ async function runMigrate(workspace, subcommand, positional, targetRef, json, de
     mkdirSync13(migrationsDir, { recursive: true });
     let nextOrder = 1;
     for (const path of listProjectSourceFilesV4(workspace.root)) {
-      const source = readFileSync20(path, "utf8");
+      const source = readFileSync21(path, "utf8");
       if (neoProjectSourceKind(path, source) !== "migration") continue;
       const migration = parseMigrationFile(
         source,
@@ -144268,7 +144482,7 @@ async function runMigrate(workspace, subcommand, positional, targetRef, json, de
       target === "project" ? "// Runs once with root context. Write the NeoScript action below." : `// Runs once per ${target} value; \`this\` is the instance.`,
       ""
     ].join("\n");
-    writeFileSync13(absolute, template, "utf8");
+    writeFileSync14(absolute, template, "utf8");
     console.log(`Created ${relPath} \u2014 edit the action body, then "neo push".`);
     console.log("(The id is assigned at push, same as schema creates.)");
     return;
@@ -146431,7 +146645,7 @@ __export(content_exports, {
   makeContentContext: () => makeContentContext,
   runLoc: () => runLoc
 });
-import { readFileSync as readFileSync21 } from "node:fs";
+import { readFileSync as readFileSync22 } from "node:fs";
 import { randomUUID as randomUUID8 } from "node:crypto";
 function versionPath2(workspace, suffix) {
   return `/api/projects/${workspace.config.projectId}/versions/${workspace.config.versionId}/${suffix}`;
@@ -146439,9 +146653,9 @@ function versionPath2(workspace, suffix) {
 function readBatch(file) {
   let raw = null;
   if (file !== null) {
-    raw = readFileSync21(file, "utf8");
+    raw = readFileSync22(file, "utf8");
   } else if (!process.stdin.isTTY) {
-    raw = readFileSync21(0, "utf8");
+    raw = readFileSync22(0, "utf8");
     if (raw.trim().length === 0) raw = null;
   }
   if (raw === null) return null;
@@ -147689,9 +147903,9 @@ import { createHash as createHash12 } from "node:crypto";
 import {
   existsSync as existsSync17,
   mkdirSync as mkdirSync14,
-  readFileSync as readFileSync22,
+  readFileSync as readFileSync23,
   unlinkSync,
-  writeFileSync as writeFileSync14
+  writeFileSync as writeFileSync15
 } from "node:fs";
 import { dirname as dirname11, join as join18 } from "node:path";
 function validatePath(path) {
@@ -147702,7 +147916,7 @@ function validatePath(path) {
 }
 function readManifest(path) {
   if (!existsSync17(path)) return null;
-  const data = JSON.parse(readFileSync22(path, "utf8"));
+  const data = JSON.parse(readFileSync23(path, "utf8"));
   if (data === null || typeof data !== "object" || !("schemaVersion" in data) || data.schemaVersion !== 1)
     throw new Error(`Invalid generated-file manifest version: ${path}`);
   if (!("files" in data) || !Array.isArray(data.files) || data.files.length === 0)
@@ -147782,7 +147996,7 @@ function writeUnityGeneratedFiles(directory, projectId, files) {
       const meta = join18(directory, old.path + ".meta");
       operations.push([
         path + ".meta",
-        existsSync17(meta) ? readFileSync22(meta, "utf8") : null
+        existsSync17(meta) ? readFileSync23(meta, "utf8") : null
       ]);
     }
     operations.push([path, file.content]);
@@ -147809,7 +148023,7 @@ function writeUnityGeneratedFiles(directory, projectId, files) {
     if (!previous.has(key))
       previous.set(key, {
         path,
-        content: existsSync17(path) ? readFileSync22(path, "utf8") : null
+        content: existsSync17(path) ? readFileSync23(path, "utf8") : null
       });
   }
   const write = (path, content) => {
@@ -147817,13 +148031,13 @@ function writeUnityGeneratedFiles(directory, projectId, files) {
       if (existsSync17(path)) unlinkSync(path);
     } else {
       mkdirSync14(dirname11(path), { recursive: true });
-      writeFileSync14(path, content);
+      writeFileSync15(path, content);
     }
   };
   const changed = [];
   try {
     for (const [path, content] of operations) {
-      const current = existsSync17(path) ? readFileSync22(path, "utf8") : null;
+      const current = existsSync17(path) ? readFileSync23(path, "utf8") : null;
       if (current === content) continue;
       changed.push(path);
       write(path, content);
@@ -147836,7 +148050,7 @@ function writeUnityGeneratedFiles(directory, projectId, files) {
       restored.add(key);
       const original = previous.get(key);
       if (original.path !== path && existsSync17(path)) unlinkSync(path);
-      const current = existsSync17(original.path) ? readFileSync22(original.path, "utf8") : null;
+      const current = existsSync17(original.path) ? readFileSync23(original.path, "utf8") : null;
       if (current !== original.content) write(original.path, original.content);
     }
     throw error;
@@ -147853,7 +148067,7 @@ var export_exports = {};
 __export(export_exports, {
   runExportUnity: () => runExportUnity
 });
-import { mkdirSync as mkdirSync15, writeFileSync as writeFileSync15 } from "node:fs";
+import { mkdirSync as mkdirSync15, writeFileSync as writeFileSync16 } from "node:fs";
 import { join as join19 } from "node:path";
 async function runExportUnity(workspace, outDir) {
   if (outDir === null) {
@@ -147876,9 +148090,9 @@ async function runExportUnity(workspace, outDir) {
     response.projectId,
     response.generatedFiles
   );
-  writeFileSync15(join19(resourcesDir, "project.json"), response.projectJson);
+  writeFileSync16(join19(resourcesDir, "project.json"), response.projectJson);
   for (const file of response.localizationFiles ?? []) {
-    writeFileSync15(join19(localizationDir, file.fileName), file.content);
+    writeFileSync16(join19(localizationDir, file.fileName), file.content);
   }
   console.log(`wrote ${join19(resourcesDir, "project.json")}`);
   console.log(`synchronized generated files in ${scriptsDir}`);
@@ -148077,7 +148291,7 @@ __export(resolve_exports, {
   resolveMarkers: () => resolveMarkers,
   runResolve: () => runResolve
 });
-import { readFileSync as readFileSync23, rmSync as rmSync10, writeFileSync as writeFileSync16 } from "node:fs";
+import { readFileSync as readFileSync24, rmSync as rmSync10, writeFileSync as writeFileSync17 } from "node:fs";
 import { join as join21, relative as relative11 } from "node:path";
 function runResolve(workspace, side) {
   const marked = readMarkedProjectSourcesV4(workspace.root);
@@ -148088,7 +148302,7 @@ function runResolve(workspace, side) {
   const resolvedRecords = adoptServerConflictBases(workspace);
   let resolvedFiles = 0;
   for (const file of marked) {
-    writeFileSync16(file.absolutePath, resolveMarkers(file.source, side), "utf8");
+    writeFileSync17(file.absolutePath, resolveMarkers(file.source, side), "utf8");
     resolvedFiles += 1;
   }
   let resolvedBinaries = 0;
@@ -148101,7 +148315,7 @@ function runResolve(workspace, side) {
       if (conflict2.remoteSha256 !== null && conflict2.artifactPath !== void 0) {
         writeVerifiedBinaryDownloadV4(
           destination,
-          readFileSync23(join21(workspace.root, conflict2.artifactPath)),
+          readFileSync24(join21(workspace.root, conflict2.artifactPath)),
           conflict2.remoteSha256
         );
         binary.sha256 = conflict2.remoteSha256;
@@ -148130,7 +148344,7 @@ function runResolve(workspace, side) {
 function readMarkedProjectSourcesV4(root) {
   const files = [];
   for (const absolutePath of listProjectSourceFilesV4(root)) {
-    const source = readFileSync23(absolutePath, "utf8");
+    const source = readFileSync24(absolutePath, "utf8");
     if (detectConflictMarkers(source) === null) continue;
     files.push({
       path: normalizeWorkspaceSourcePath(relative11(root, absolutePath)),
@@ -148431,7 +148645,7 @@ There is no --keep-current: preserving current semantic state defines flatten.
 async function main() {
   const args = parseArgs(process.argv.slice(2));
   if (args.command === "--version") {
-    console.log("0.58.1");
+    console.log("0.58.3");
     return;
   }
   if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {