@neocompose/cli 0.10.2 → 0.10.4

package/CHANGELOG.md

@@ -1,5 +1,38 @@
 # Changelog
 
+## [0.10.4] - 2026-07-26
+
+### Fixed
+
+- Materialize the required keys a bare `new()` omits. A constructor body was
+  built from constructor projections and explicit assignments only, so
+  `Birthday = new()` lowered to `{}` and the commit was rejected with
+  `missing required schema key "Day"` -- naming a key whose default the source
+  declares one line away. Each omitted required key now lowers the member's own
+  declared initializer, so a nested `new()` recurses and a row-backed default
+  is copied rather than shared. Optional keys stay absent, and a required key
+  whose member declares no default is unchanged.
+
+- Stop rejecting the transaction status response over a field the server no
+  longer sends. `resultCursor` was removed from the status payload as dead --
+  it was hardcoded null and read only as the starting result-page cursor,
+  where an empty cursor means the same thing -- but push still required it to
+  be present, so every push large enough to go durable failed with
+  `resultCursor must be a string or null` after the write had already
+  committed.
+
+## [0.10.3] - 2026-07-25
+
+### Fixed
+
+- Stop writing `isReadOnly: false` onto members that never carried the field.
+  Absent is how false is spelled, but document normalization materialized the
+  full-member default, so any member record that changed for another reason
+  pushed an explicit `isReadOnly: false` with it. The explicit value is kept
+  only where it has something to overwrite -- a record that already carries
+  the field, which is how dropping `readonly` from a declaration reaches the
+  server.
+
 ## [0.10.2] - 2026-07-25
 
 ### Fixed

package/dist/neo.mjs

@@ -1356,6 +1356,9 @@ function composeDocumentRecord(recordKind, recordId, authoredFields, baseRecord)
     const base = partitionDocumentFields(recordKind, baseRecord.data);
     Object.assign(data, base.derived, base.volatile);
   }
+  if (recordKind === "member" && data.isReadOnly === false && !Object.prototype.hasOwnProperty.call(baseRecord?.data ?? {}, "isReadOnly")) {
+    delete data.isReadOnly;
+  }
   return { recordKind, recordId, data };
 }
 function assertOnlyAuthoredFields(recordKind, fields) {
@@ -42414,6 +42417,7 @@ function buildValueLowerContext(state, manifest, options = {}) {
     mainLocale: projectMainLocaleFromState(state),
     valuePlacements: indexValuePlacements(state),
     parsedInitializers,
+    declaredInitializers: indexDeclaredInitializers(options.analysis),
     reconstructed: /* @__PURE__ */ new Map(),
     pendingValues: /* @__PURE__ */ new Map(),
     pendingLocalizedTexts: /* @__PURE__ */ new Map(),
@@ -42421,6 +42425,27 @@ function buildValueLowerContext(state, manifest, options = {}) {
     pendingBindingMembersByClassId: /* @__PURE__ */ new Map()
   };
 }
+function indexDeclaredInitializers(analysis) {
+  const initializers = /* @__PURE__ */ new Map();
+  if (analysis === void 0) return initializers;
+  for (const sourceClass of analysis.schema.classes) {
+    for (const declaration of sourceClass.members) {
+      if (declaration.kind !== "field" || declaration.initializer === null) {
+        continue;
+      }
+      if (declaration.modifiers.includes("static")) continue;
+      initializers.set(
+        sourceIdentityId(
+          declaration,
+          "member",
+          `${sourceClass.name}.${declaration.name}`
+        ),
+        declaration.initializer
+      );
+    }
+  }
+  return initializers;
+}
 function lowerStoredValueBindingsV4(state, manifest, bindings, options = {}) {
   const context = buildValueLowerContext(state, manifest, options);
   const memberValueIds = /* @__PURE__ */ new Map();
@@ -42886,6 +42911,17 @@ function lowerSeedRow(context, member, sourceExpression, source, valueId, path,
         environment
       );
     }
+    materializeRequiredDefaults(
+      context,
+      resolvedMember,
+      effectiveClass,
+      body,
+      source,
+      path,
+      rows,
+      localizedTexts,
+      environment
+    );
     value = body;
   } else if (resolvedMember.kind === "list") {
     if (expression.kind === "litNull") {
@@ -42981,6 +43017,51 @@ function lowerSeedRow(context, member, sourceExpression, source, valueId, path,
   context.pendingValues.set(valueId, row);
   return row;
 }
+function materializeRequiredDefaults(context, member, effectiveClass, body, source, path, rows, localizedTexts, environment) {
+  if (member.partial === true) return;
+  for (const [schemaKey, childMember] of storedSchemaEntries(
+    context,
+    effectiveClass
+  )) {
+    if (body[schemaKey] !== void 0) continue;
+    if (!childMember.required) continue;
+    if (childMember.kind === "class" && childMember.partial === true) continue;
+    const initializer = context.declaredInitializers.get(childMember.id);
+    if (initializer === void 0) continue;
+    body[schemaKey] = lowerSeedChild(
+      context,
+      recursivePartialMember(member, childMember),
+      parseCachedInitializer(context.parsedInitializers, initializer),
+      source,
+      `${path}.${schemaKey}`,
+      rows,
+      localizedTexts,
+      void 0,
+      environment
+    );
+  }
+}
+function storedSchemaEntries(context, schemaClass2) {
+  const entries = /* @__PURE__ */ new Map();
+  const visited = /* @__PURE__ */ new Set();
+  let current = schemaClass2;
+  while (current !== void 0 && !visited.has(current.id)) {
+    visited.add(current.id);
+    for (const [schemaKey, memberId] of Object.entries(current.schema)) {
+      if (entries.has(schemaKey)) continue;
+      const child = context.members.get(memberId);
+      if (child === void 0) continue;
+      if (!ownsValueRow(child)) continue;
+      entries.set(schemaKey, child);
+    }
+    current = current.extendsClassId === null ? void 0 : context.classes.get(current.extendsClassId);
+  }
+  return [...entries];
+}
+function ownsValueRow(member) {
+  if (member.isReadOnly) return false;
+  return member.kind !== "computed" && member.kind !== "function" && member.kind !== "scriptFunction";
+}
 function lowerSeedChild(context, member, expression, source, path, rows, localizedTexts, containerId, environment) {
   const symbolId = sourceValueSymbol(context, expression);
   if (symbolId !== null) return symbolId;
@@ -66665,10 +66746,6 @@ function readProjectVersionTransactionStatus(value, transactionId) {
     value.errorMessage,
     `Project transaction "${transactionId}" errorMessage`
   );
-  const resultCursor = readNullableString(
-    value.resultCursor,
-    `Project transaction "${transactionId}" resultCursor`
-  );
   return {
     transactionId,
     commitStatus: value.commitStatus,
@@ -66689,8 +66766,7 @@ function readProjectVersionTransactionStatus(value, transactionId) {
       `Project transaction "${transactionId}" appliedChunkCount`
     ),
     errorCode,
-    errorMessage: errorMessage3,
-    resultCursor
+    errorMessage: errorMessage3
   };
 }
 function readProjectVersionTransactionResultPage(value, transactionId) {
@@ -66898,7 +66974,7 @@ async function downloadProjectVersionTransactionResult(args) {
   const assignments = {};
   const changedRecords = [];
   const seenCursors = /* @__PURE__ */ new Set();
-  let cursor = args.status.resultCursor ?? "";
+  let cursor = "";
   for (; ; ) {
     if (seenCursors.has(cursor)) {
       throw new Error(

package/package.json

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