@neocompose/cli 0.11.0 → 0.11.1

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## [0.11.1] - 2026-07-27
+
+### Fixed
+
+- Show push preparation and file-upload progress immediately after confirmation,
+  validate trusted lowering before uploading bytes, and batch presigning with
+  bounded concurrent transfers, request deadlines, retries, and cancellation.
+- Preserve inherited numeric settings when lowering newly authored member
+  overrides, preventing trusted-lowering rejection after file staging.
+- Report the first divergent trusted-lowering field when a source commit is
+  rejected instead of only identifying the affected record.
+
 ## [0.11.0] - 2026-07-27
 
 ### Added

package/dist/neo.mjs

@@ -11837,12 +11837,13 @@ var init_project_source_parser = __esm({
 });
 
 // ../packages/neoscript-language/src/project-schema-contract.generated.ts
-var PROJECT_SCHEMA_MANIFEST_FORMAT_VERSION, PROJECT_SCHEMA_MANIFEST_CONTRACT_VERSION, NEO_PROJECT_SOURCE_RECORD_CONTRACT;
+var PROJECT_SCHEMA_MANIFEST_FORMAT_VERSION, PROJECT_SCHEMA_MANIFEST_CONTRACT_VERSION, PROJECT_FILE_UPLOAD_BATCH_SIZE, NEO_PROJECT_SOURCE_RECORD_CONTRACT;
 var init_project_schema_contract_generated = __esm({
   "../packages/neoscript-language/src/project-schema-contract.generated.ts"() {
     "use strict";
     PROJECT_SCHEMA_MANIFEST_FORMAT_VERSION = 3;
     PROJECT_SCHEMA_MANIFEST_CONTRACT_VERSION = "3.5";
+    PROJECT_FILE_UPLOAD_BATCH_SIZE = 32;
     NEO_PROJECT_SOURCE_RECORD_CONTRACT = {
       "recordFields": {
         "member": [
@@ -19507,8 +19508,8 @@ function memberSymbol(member, schemaKey, environment, field) {
     `${field}.source`
   );
   const overrideOf = nullableString(member.overrideOf, `${field}.overrideOf`);
-  const inheritedMember = overrideOf ? environment.members.get(overrideOf) : void 0;
-  const inheritedOwner = inheritedMember ? optionalRecord(inheritedMember.owner) : void 0;
+  const inheritedMember2 = overrideOf ? environment.members.get(overrideOf) : void 0;
+  const inheritedOwner = inheritedMember2 ? optionalRecord(inheritedMember2.owner) : void 0;
   const inheritedTypeId = inheritedOwner?.kind === "classMember" && typeof inheritedOwner.classId === "string" ? inheritedOwner.classId : void 0;
   const inheritedType = inheritedTypeId ? environment.classes.get(inheritedTypeId) : void 0;
   const common = {
@@ -29260,6 +29261,7 @@ function lowerFieldMember(context, ownerClass, declaration, id2, commonInput, ba
   const fieldType = partial ? requiredTypeArgument(declaration.type, 0) : declaration.type;
   const storedStatic = declaration.modifiers.includes("static") && !declaration.modifiers.includes("readonly");
   const settings = annotation(declaration.annotations, "settings");
+  const inherited = inheritedMember(context, commonInput.overrideOf);
   const storesSelectionArray = context.enumIdsByName.has(fieldType.name) || fieldType.name === "Dialogue" || Boolean(settings && argument(settings, "collection"));
   const common = {
     ...commonInput,
@@ -29291,11 +29293,12 @@ function lowerFieldMember(context, ownerClass, declaration, id2, commonInput, ba
     return { ...common, kind: name };
   }
   if (name === "int") {
+    const inheritedInt = inherited?.kind === "int" ? inherited : void 0;
     return {
       ...common,
       kind: "int",
-      min: numberArgument(settings, "min"),
-      max: numberArgument(settings, "max")
+      min: numberArgument(settings, "min") ?? inheritedInt?.min ?? null,
+      max: numberArgument(settings, "max") ?? inheritedInt?.max ?? null
     };
   }
   if (name === "string") {
@@ -29310,20 +29313,24 @@ function lowerFieldMember(context, ownerClass, declaration, id2, commonInput, ba
     const min = numberTextArgument(settings, "min");
     const max = numberTextArgument(settings, "max");
     if (name === "decimal") {
+      const inheritedDecimal = inherited?.kind === "decimal" ? inherited : void 0;
       return {
         ...common,
         kind: "decimal",
-        min,
-        max,
-        decimalPoints: numberArgument(settings, "decimalPoints")
+        min: min ?? inheritedDecimal?.min ?? null,
+        max: max ?? inheritedDecimal?.max ?? null,
+        decimalPoints: numberArgument(settings, "decimalPoints") ?? inheritedDecimal?.decimalPoints ?? null
       };
     }
+    const inheritedFloat = inherited?.kind === "float" ? inherited : void 0;
+    const numericMin = min === null ? null : Number(min);
+    const numericMax = max === null ? null : Number(max);
     return {
       ...common,
       kind: "float",
-      min: min === null ? null : Number(min),
-      max: max === null ? null : Number(max),
-      decimalPoints: numberArgument(settings, "decimalPoints")
+      min: numericMin ?? inheritedFloat?.min ?? null,
+      max: numericMax ?? inheritedFloat?.max ?? null,
+      decimalPoints: numberArgument(settings, "decimalPoints") ?? inheritedFloat?.decimalPoints ?? null
     };
   }
   const primitive3 = primitiveMemberKind(name);
@@ -29443,6 +29450,10 @@ function lowerFieldMember(context, ownerClass, declaration, id2, commonInput, ba
     `Unsupported field type ${JSON.stringify(name)} on ${ownerClass.name}.${declaration.name}.`
   );
 }
+function inheritedMember(context, memberId) {
+  if (memberId === null) return void 0;
+  return context.loweredMembers.get(memberId) ?? context.baseMembers.get(memberId);
+}
 function lowerListIndexes(ownerClass, declaration) {
   const declared = /* @__PURE__ */ new Set();
   return declaration.annotations.filter((entry) => entry.name === "index").map((entry) => {
@@ -51477,7 +51488,7 @@ var init_http = __esm({
         }
         return new _NeoApiClient(apiBaseUrl, token);
       }
-      async post(path, body, headers) {
+      async post(path, body, headers, options = {}) {
         const url = new URL(path, this.apiBaseUrl).toString();
         const response = await fetch(url, {
           method: "POST",
@@ -51486,7 +51497,8 @@ var init_http = __esm({
             "Content-Type": "application/json",
             ...headers
           },
-          body: body === void 0 ? void 0 : JSON.stringify(body)
+          body: body === void 0 ? void 0 : JSON.stringify(body),
+          signal: options.signal
         });
         const text = await response.text();
         let parsed = null;
@@ -59572,13 +59584,13 @@ function ownedObjectChildMember(row, sourceMember, key, ctx) {
   return memberForCustomSchemaValue(classId, key, ctx);
 }
 function freshCloneValueId() {
-  const randomUUID6 = globalThis.crypto?.randomUUID;
-  if (randomUUID6 === void 0) {
+  const randomUUID7 = globalThis.crypto?.randomUUID;
+  if (randomUUID7 === void 0) {
     throw new NSGetterRuntimeError(
       "Class.Clone cannot mint a value id because crypto.randomUUID is unavailable."
     );
   }
-  return randomUUID6.call(globalThis.crypto);
+  return randomUUID7.call(globalThis.crypto);
 }
 function parseDialogueMemoryPointer(pointer) {
   if (typeof pointer !== "string") return null;
@@ -66504,80 +66516,154 @@ function ensureProjectFileBinaryChangesV4(args) {
     });
   }
 }
+function prepareProjectFilePushesV4(args) {
+  const prepared = [];
+  for (const binary of args.binaryChanges) {
+    if (binary.action !== "create" && binary.action !== "upload") continue;
+    const recordId = args.assignedIds.get(binary.fileId) ?? binary.fileId;
+    const change = args.changes.find(
+      (candidate) => candidate.recordKind === "project-file" && candidate.recordId === recordId
+    );
+    if (change === void 0) {
+      throw new Error(
+        `Project file ${recordId} has upload bytes but no source change.`
+      );
+    }
+    if (!isObjectRecord2(change.nextData)) {
+      throw new Error(
+        `Project file ${recordId} has upload bytes but its source change has no record data.`
+      );
+    }
+    const absolute = join14(args.workspace.root, binary.path);
+    const bytes = new Uint8Array(readFileSync12(absolute));
+    const digest = sha256Bytes(bytes);
+    if (binary.localSha256 !== null && digest !== binary.localSha256) {
+      throw new Error(
+        `Project file ${binary.path} changed after status was computed; run push again.`
+      );
+    }
+    const mimeType = binary.mimeType;
+    if (mimeType === null) {
+      throw new Error(`Project file ${binary.path} has no MIME type.`);
+    }
+    prepared.push({
+      uploadToken: `${recordId}-${prepared.length}`,
+      recordId,
+      replaceFileId: binary.action === "upload" ? recordId : null,
+      name: basename2(binary.path),
+      fileType: binary.kind,
+      mimeType,
+      byteLength: bytes.byteLength,
+      contentSha256: digest,
+      audioDurationSeconds: binary.kind === "audio" && typeof change.nextData.audioDurationSeconds === "number" ? change.nextData.audioDurationSeconds : null,
+      bytes
+    });
+  }
+  return prepared;
+}
 async function stageProjectFilePushesV4(args) {
+  const prepared = args.prepared ?? prepareProjectFilePushesV4({
+    workspace: args.workspace,
+    changes: args.changes,
+    binaryChanges: args.binaryChanges,
+    assignedIds: args.assignedIds
+  });
   const staged = [];
   const cleanupKeys = [];
   const put = args.put ?? fetch;
+  const interruptController = new AbortController();
+  const interrupt = () => interruptController.abort(new ProjectFilePushCancelledError());
+  process.once("SIGINT", interrupt);
+  const signal = combineSignals(args.signal, interruptController.signal);
+  const totalBytes = prepared.reduce((sum, file) => sum + file.byteLength, 0);
+  let completedBytes = 0;
+  let completedFiles = 0;
+  const report = () => args.onProgress?.({
+    completedFiles,
+    totalFiles: prepared.length,
+    completedBytes,
+    totalBytes
+  });
+  report();
   try {
-    for (const binary of args.binaryChanges) {
-      if (binary.action !== "create" && binary.action !== "upload") continue;
-      const recordId = args.assignedIds.get(binary.fileId) ?? binary.fileId;
-      const change = args.changes.find(
-        (candidate) => candidate.recordKind === "project-file" && candidate.recordId === recordId
+    for (let offset = 0; offset < prepared.length; offset += PROJECT_FILE_UPLOAD_BATCH_SIZE) {
+      const batch = prepared.slice(
+        offset,
+        offset + PROJECT_FILE_UPLOAD_BATCH_SIZE
       );
-      if (change === void 0 || !isObjectRecord2(change.nextData)) {
-        throw new Error(
-          `Project file ${recordId} has upload bytes but no source change.`
-        );
-      }
-      const absolute = join14(args.workspace.root, binary.path);
-      const bytes = new Uint8Array(readFileSync12(absolute));
-      const digest = sha256Bytes(bytes);
-      if (binary.localSha256 !== null && digest !== binary.localSha256) {
-        throw new Error(
-          `Project file ${binary.path} changed after status was computed; run push again.`
-        );
-      }
-      const mimeType = binary.mimeType;
-      if (mimeType === null) {
-        throw new Error(`Project file ${binary.path} has no MIME type.`);
-      }
-      const name = basename2(binary.path);
-      const replaceFileId = binary.action === "upload" ? recordId : null;
-      const presign = await args.client.post(
+      const presign = await postWithTimeout(
+        args.client,
         versionPath2(args.workspace, "upload"),
         {
           route: "projectFile",
           metadata: {
-            projectFileId: recordId,
-            replaceFileId,
-            contentSha256: digest,
-            deferredSourceCommit: true
+            deferredSourceCommit: true,
+            uploads: batch.map((file) => ({
+              uploadToken: file.uploadToken,
+              projectFileId: file.recordId,
+              replaceFileId: file.replaceFileId,
+              name: file.name,
+              contentSha256: file.contentSha256
+            }))
           },
-          files: [{ name, size: bytes.byteLength, type: mimeType }]
-        }
+          files: batch.map((file) => ({
+            name: file.uploadToken,
+            size: file.byteLength,
+            type: file.mimeType
+          }))
+        },
+        signal
       );
-      const entry = Array.isArray(presign.files) ? presign.files.find(isObjectRecord2) : void 0;
-      const fileInfo = isObjectRecord2(entry?.file) ? entry.file : {};
-      const objectInfo = isObjectRecord2(fileInfo.objectInfo) ? fileInfo.objectInfo : {};
-      if (typeof entry?.signedUrl !== "string" || typeof objectInfo.key !== "string") {
-        throw new Error("Upload presign response is missing signedUrl/key.");
+      const entries = readPresignEntries(presign, batch);
+      for (const entry of entries) cleanupKeys.push(entry.storageKey);
+      const batchController = new AbortController();
+      try {
+        await mapWithConcurrency(entries, UPLOAD_CONCURRENCY, async (entry) => {
+          try {
+            await putWithRetry(
+              put,
+              entry,
+              combineSignals(signal, batchController.signal)
+            );
+          } catch (error) {
+            batchController.abort(error);
+            throw error;
+          }
+          staged.push({
+            uploadToken: entry.file.uploadToken,
+            file: {
+              recordId: entry.file.recordId,
+              replaceFileId: entry.file.replaceFileId,
+              name: entry.file.name,
+              fileType: entry.file.fileType,
+              mimeType: entry.file.mimeType,
+              byteLength: entry.file.byteLength,
+              storageKey: entry.storageKey,
+              contentSha256: entry.file.contentSha256,
+              audioDurationSeconds: entry.file.audioDurationSeconds
+            }
+          });
+          completedFiles += 1;
+          completedBytes += entry.file.byteLength;
+          report();
+        });
+      } catch (error) {
+        batchController.abort(error);
+        throw error;
       }
-      cleanupKeys.push(objectInfo.key);
-      const headers = uploadHeaders(entry, objectInfo, mimeType);
-      const response = await put(entry.signedUrl, {
-        method: "PUT",
-        headers,
-        body: bytes
-      });
-      if (!response.ok) {
+    }
+    const byUploadToken = new Map(
+      staged.map((entry) => [entry.uploadToken, entry.file])
+    );
+    return prepared.map((file) => {
+      const result = byUploadToken.get(file.uploadToken);
+      if (result === void 0) {
         throw new Error(
-          `Storage PUT failed (${response.status}): ${await response.text()}`
+          `Uploaded project file ${file.name} (${file.uploadToken}) is missing from the staged result.`
         );
       }
-      staged.push({
-        recordId,
-        replaceFileId,
-        name,
-        fileType: binary.kind,
-        mimeType,
-        byteLength: bytes.byteLength,
-        storageKey: objectInfo.key,
-        contentSha256: digest,
-        audioDurationSeconds: binary.kind === "audio" && typeof change.nextData.audioDurationSeconds === "number" ? change.nextData.audioDurationSeconds : null
-      });
-    }
-    return staged;
+      return result;
+    });
   } catch (error) {
     if (cleanupKeys.length > 0) {
       try {
@@ -66588,9 +66674,146 @@ async function stageProjectFilePushesV4(args) {
       } catch {
       }
     }
+    if (interruptController.signal.aborted || args.signal?.aborted === true) {
+      throw new ProjectFilePushCancelledError();
+    }
     throw error;
+  } finally {
+    process.removeListener("SIGINT", interrupt);
   }
 }
+function readPresignEntries(presign, batch) {
+  const entries = Array.isArray(presign.files) ? presign.files.filter(isObjectRecord2) : [];
+  return batch.map((file) => {
+    const entry = entries.find((candidate) => {
+      const info = isObjectRecord2(candidate.file) ? candidate.file : {};
+      return info.name === file.uploadToken;
+    });
+    const fileInfo = isObjectRecord2(entry?.file) ? entry.file : {};
+    const objectInfo = isObjectRecord2(fileInfo.objectInfo) ? fileInfo.objectInfo : {};
+    if (typeof entry?.signedUrl !== "string") {
+      throw new Error(
+        `Upload presign response is missing signedUrl for ${file.name}.`
+      );
+    }
+    if (typeof objectInfo.key !== "string") {
+      throw new Error(
+        `Upload presign response is missing a storage key for ${file.name}.`
+      );
+    }
+    return {
+      file,
+      signedUrl: entry.signedUrl,
+      storageKey: objectInfo.key,
+      headers: uploadHeaders(entry, objectInfo, file.mimeType)
+    };
+  });
+}
+async function postWithTimeout(client, path, body, signal) {
+  for (let attempt = 1; attempt <= PRESIGN_ATTEMPTS; attempt += 1) {
+    try {
+      return await client.post(path, body, void 0, {
+        signal: combineSignals(signal, AbortSignal.timeout(PRESIGN_TIMEOUT_MS))
+      });
+    } catch (error) {
+      if (signal.aborted || !isRetryableRequestError(error) || attempt === PRESIGN_ATTEMPTS) {
+        throw error;
+      }
+      await waitForRetry(attempt, signal);
+    }
+  }
+  throw new Error("Upload presign failed after all retry attempts.");
+}
+async function putWithRetry(put, entry, signal) {
+  let lastError;
+  for (let attempt = 1; attempt <= STORAGE_PUT_ATTEMPTS; attempt += 1) {
+    let response;
+    try {
+      response = await put(entry.signedUrl, {
+        method: "PUT",
+        headers: entry.headers,
+        body: Buffer.from(entry.file.bytes),
+        signal: combineSignals(
+          signal,
+          AbortSignal.timeout(STORAGE_PUT_TIMEOUT_MS)
+        )
+      });
+    } catch (error) {
+      if (signal.aborted || attempt === STORAGE_PUT_ATTEMPTS) throw error;
+      lastError = error;
+      await waitForRetry(attempt, signal);
+      continue;
+    }
+    if (response.ok) return;
+    if (isRetryableStatus(response.status) && attempt < STORAGE_PUT_ATTEMPTS) {
+      lastError = new Error(`Storage PUT failed (${response.status}).`);
+      await waitForRetry(attempt, signal);
+      continue;
+    }
+    throw new Error(
+      `Storage PUT failed (${response.status}): ${await response.text()}`
+    );
+  }
+  throw lastError instanceof Error ? lastError : new Error(`Storage PUT failed for ${entry.file.name}.`);
+}
+function isRetryableStatus(status) {
+  return status === 408 || status === 429 || status >= 500;
+}
+function isRetryableRequestError(error) {
+  if (isObjectRecord2(error) && typeof error.status === "number") {
+    return isRetryableStatus(error.status);
+  }
+  if (isObjectRecord2(error) && error.name === "TimeoutError") return true;
+  if (!(error instanceof TypeError) || error.message !== "fetch failed") {
+    return false;
+  }
+  if (!isObjectRecord2(error.cause) || typeof error.cause.code !== "string") {
+    return false;
+  }
+  return RETRYABLE_NETWORK_ERROR_CODES.has(error.cause.code);
+}
+async function waitForRetry(attempt, signal) {
+  await new Promise((resolve4, reject) => {
+    const abort = () => {
+      clearTimeout(timeout);
+      reject(signal.reason);
+    };
+    const timeout = setTimeout(
+      () => {
+        signal.removeEventListener("abort", abort);
+        resolve4();
+      },
+      200 * 2 ** (attempt - 1)
+    );
+    signal.addEventListener("abort", abort, { once: true });
+  });
+}
+async function mapWithConcurrency(values, concurrency, run) {
+  let nextIndex = 0;
+  let firstError;
+  const worker = async () => {
+    while (firstError === void 0) {
+      const index = nextIndex;
+      nextIndex += 1;
+      if (index >= values.length) return;
+      try {
+        await run(values[index]);
+      } catch (error) {
+        firstError ??= error;
+      }
+    }
+  };
+  await Promise.all(
+    Array.from({ length: Math.min(concurrency, values.length) }, worker)
+  );
+  if (firstError !== void 0) throw firstError;
+}
+function combineSignals(...signals) {
+  const defined = signals.filter(
+    (signal) => signal !== void 0
+  );
+  return defined.length === 1 ? defined[0] : AbortSignal.any(defined);
+}
 function uploadHeaders(entry, objectInfo, mimeType) {
   const headers = { "Content-Type": mimeType };
   if (typeof objectInfo.cacheControl === "string") {
@@ -66611,11 +66834,431 @@ function uploadHeaders(entry, objectInfo, mimeType) {
 function versionPath2(workspace, suffix) {
   return `/api/projects/${workspace.config.projectId}/versions/${workspace.config.versionId}/${suffix}`;
 }
+var UPLOAD_CONCURRENCY, PRESIGN_TIMEOUT_MS, PRESIGN_ATTEMPTS, STORAGE_PUT_TIMEOUT_MS, STORAGE_PUT_ATTEMPTS, ProjectFilePushCancelledError, RETRYABLE_NETWORK_ERROR_CODES;
 var init_project_file_push = __esm({
   "src/project-source/project-file-push.ts"() {
     "use strict";
     init_project_files();
     init_projection();
+    init_src();
+    UPLOAD_CONCURRENCY = 6;
+    PRESIGN_TIMEOUT_MS = 3e4;
+    PRESIGN_ATTEMPTS = 3;
+    STORAGE_PUT_TIMEOUT_MS = 12e4;
+    STORAGE_PUT_ATTEMPTS = 3;
+    ProjectFilePushCancelledError = class extends Error {
+      constructor() {
+        super("Project file upload was cancelled.");
+        this.name = "ProjectFilePushCancelledError";
+      }
+    };
+    RETRYABLE_NETWORK_ERROR_CODES = /* @__PURE__ */ new Set([
+      "ECONNRESET",
+      "ECONNREFUSED",
+      "EHOSTUNREACH",
+      "ENETUNREACH",
+      "ENOTFOUND",
+      "EPIPE",
+      "ETIMEDOUT"
+    ]);
+  }
+});
+
+// src/project-source/trusted-commit-verification.ts
+import { randomUUID as randomUUID5 } from "node:crypto";
+import { tmpdir } from "node:os";
+import { join as join15 } from "node:path";
+function verifyProjectSourceCommitAgainstStateV4(args) {
+  const root = join15(tmpdir(), `neo-source-verify-virtual-${randomUUID5()}`);
+  const workspace = {
+    root,
+    config: {
+      formatVersion: 4,
+      apiBaseUrl: "https://trusted-server.invalid",
+      projectId: args.projectId,
+      versionId: args.versionId,
+      profile: "editor"
+    },
+    state: { records: { ...args.stateRecords } }
+  };
+  const assignments = validateAssignments(args.pendingIdAssignments);
+  const pendingIdByAssignedId = new Map(
+    [...assignments].map(([pendingId2, assignedId]) => [assignedId, pendingId2])
+  );
+  const trustedPendingProjectFiles = /* @__PURE__ */ new Map();
+  const stagedRecordIds = /* @__PURE__ */ new Set();
+  for (const file of args.stagedFiles) {
+    if (stagedRecordIds.has(file.recordId)) {
+      throw new ProjectSourceCommitVerificationError(
+        "Source commit contains duplicate verified staged project files."
+      );
+    }
+    stagedRecordIds.add(file.recordId);
+    const metadata = {
+      mimeType: file.mimeType,
+      byteLength: file.byteLength,
+      sha256: file.contentSha256
+    };
+    trustedPendingProjectFiles.set(file.recordId, metadata);
+    const pendingId2 = pendingIdByAssignedId.get(file.recordId);
+    if (pendingId2 !== void 0) {
+      trustedPendingProjectFiles.set(pendingId2, metadata);
+    }
+  }
+  const status = computeWorkspaceStatus(workspace, {
+    skipProjectBinaryInspection: true,
+    writeProjectAnalysisCache: () => void 0,
+    trustedPendingProjectFiles,
+    virtualSourceFiles: args.files
+  });
+  const blockingErrors = status.parseErrors.filter(isBlockingSchemaSourceError);
+  if (status.conflictedFiles.length > 0 || blockingErrors.length > 0) {
+    const first = blockingErrors[0];
+    throw new ProjectSourceCommitVerificationError(
+      first ? `Trusted source lowering failed: ${first.file}:${first.line}:${first.column} ${first.message}` : `Trusted source lowering found conflict markers in ${status.conflictedFiles[0]}.`
+    );
+  }
+  const usedAssignments = /* @__PURE__ */ new Set();
+  const expectedChanges = status.changes.map((change) => {
+    const rewrittenData = change.nextData === void 0 ? void 0 : rewritePending(change.nextData, assignments, usedAssignments);
+    return {
+      recordKind: change.recordKind,
+      recordId: rewritePending(change.recordId, assignments, usedAssignments),
+      operation: change.kind,
+      // Source syntax does not author project ownership. The CLI stamps the
+      // authenticated project id on creates immediately before transport;
+      // reproduce that server-known field instead of comparing the
+      // lowerer's empty construction placeholder.
+      nextData: change.kind === "create" && isObjectRecord2(rewrittenData) ? { ...rewrittenData, projectId: args.projectId } : rewrittenData,
+      expectedBaseContentHash: change.kind === "create" ? null : change.casBaseHash ?? null
+    };
+  });
+  const expectedSeeds = [...status.staticValueSeeds].map(
+    ([memberId, seed]) => ({
+      memberId: rewritePending(memberId, assignments, usedAssignments),
+      value: rewritePending(seed.value, assignments, usedAssignments),
+      classId: seed.classId === null ? null : rewritePending(seed.classId, assignments, usedAssignments),
+      ...seed.valueId === void 0 ? {} : {
+        valueId: rewritePending(seed.valueId, assignments, usedAssignments)
+      },
+      ...seed.values === void 0 ? {} : {
+        values: rewritePending(seed.values, assignments, usedAssignments)
+      },
+      ...seed.bindingMembers === void 0 ? {} : {
+        bindingMembers: rewritePending(
+          seed.bindingMembers,
+          assignments,
+          usedAssignments
+        )
+      },
+      ...seed.localizedTexts === void 0 ? {} : {
+        localizedTexts: rewritePending(
+          seed.localizedTexts,
+          assignments,
+          usedAssignments
+        )
+      }
+    })
+  );
+  for (const pendingId2 of assignments.keys()) {
+    if (!usedAssignments.has(pendingId2)) {
+      throw new ProjectSourceCommitVerificationError(
+        `Pending id assignment ${pendingId2} is not present in the verified source manifest.`
+      );
+    }
+  }
+  compareChanges(expectedChanges, args.changes);
+  compareSeeds(expectedSeeds, args.staticValueSeeds);
+}
+function validateAssignments(value) {
+  const assignments = /* @__PURE__ */ new Map();
+  const assignedIds = /* @__PURE__ */ new Set();
+  for (const [pendingId2, assignedId] of Object.entries(value)) {
+    if (!pendingId2.startsWith("__pending__:")) {
+      throw new ProjectSourceCommitVerificationError(
+        `Pending id assignment key ${pendingId2} is not a pending identity.`
+      );
+    }
+    if (pendingMemberValueMemberId(pendingId2) === null) {
+      if (!/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/u.test(
+        assignedId
+      )) {
+        throw new ProjectSourceCommitVerificationError(
+          `Pending id assignment for ${pendingId2} is not a UUID v4.`
+        );
+      }
+    }
+    if (assignedIds.has(assignedId)) {
+      throw new ProjectSourceCommitVerificationError(
+        `Pending id assignments reuse durable id ${assignedId}.`
+      );
+    }
+    assignments.set(pendingId2, assignedId);
+    assignedIds.add(assignedId);
+  }
+  assertMemberValueAssignmentsAreDerived(assignments);
+  return assignments;
+}
+function assertMemberValueAssignmentsAreDerived(assignments) {
+  for (const [pendingId2, assignedId] of assignments) {
+    const memberLocator = pendingMemberValueMemberId(pendingId2);
+    if (memberLocator === null) continue;
+    const memberId = memberLocator.startsWith("__pending__:") ? assignments.get(memberLocator) : memberLocator;
+    if (memberId === void 0) {
+      throw new ProjectSourceCommitVerificationError(
+        `Member value assignment ${pendingId2} names member ${memberLocator}, which has no pending id assignment.`
+      );
+    }
+    const derived = derivedMemberValueId(memberId);
+    if (assignedId !== derived) {
+      throw new ProjectSourceCommitVerificationError(
+        `Member value assignment ${pendingId2} is ${assignedId}, but member ${memberId} owns value ${derived}.`
+      );
+    }
+  }
+}
+function positionIndependentPendingKey(pendingId2) {
+  const parts = pendingId2.split(":");
+  if (parts.length !== 6) return null;
+  const [prefix, kind, uri, line, character, label] = parts;
+  if (prefix !== "__pending__") return null;
+  if (!/^\d+$/u.test(line) || !/^\d+$/u.test(character)) return null;
+  return `${prefix}:${kind}:${uri}:${label}`;
+}
+function positionIndependentAssignments(assignments) {
+  const candidates = /* @__PURE__ */ new Map();
+  for (const pendingId2 of assignments.keys()) {
+    const key = positionIndependentPendingKey(pendingId2);
+    if (key === null) continue;
+    candidates.set(key, [...candidates.get(key) ?? [], pendingId2]);
+  }
+  const resolved = /* @__PURE__ */ new Map();
+  for (const [key, pendingIds] of candidates) {
+    if (pendingIds.length !== 1) continue;
+    resolved.set(key, pendingIds[0]);
+  }
+  return resolved;
+}
+function rewritePending(value, assignments, used, byPosition) {
+  const positionless = byPosition ?? positionIndependentAssignments(assignments);
+  if (typeof value === "string") {
+    const exact = assignments.get(value);
+    if (exact !== void 0) {
+      used.add(value);
+      return exact;
+    }
+    if (value.startsWith("__pending__:")) {
+      const key = positionIndependentPendingKey(value);
+      const relocated = key === null ? void 0 : positionless.get(key);
+      if (relocated !== void 0) {
+        used.add(relocated);
+        return assignments.get(relocated);
+      }
+      throw new ProjectSourceCommitVerificationError(
+        `Verified source identity ${value} has no pending id assignment.`
+      );
+    }
+    let rewritten = value;
+    for (const [pendingId2, assignedId] of assignments) {
+      if (!rewritten.includes(pendingId2)) continue;
+      rewritten = rewritten.replaceAll(pendingId2, assignedId);
+      used.add(pendingId2);
+    }
+    return rewritten;
+  }
+  if (Array.isArray(value)) {
+    return value.map(
+      (entry) => rewritePending(entry, assignments, used, positionless)
+    );
+  }
+  if (isObjectRecord2(value)) {
+    const result = {};
+    for (const [key, entry] of Object.entries(value)) {
+      const rewrittenKey = key.startsWith("__pending__:") ? rewritePending(key, assignments, used, positionless) : key;
+      result[rewrittenKey] = rewritePending(
+        entry,
+        assignments,
+        used,
+        positionless
+      );
+    }
+    return result;
+  }
+  return value;
+}
+function compareChanges(expected, received) {
+  const expectedByKey = new Map(
+    expected.map((change) => [
+      `${change.recordKind}:${change.recordId}`,
+      change
+    ])
+  );
+  const receivedByKey = new Map(
+    received.map((change) => [
+      `${change.recordKind}:${change.recordId}`,
+      change
+    ])
+  );
+  if (expectedByKey.size !== expected.length || receivedByKey.size !== received.length) {
+    throw new ProjectSourceCommitVerificationError(
+      "Source commit contains duplicate semantic record changes."
+    );
+  }
+  for (const [key, expectedChange] of expectedByKey) {
+    const actual = receivedByKey.get(key);
+    if (actual === void 0) {
+      throw new ProjectSourceCommitVerificationError(
+        `Source commit omitted semantic change ${key}.`
+      );
+    }
+    if (actual.operation !== expectedChange.operation || (actual.expectedBaseContentHash ?? null) !== expectedChange.expectedBaseContentHash) {
+      throw new ProjectSourceCommitVerificationError(
+        `Source commit changed operation or CAS base for ${key}.`
+      );
+    }
+    const expectedData = comparisonData(
+      expectedChange.recordKind,
+      expectedChange.nextData
+    );
+    const actualData = comparisonData(actual.recordKind, actual.nextData);
+    if (canonicalStringify(expectedData) !== canonicalStringify(actualData)) {
+      const difference = firstDifference(expectedData, actualData);
+      throw new ProjectSourceCommitVerificationError(
+        `Source commit nextData for ${key} does not match trusted lowering${difference === null ? "." : ` at ${difference.path}: trusted ${formatDifferenceValue(difference.trusted)}, submitted ${formatDifferenceValue(difference.submitted)}.`}`
+      );
+    }
+    if (!isObjectRecord2(actual.intent) || actual.intent.type !== `${actual.recordKind}.${actual.operation}`) {
+      throw new ProjectSourceCommitVerificationError(
+        `Source commit intent for ${key} does not match its semantic operation.`
+      );
+    }
+    receivedByKey.delete(key);
+  }
+  const extra = receivedByKey.keys().next().value;
+  if (extra !== void 0) {
+    throw new ProjectSourceCommitVerificationError(
+      `Source commit added semantic change ${extra} absent from trusted lowering.`
+    );
+  }
+}
+function firstDifference(trusted, submitted, path = "$") {
+  if (Object.is(trusted, submitted)) return null;
+  if (Array.isArray(trusted) && Array.isArray(submitted)) {
+    const count = Math.max(trusted.length, submitted.length);
+    for (let index = 0; index < count; index += 1) {
+      if (index >= trusted.length) {
+        return {
+          path: `${path}[${index}]`,
+          trusted: ABSENT_DIFFERENCE_VALUE,
+          submitted: submitted[index]
+        };
+      }
+      if (index >= submitted.length) {
+        return {
+          path: `${path}[${index}]`,
+          trusted: trusted[index],
+          submitted: ABSENT_DIFFERENCE_VALUE
+        };
+      }
+      const difference = firstDifference(
+        trusted[index],
+        submitted[index],
+        `${path}[${index}]`
+      );
+      if (difference !== null) return difference;
+    }
+  }
+  if (isObjectRecord2(trusted) && isObjectRecord2(submitted)) {
+    const keys = [
+      .../* @__PURE__ */ new Set([...Object.keys(trusted), ...Object.keys(submitted)])
+    ].sort();
+    for (const key of keys) {
+      const trustedHasKey = Object.hasOwn(trusted, key);
+      const submittedHasKey = Object.hasOwn(submitted, key);
+      const childPath = `${path}.${key}`;
+      if (!trustedHasKey || !submittedHasKey) {
+        return {
+          path: childPath,
+          trusted: trustedHasKey ? trusted[key] : ABSENT_DIFFERENCE_VALUE,
+          submitted: submittedHasKey ? submitted[key] : ABSENT_DIFFERENCE_VALUE
+        };
+      }
+      const difference = firstDifference(
+        trusted[key],
+        submitted[key],
+        childPath
+      );
+      if (difference !== null) return difference;
+    }
+  }
+  return { path, trusted, submitted };
+}
+function formatDifferenceValue(value) {
+  if (value === ABSENT_DIFFERENCE_VALUE) return "<absent>";
+  const serialized = JSON.stringify(value);
+  const rendered = serialized === void 0 ? String(value) : serialized;
+  return rendered.length <= 160 ? rendered : `${rendered.slice(0, 157)}...`;
+}
+function comparisonData(recordKind, value) {
+  if (!isObjectRecord2(value)) return value;
+  const result = { ...value };
+  delete result.createdAt;
+  delete result.updatedAt;
+  if (recordKind === "member") {
+    delete result.getter;
+    delete result.setter;
+    if (result.kind === 23) delete result.action;
+  }
+  if (recordKind === "migration") delete result.action;
+  return result;
+}
+function compareSeeds(expected, received) {
+  const normalize = (values) => values.map(normalizeSeedForComparison).sort((left, right) => {
+    if (left.memberId < right.memberId) return -1;
+    if (left.memberId > right.memberId) return 1;
+    return 0;
+  });
+  if (canonicalStringify(normalize(expected)) !== canonicalStringify(normalize(received))) {
+    throw new ProjectSourceCommitVerificationError(
+      "Source commit static value seeds do not match trusted lowering."
+    );
+  }
+}
+function normalizeSeedForComparison(seed) {
+  const normalized = { ...seed };
+  if (seed.values !== void 0) {
+    normalized.values = sortSeedRows(seed.values);
+  }
+  if (seed.bindingMembers !== void 0) {
+    normalized.bindingMembers = sortSeedRows(seed.bindingMembers);
+  }
+  if (seed.localizedTexts !== void 0) {
+    normalized.localizedTexts = sortSeedRows(seed.localizedTexts);
+  }
+  return normalized;
+}
+function sortSeedRows(values) {
+  return [...values].sort((left, right) => {
+    if (left.id < right.id) return -1;
+    if (left.id > right.id) return 1;
+    return 0;
+  });
+}
+var ProjectSourceCommitVerificationError, ABSENT_DIFFERENCE_VALUE;
+var init_trusted_commit_verification = __esm({
+  "src/project-source/trusted-commit-verification.ts"() {
+    "use strict";
+    init_workspace_status();
+    init_source_diagnostics();
+    init_projection();
+    init_member_value_id();
+    ProjectSourceCommitVerificationError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "ProjectSourceCommitVerificationError";
+      }
+    };
+    ABSENT_DIFFERENCE_VALUE = /* @__PURE__ */ Symbol("absent-difference-value");
   }
 });
 
@@ -66660,7 +67303,7 @@ __export(push_exports, {
   stripServerDerivedNeoScript: () => stripServerDerivedNeoScript,
   workspaceChangesRequireCompleteBodySweep: () => workspaceChangesRequireCompleteBodySweep
 });
-import { randomUUID as randomUUID5 } from "node:crypto";
+import { randomUUID as randomUUID6 } from "node:crypto";
 import {
   mkdirSync as mkdirSync11,
   writeFileSync as writeFileSync11,
@@ -66668,7 +67311,7 @@ import {
   existsSync as existsSync12,
   readFileSync as readFileSync13
 } from "node:fs";
-import { dirname as dirname7, join as join15, relative as relative5, sep as sep5 } from "node:path";
+import { dirname as dirname7, join as join16, relative as relative5, sep as sep5 } from "node:path";
 function assignPendingIds(changes, staticValueSeeds, reconstructed3) {
   const assigned = /* @__PURE__ */ new Map();
   const assign = (pendingId2) => {
@@ -66681,7 +67324,7 @@ function assignPendingIds(changes, staticValueSeeds, reconstructed3) {
       assigned.set(pendingId2, derived);
       return derived;
     }
-    const fresh = randomUUID5();
+    const fresh = randomUUID6();
     assigned.set(pendingId2, fresh);
     return fresh;
   };
@@ -66992,6 +67635,10 @@ function createPushProgressReporter(json) {
   };
 }
 function projectTransactionProgressLabel(event) {
+  if (event.type === "push-progress") {
+    if (event.phase === "preparing") return "Preparing push\u2026";
+    return `Uploading files\u2026 ${event.completedFiles.toLocaleString("en-US")}/${event.totalFiles.toLocaleString("en-US")} (${formatByteProgress(event.completedBytes)}/${formatByteProgress(event.totalBytes)})`;
+  }
   if (event.phase === "submitting") return "Pushing\u2026";
   if (event.phase === "preparing") return "Preparing push\u2026";
   if (event.phase === "waiting") return "Waiting to apply project transaction\u2026";
@@ -67009,6 +67656,11 @@ function projectTransactionProgressLabel(event) {
   }
   return "Finalizing project transaction\u2026";
 }
+function formatByteProgress(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KiB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MiB`;
+}
 function progressEventFromAccepted(accepted) {
   return {
     type: "project-transaction-progress",
@@ -67281,46 +67933,111 @@ ${blockingErrors.map((error) => `  ${error.message}`).join("\n")}`
     console.log("Push cancelled.");
     return;
   }
-  const sourceBundle = await createPendingProjectSourceBundleV4(
-    workspace,
-    status,
-    status.staticValueSeeds
-  );
-  const pendingAssignment = assignPendingIds(
-    status.changes,
-    status.staticValueSeeds,
-    status.reconstructed
-  );
-  const operations = new Set(status.changes.map((change) => change.kind));
-  const transactionOperation = operations.size === 1 ? status.changes[0].kind : "update";
-  const client = NeoApiClient.forBaseUrl(workspace.config.apiBaseUrl);
-  let stagedFiles = await stageProjectFilePushesV4({
-    workspace,
-    changes: status.changes,
-    binaryChanges: status.binaryChanges ?? [],
-    assignedIds: pendingAssignment.assigned,
-    client
+  let progress = createPushProgressReporter(options.json === true);
+  progress.report({
+    type: "push-progress",
+    phase: "preparing",
+    completedFiles: 0,
+    totalFiles: status.binaryChanges?.length ?? 0,
+    completedBytes: 0,
+    totalBytes: 0
   });
+  const prepareAndStage = async () => {
+    const source2 = await createPendingProjectSourceBundleV4(
+      workspace,
+      status,
+      status.staticValueSeeds
+    );
+    const pendingAssignment2 = assignPendingIds(
+      status.changes,
+      status.staticValueSeeds,
+      status.reconstructed
+    );
+    const operations = new Set(status.changes.map((change) => change.kind));
+    const transactionOperation2 = operations.size === 1 ? status.changes[0].kind : "update";
+    const client2 = NeoApiClient.forBaseUrl(workspace.config.apiBaseUrl);
+    const transportChanges2 = status.changes.map((change) => ({
+      recordKind: change.recordKind,
+      recordId: change.recordId,
+      operation: change.kind,
+      nextData: change.kind === "delete" ? void 0 : stripServerDerivedNeoScript(change.nextData),
+      deleted: change.kind === "delete" ? true : void 0,
+      intent: createNeoCliPushIntent(change),
+      expectedBaseContentHash: change.kind === "create" ? null : change.casBaseHash ?? null
+    }));
+    const transportSeeds2 = [...pendingAssignment2.staticValueSeeds].map(
+      ([memberId, seed]) => ({ memberId, ...seed })
+    );
+    const files = prepareProjectFilePushesV4({
+      workspace,
+      changes: status.changes,
+      binaryChanges: status.binaryChanges ?? [],
+      assignedIds: pendingAssignment2.assigned
+    });
+    verifyProjectSourceCommitAgainstStateV4({
+      projectId: workspace.config.projectId,
+      versionId: workspace.config.versionId,
+      stateRecords: workspace.state.records,
+      files: source2.files,
+      changes: transportChanges2,
+      staticValueSeeds: transportSeeds2,
+      pendingIdAssignments: Object.fromEntries(pendingAssignment2.assigned),
+      stagedFiles: files
+    });
+    const stagedFiles2 = await stageProjectFilePushesV4({
+      workspace,
+      changes: status.changes,
+      binaryChanges: status.binaryChanges ?? [],
+      assignedIds: pendingAssignment2.assigned,
+      client: client2,
+      prepared: files,
+      onProgress: (upload) => progress.report({
+        type: "push-progress",
+        phase: "uploading",
+        ...upload
+      })
+    });
+    return {
+      source: source2,
+      pendingAssignment: pendingAssignment2,
+      transactionOperation: transactionOperation2,
+      client: client2,
+      transportChanges: transportChanges2,
+      transportSeeds: transportSeeds2,
+      preparedFiles: files,
+      stagedFiles: stagedFiles2
+    };
+  };
+  let preparedPush;
+  try {
+    preparedPush = await prepareAndStage();
+  } catch (error) {
+    progress.stop();
+    if (error instanceof ProjectFilePushCancelledError) {
+      if (options.json !== true) console.error("Push cancelled.");
+      process.exitCode = 130;
+      return;
+    }
+    throw error;
+  }
+  const {
+    source,
+    pendingAssignment,
+    transactionOperation,
+    client,
+    transportChanges,
+    transportSeeds,
+    preparedFiles
+  } = preparedPush;
+  let { stagedFiles } = preparedPush;
   const commit = async (force) => await client.post(
     `/api/projects/${workspace.config.projectId}/versions/${workspace.config.versionId}/schema/commit`,
     {
       operation: transactionOperation,
-      changes: status.changes.map((change) => {
-        return {
-          recordKind: change.recordKind,
-          recordId: change.recordId,
-          operation: change.kind,
-          nextData: change.kind === "delete" ? void 0 : stripServerDerivedNeoScript(change.nextData),
-          deleted: change.kind === "delete" ? true : void 0,
-          intent: createNeoCliPushIntent(change),
-          expectedBaseContentHash: change.kind === "create" ? null : change.casBaseHash ?? null
-        };
-      }),
-      staticValueSeeds: [...pendingAssignment.staticValueSeeds].map(
-        ([memberId, seed]) => ({ memberId, ...seed })
-      ),
+      changes: transportChanges,
+      staticValueSeeds: transportSeeds,
       stagedFiles,
-      sourceBundle,
+      sourceBundle: source.bundle,
       pendingIdAssignments: Object.fromEntries(pendingAssignment.assigned),
       summary: options.summary ?? "neo push"
     },
@@ -67434,7 +68151,6 @@ ${blockingErrors.map((error) => `  ${error.message}`).join("\n")}`
     if (options.json !== true) success("Push complete.");
     return true;
   };
-  let progress = createPushProgressReporter(options.json === true);
   progress.report({
     type: "project-transaction-progress",
     transactionId: null,
@@ -67467,28 +68183,39 @@ ${blockingErrors.map((error) => `  ${error.message}`).join("\n")}`
         fallback: false
       })) {
         progress = createPushProgressReporter(options.json === true);
-        progress.report({
-          type: "project-transaction-progress",
-          transactionId: null,
-          phase: "submitting",
-          totalChangeCount: status.changes.length,
-          appliedChangeCount: 0,
-          totalChunkCount: null,
-          appliedChunkCount: 0,
-          errorCode: null,
-          errorMessage: null
-        });
         try {
           stagedFiles = await stageProjectFilePushesV4({
             workspace,
             changes: status.changes,
             binaryChanges: status.binaryChanges ?? [],
             assignedIds: pendingAssignment.assigned,
-            client
+            client,
+            prepared: preparedFiles,
+            onProgress: (upload) => progress.report({
+              type: "push-progress",
+              phase: "uploading",
+              ...upload
+            })
+          });
+          progress.report({
+            type: "project-transaction-progress",
+            transactionId: null,
+            phase: "submitting",
+            totalChangeCount: status.changes.length,
+            appliedChangeCount: 0,
+            totalChunkCount: null,
+            appliedChunkCount: 0,
+            errorCode: null,
+            errorMessage: null
           });
           result = await commit(true);
         } catch (retryError) {
           progress.stop();
+          if (retryError instanceof ProjectFilePushCancelledError) {
+            if (options.json !== true) console.error("Push cancelled.");
+            process.exitCode = 130;
+            return;
+          }
           if (retryError instanceof NeoApiError) {
             reportPushRejection(retryError.status, retryError.body);
             process.exitCode = 1;
@@ -67617,17 +68344,19 @@ async function createPendingProjectSourceBundleV4(workspace, status, staticValue
     }
   }
   const emission = emitProjectDocumentFilesV4(records2);
-  return createProjectSourceBundle(
-    emission.files.map((file) => {
-      const kind = neoProjectSourceKind(file.path);
-      if (kind === null) {
-        throw new Error(
-          `Emitted project source bundle file ${JSON.stringify(file.path)} is not a recognized Neo source path.`
-        );
-      }
-      return { path: file.path, kind, content: file.content };
-    })
-  );
+  const files = emission.files.map((file) => {
+    const kind = neoProjectSourceKind(file.path);
+    if (kind === null) {
+      throw new Error(
+        `Emitted project source bundle file ${JSON.stringify(file.path)} is not a recognized Neo source path.`
+      );
+    }
+    return { path: file.path, kind, content: file.content };
+  });
+  return {
+    files,
+    bundle: await createProjectSourceBundle(files)
+  };
 }
 function staticSeedBindingMemberRecord(projectId, bindingMember, timestamp) {
   return {
@@ -68018,11 +68747,11 @@ ${finalErrors.map(
   for (const recordState of Object.values(workspace.state.records)) {
     const previousPath = recordState.file;
     if (previousPath === void 0 || emittedPaths.has(previousPath)) continue;
-    const absolute = join15(workspace.root, previousPath);
+    const absolute = join16(workspace.root, previousPath);
     if (existsSync12(absolute)) rmSync6(absolute);
   }
   for (const file of files) {
-    const absolute = join15(workspace.root, file.path);
+    const absolute = join16(workspace.root, file.path);
     mkdirSync11(dirname7(absolute), { recursive: true });
     const existing = existsSync12(absolute) ? readFileSync13(absolute, "utf8") : null;
     if (existing !== file.content)
@@ -68702,6 +69431,7 @@ var init_push = __esm({
     init_source_diagnostics();
     init_projection();
     init_project_file_push();
+    init_trusted_commit_verification();
     init_world_system_classes();
     init_project_manifest();
     init_merge();
@@ -68744,7 +69474,7 @@ __export(dev_exports, {
   runDev: () => runDev
 });
 import { watch } from "node:fs";
-import { join as join16 } from "node:path";
+import { join as join17 } from "node:path";
 import { emitKeypressEvents } from "node:readline";
 import { ConvexClient } from "convex/browser";
 function isSchemaSignal(value) {
@@ -68851,7 +69581,7 @@ async function runDev(workspace, options) {
   };
   for (const dir of ["Classes", "Enums"]) {
     try {
-      watch(join16(workspace.root, dir), { persistent: true }, onFileChange);
+      watch(join17(workspace.root, dir), { persistent: true }, onFileChange);
     } catch {
     }
   }
@@ -68907,7 +69637,7 @@ __export(resolve_exports, {
   workspaceFilePath: () => workspaceFilePath
 });
 import { readFileSync as readFileSync14, rmSync as rmSync7, writeFileSync as writeFileSync12 } from "node:fs";
-import { join as join17 } from "node:path";
+import { join as join18 } from "node:path";
 function runResolve(workspace, side) {
   let resolvedFiles = 0;
   for (const filePath of listProjectSourceFilesV4(workspace.root)) {
@@ -68922,12 +69652,12 @@ function runResolve(workspace, side) {
     const binary = state.projectBinary;
     const conflict2 = binary?.conflict;
     if (binary === void 0 || conflict2 === void 0) continue;
-    const destination = join17(workspace.root, binary.path);
+    const destination = join18(workspace.root, binary.path);
     if (side === "theirs") {
       if (conflict2.remoteSha256 !== null && conflict2.artifactPath !== void 0) {
         writeVerifiedBinaryDownloadV4(
           destination,
-          readFileSync14(join17(workspace.root, conflict2.artifactPath)),
+          readFileSync14(join18(workspace.root, conflict2.artifactPath)),
           conflict2.remoteSha256
         );
         binary.sha256 = conflict2.remoteSha256;
@@ -68937,7 +69667,7 @@ function runResolve(workspace, side) {
       }
     }
     if (conflict2.artifactPath !== void 0) {
-      rmSync7(join17(workspace.root, conflict2.artifactPath), { force: true });
+      rmSync7(join18(workspace.root, conflict2.artifactPath), { force: true });
     }
     delete binary.conflict;
     resolvedBinaries += 1;
@@ -68990,7 +69720,7 @@ function resolveMarkers(source, side) {
   return output.join("\n");
 }
 function workspaceFilePath(workspace, file) {
-  return join17(workspace.root, file);
+  return join18(workspace.root, file);
 }
 var init_resolve = __esm({
   "src/commands/resolve.ts"() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neocompose/cli",
-  "version": "0.11.0",
+  "version": "0.11.1",
   "description": "Neo Compose native project-source CLI with bidirectional sync.",
   "license": "MIT",
   "type": "module",