@neocompose/cli 0.7.0 → 0.7.1

package/CHANGELOG.md

@@ -7,6 +7,14 @@
 - Document the final relation-only world layer-link contract and keep the
   format-4 Hello World corpus free of the retired value-side binding field.
 
+## [0.7.1] - 2026-07-22
+
+### Added
+
+- Support `abstract readonly` getter contracts and concrete `override readonly`
+  implementations, including inherited Immutable storage without a repeated
+  storage decorator.
+
 ## [0.7.0] - 2026-07-22
 
 ### Added

package/dist/neo.mjs

@@ -16240,6 +16240,7 @@ function createEnvironment2(documents) {
   const declarations = /* @__PURE__ */ new Map();
   const classes = /* @__PURE__ */ new Map();
   const interfaces = /* @__PURE__ */ new Map();
+  const memberOwners = /* @__PURE__ */ new Map();
   const typeKinds = /* @__PURE__ */ new Map();
   for (const [uri, document] of documents) {
     for (const declaration of document.declarations) {
@@ -16264,6 +16265,9 @@ function createEnvironment2(documents) {
         };
         declarations.set(declaration.name, ref);
         classes.set(declaration.name, ref);
+        for (const member of declaration.members) {
+          memberOwners.set(member, ref);
+        }
         typeKinds.set(declaration.name, {
           kind: "class",
           location: ref.location,
@@ -16286,7 +16290,7 @@ function createEnvironment2(documents) {
       }
     }
   }
-  return { declarations, classes, interfaces, typeKinds };
+  return { declarations, classes, interfaces, memberOwners, typeKinds };
 }
 function validatePersistedNames(documents, diagnostics) {
   for (const [uri, document] of documents) {
@@ -16921,16 +16925,7 @@ function validateClassMemberModifiers(ref, environment, diagnostics) {
             `Read-only field '${member.name}' cannot be static.`
           );
         }
-        if (modifiers.has("abstract")) {
-          diagnose(
-            diagnostics,
-            ref.uri,
-            member.nameRange,
-            "abstract-readonly-member",
-            `Read-only field '${member.name}' cannot be abstract.`
-          );
-        }
-        if (member.initializer === void 0) {
+        if (member.initializer === void 0 && !modifiers.has("abstract")) {
           diagnose(
             diagnostics,
             ref.uri,
@@ -17102,7 +17097,38 @@ function validateClassOverrides(ref, environment, diagnostics) {
       environment,
       true
     );
+    const readOnlyContract = candidates.find(
+      (candidate) => candidate.member.modifiers.includes("abstract") && candidate.member.modifiers.includes("readonly")
+    );
+    if (readOnlyContract !== void 0 && !member.modifiers.includes("readonly")) {
+      diagnose(
+        diagnostics,
+        ref.uri,
+        member.nameRange,
+        "override-readonly-contract",
+        `Override '${ref.declaration.name}.${member.name}' must remain readonly because '${readOnlyContract.owner.declaration.name}.${readOnlyContract.member.name}' is an abstract readonly contract.`,
+        related(
+          memberLocation(readOnlyContract),
+          "The abstract readonly contract is declared here."
+        )
+      );
+      continue;
+    }
     if (mismatch) {
+      if (mismatch === "the implementation must provide a setter" && member.modifiers.includes("readonly")) {
+        diagnose(
+          diagnostics,
+          ref.uri,
+          member.nameRange,
+          "override-readonly-setter",
+          `Read-only override '${ref.declaration.name}.${member.name}' cannot satisfy the setter required by abstract member '${target.owner.declaration.name}.${target.member.name}'.`,
+          related(
+            memberLocation(target),
+            "The settable abstract member is declared here."
+          )
+        );
+        continue;
+      }
       diagnose(
         diagnostics,
         ref.uri,
@@ -17281,7 +17307,7 @@ function memberCompatibility(implementation, implementationSubstitution, target,
     implementationSubstitution
   );
   const targetType = typeShape(target.member.type, target.substitution);
-  const targetAccessors = target.member.kind === "function" ? { get: false, set: false } : valueAccessors(target.member);
+  const targetAccessors = target.member.kind === "function" ? { get: false, set: false } : valueAccessors(target.member, environment);
   const permitsCovariantGetter = allowStoredInterfaceImplementation && implementationFamily === "value" && targetAccessors.get && !targetAccessors.set;
   const permitsStoredOverrideNullability = allowStoredOverrideNullability && implementation.kind === "field" && target.member.kind === "field" && typesEqual(
     { ...implementationType, nullable: false },
@@ -17291,7 +17317,7 @@ function memberCompatibility(implementation, implementationSubstitution, target,
     return `type '${formatType2(implementationType)}' does not match '${formatType2(targetType)}'`;
   }
   if (implementation.kind !== "function" || target.member.kind !== "function") {
-    const implementationAccessors = valueAccessors(implementation);
+    const implementationAccessors = valueAccessors(implementation, environment);
     if (targetAccessors.get && !implementationAccessors.get) {
       return "the implementation must provide a getter";
     }
@@ -17323,11 +17349,13 @@ function memberCompatibility(implementation, implementationSubstitution, target,
   }
   return null;
 }
-function valueAccessors(member) {
+function valueAccessors(member, environment) {
   if (member.kind === "field") {
+    const owner = environment.memberOwners.get(member);
+    const immutable = member.modifiers.includes("abstract") && owner !== void 0 && resolvedSourceMemberStorage(owner, member, environment) === "immutable";
     return {
       get: true,
-      set: !member.modifiers.includes("readonly")
+      set: !member.modifiers.includes("readonly") && !immutable
     };
   }
   if (member.kind === "function") return { get: false, set: false };
@@ -25142,15 +25170,18 @@ function assertMember2(value, path) {
       "must be null unless the member modifier is override."
     );
   }
+  if ((member.modifier === "abstract" || member.modifier === "abstractOverride") && member.defaultValue !== null) {
+    invalid(
+      `${path}.defaultValue`,
+      "must be null for an abstract member; concrete implementations own defaults."
+    );
+  }
   assertSystem(member.system, `${path}.system`);
   nullableStorage(member.storage, `${path}.storage`);
   nullableNonEmptyString(member.storageKey, `${path}.storageKey`);
   if (member.isReadOnly === true) {
     if (owner.kind !== "classMember" && owner.kind !== "sharedClassMember") {
-      invalid(
-        `${path}.isReadOnly`,
-        "is allowed only on a concrete class field."
-      );
+      invalid(`${path}.isReadOnly`, "is allowed only on a class field.");
     }
     if (member.isStatic === true) {
       invalid(`${path}.isReadOnly`, "cannot be combined with isStatic.");
@@ -25161,13 +25192,10 @@ function assertMember2(value, path) {
         `is not valid on value-less member kind ${JSON.stringify(kind)}.`
       );
     }
-    if (member.modifier === "abstract" || member.modifier === "abstractOverride") {
-      invalid(`${path}.isReadOnly`, "cannot be combined with abstract.");
-    }
-    if (member.storage !== "immutable") {
+    if (member.storage !== "immutable" && (member.storage !== null || member.overrideOf === null)) {
       invalid(`${path}.storage`, "must be immutable when isReadOnly is true.");
     }
-    if (member.defaultValue === null) {
+    if (member.defaultValue === null && member.modifier !== "abstract" && member.modifier !== "abstractOverride") {
       invalid(`${path}.defaultValue`, "is required when isReadOnly is true.");
     }
   }
@@ -28209,6 +28237,7 @@ function lowerMember(context, ownerClass, declaration, id2, owner) {
 }
 function memberCommon(context, ownerClass, declaration, id2, owner, base) {
   const storage = annotation(declaration.annotations, "storage");
+  const inheritedId = declaration.modifiers.includes("override") || declaration.modifiers.includes("sealed") ? base?.overrideOf ?? inheritedMemberId(context, ownerClass, declaration.name) : null;
   return {
     id: id2,
     source: sourceIdentity2(declaration, "member", declaration.name),
@@ -28225,12 +28254,41 @@ function memberCommon(context, ownerClass, declaration, id2, owner, base) {
     locked: hasAnnotation(declaration.annotations, "locked"),
     required: declaration.kind === "field" ? !declaration.type.nullable : base?.required ?? false,
     defaultValue: null,
-    overrideOf: declaration.modifiers.includes("override") || declaration.modifiers.includes("sealed") ? base?.overrideOf ?? inheritedMemberId(context, ownerClass, declaration.name) : null,
+    overrideOf: inheritedId,
     system: systemMetadata(declaration.annotations),
-    storage: storage ? storageValue(storage, "allowed") : null,
+    storage: storage ? storageValue(storage, "allowed") : declaration.modifiers.includes("readonly") ? base !== void 0 ? base.storage : inheritedId !== null && resolvedMemberStorage(context, inheritedId) === "immutable" ? "immutable" : null : null,
     storageKey: storage ? stringArgument(storage, "key") : null
   };
 }
+function resolvedMemberStorage(context, memberId, visited = /* @__PURE__ */ new Set()) {
+  if (visited.has(memberId)) return null;
+  visited.add(memberId);
+  const lowered = context.loweredMembers.get(memberId);
+  if (lowered?.storage !== null && lowered?.storage !== void 0) {
+    return lowered.storage;
+  }
+  const persisted = context.baseMembers.get(memberId);
+  if (persisted !== void 0) {
+    if (persisted.storage !== null) return persisted.storage;
+    if (persisted.overrideOf !== null) {
+      return resolvedMemberStorage(context, persisted.overrideOf, visited);
+    }
+  }
+  const sourcePlacement = context.sourceMembersById.get(memberId);
+  if (sourcePlacement !== void 0) {
+    const { ownerClass: sourceClass, member: sourceMember } = sourcePlacement;
+    const storage = annotation(sourceMember.annotations, "storage");
+    const localStorage = storage ? storageValue(storage, "allowed") : null;
+    if (localStorage !== null) return localStorage;
+    const inheritedId = inheritedMemberId(
+      context,
+      sourceClass,
+      sourceMember.name
+    );
+    return inheritedId === null ? null : resolvedMemberStorage(context, inheritedId, visited);
+  }
+  return null;
+}
 function lowerFieldMember(context, ownerClass, declaration, id2, commonInput, base) {
   const storedStatic = declaration.modifiers.includes("static") && !declaration.modifiers.includes("readonly");
   const settings = annotation(declaration.annotations, "settings");
@@ -29513,6 +29571,26 @@ function lowerProjectSchemaV4(base, analysis, options = {}) {
       )
     );
   }
+  const sourceClasses = new Map(
+    analysis.schema.classes.map((entry) => [
+      materializedId(entry, "class", entry.name),
+      entry
+    ])
+  );
+  const sourceMembersById = new Map(
+    analysis.schema.classes.flatMap(
+      (ownerClass) => ownerClass.members.map(
+        (member) => [
+          materializedId(
+            member,
+            "member",
+            `${ownerClass.name}.${member.name}`
+          ),
+          { ownerClass, member }
+        ]
+      )
+    )
+  );
   const context = {
     base,
     baseClasses: new Map(base.classes.map((entry) => [entry.id, entry])),
@@ -29520,12 +29598,8 @@ function lowerProjectSchemaV4(base, analysis, options = {}) {
     baseInterfaces: new Map(base.interfaces.map((entry) => [entry.id, entry])),
     baseEnums: new Map(base.enums.map((entry) => [entry.id, entry])),
     baseRelationsById: indexFirstById(base.internalRecordRelations),
-    sourceClasses: new Map(
-      analysis.schema.classes.map((entry) => [
-        materializedId(entry, "class", entry.name),
-        entry
-      ])
-    ),
+    sourceClasses,
+    sourceMembersById,
     classIdsByName,
     interfaceIdsByName,
     enumIdsByName,

package/package.json

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