@neocompose/cli 0.5.4 → 0.6.0

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## [0.6.0] - 2026-07-19
+
+### Added
+
+- Member access modifiers. Class and interface members now carry a required
+  `accessModifier` (`public` / `protected` / `private`); the source lowering
+  and emitter read and write the keyword, defaulting to `private` on classes
+  and `public` on interfaces when omitted, mirroring C#. The schema-commit
+  path enforces the same access rules as the web app.
+
 ## [0.5.4] - 2026-07-19
 
 ### Fixed

package/dist/neo.mjs

@@ -829,6 +829,7 @@ var init_document_contracts = __esm({
           "isStatic",
           "isVirtual",
           "isAbstract",
+          "accessModifierKind",
           "defaultValue",
           "extendsMemberId",
           "system",
@@ -1528,6 +1529,11 @@ function memberFromDocument(record3, members, owners, classNames, context) {
     owner: owners.get(record3.recordId) ?? { kind: "loose" },
     name: requiredString(data, "name", record3),
     isStatic: booleanValue(data.isStatic, record3, "isStatic"),
+    accessModifier: accessModifierValue(
+      data.accessModifierKind,
+      record3,
+      "accessModifierKind"
+    ),
     modifier,
     locked: booleanValue(field("locked", false), record3, "locked"),
     required: booleanValue(field("required", false), record3, "required"),
@@ -1770,7 +1776,8 @@ function memberToDocumentFields(member, baseData3) {
     kind,
     locked: member.locked,
     required: member.required,
-    isStatic: member.isStatic
+    isStatic: member.isStatic,
+    accessModifierKind: member.accessModifier
   };
   applyModifier(fields, member, baseData3);
   if (member.defaultValue !== null) {
@@ -2370,6 +2377,16 @@ function optionalNumberOrNull(value, record3, path) {
   if (value === void 0 || value === null) return null;
   return requiredNumberValue(value, record3, path);
 }
+function accessModifierValue(value, record3, path) {
+  if (value !== "public" && value !== "protected" && value !== "private") {
+    throw invalidDocument(
+      record3,
+      path,
+      "must be public, protected, or private"
+    );
+  }
+  return value;
+}
 function requiredString(value, key, record3) {
   return requiredStringValue(value[key], record3, key);
 }
@@ -2626,6 +2643,11 @@ function interfaceFromDocument(record3, context) {
       );
       const memberId = requiredString(member, "id", record3);
       const memberSource = nestedSource(source, "interfaceMember", memberId);
+      const accessModifier = accessModifierValue(
+        member.accessModifierKind,
+        record3,
+        `members.${name}.accessModifierKind`
+      );
       if (member.kind === "property") {
         return {
           id: memberId,
@@ -2641,6 +2663,7 @@ function interfaceFromDocument(record3, context) {
             record3,
             `members.${name}.settable`
           ),
+          accessModifier,
           source: memberSource
         };
       }
@@ -2664,6 +2687,7 @@ function interfaceFromDocument(record3, context) {
             record3,
             `members.${name}.deferred`
           ),
+          accessModifier,
           source: memberSource
         };
       }
@@ -2683,7 +2707,8 @@ function interfaceToDocument(neoInterface) {
         id: member.id,
         kind: "property",
         typeInfo: manifestTypeToDocument(member.type),
-        settable: member.settable
+        settable: member.settable,
+        accessModifierKind: member.accessModifier
       };
     } else {
       members[member.name] = {
@@ -2694,7 +2719,8 @@ function interfaceToDocument(neoInterface) {
           name: argument2.name,
           ...manifestTypeToDocument(argument2.type)
         })),
-        deferred: member.deferred
+        deferred: member.deferred,
+        accessModifierKind: member.accessModifier
       };
     }
   }
@@ -3480,6 +3506,9 @@ var init_language_spec = __esm({
       "interface",
       "native",
       "override",
+      "private",
+      "protected",
+      "public",
       "return",
       "sealed",
       "static",
@@ -3779,6 +3808,66 @@ function createProjectIndex(project) {
     indexesByListMemberId
   };
 }
+function memberAccessFailure(args) {
+  const access = args.symbol.accessModifier;
+  if (access === void 0) return null;
+  if (access === "public") return null;
+  const declaringTypeId = args.symbol.inheritedFrom?.typeId ?? args.owner.id;
+  const declaringTypeName = args.symbol.inheritedFrom?.typeName ?? args.owner.name;
+  const accessing = args.context.declaringType ?? args.context.thisClass;
+  const accessingTypeId = accessing?.kind === "named" ? accessing.typeId : void 0;
+  if (access === "private") {
+    if (accessingTypeId === declaringTypeId) return null;
+    return { kind: "private", declaringTypeName };
+  }
+  if (args.owner.kind === "interface") {
+    if (accessingTypeId !== void 0 && classFamilyImplementsInterface(
+      args.project,
+      accessingTypeId,
+      declaringTypeId
+    )) {
+      return null;
+    }
+    return { kind: "interfaceProtected", interfaceName: declaringTypeName };
+  }
+  if (accessingTypeId !== void 0 && typeExtendsInclusive(args.project, accessingTypeId, declaringTypeId)) {
+    return null;
+  }
+  return { kind: "protected", declaringTypeName };
+}
+function typeExtendsInclusive(project, typeId, ancestorTypeId) {
+  const visited = /* @__PURE__ */ new Set();
+  const queue = [typeId];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (current === ancestorTypeId) return true;
+    if (visited.has(current)) continue;
+    visited.add(current);
+    const type = project.typeById.get(current);
+    for (const baseTypeId of type?.baseTypeIds ?? []) queue.push(baseTypeId);
+  }
+  return false;
+}
+function classFamilyImplementsInterface(project, classTypeId, interfaceTypeId) {
+  const visitedClasses = /* @__PURE__ */ new Set();
+  const classQueue = [classTypeId];
+  while (classQueue.length > 0) {
+    const current = classQueue.shift();
+    if (visitedClasses.has(current)) continue;
+    visitedClasses.add(current);
+    const type = project.typeById.get(current);
+    if (type === void 0) continue;
+    for (const interfaceId of type.interfaceTypeIds ?? []) {
+      if (typeExtendsInclusive(project, interfaceId, interfaceTypeId)) {
+        return true;
+      }
+    }
+    for (const baseTypeId of type.baseTypeIds ?? []) {
+      classQueue.push(baseTypeId);
+    }
+  }
+  return false;
+}
 function withNullability(type, nullable) {
   return { ...type, nullable };
 }
@@ -4457,11 +4546,23 @@ function completionItemsForResolution(snapshot, resolved, word) {
     return resolved.staticType.members.filter((member) => member.kind === "enumMember").map((member) => symbolCompletion(member, word, snapshot));
   }
   if (resolved.staticType) {
-    return resolved.staticType.members.filter((member) => member.static === true).map((member) => symbolCompletion(member, word, snapshot));
-  }
-  return membersForType(snapshot, resolved.type).map(
-    (symbol) => symbolCompletion(symbol, word, snapshot)
-  );
+    const staticType = resolved.staticType;
+    return staticType.members.filter(
+      (member) => member.static === true && isMemberCompletionAccessible(snapshot, staticType, member)
+    ).map((member) => symbolCompletion(member, word, snapshot));
+  }
+  const owner = resolved.type.kind === "named" ? snapshot.project.typeById.get(resolved.type.typeId) : void 0;
+  return membersForType(snapshot, resolved.type).filter(
+    (symbol) => owner === void 0 || isMemberCompletionAccessible(snapshot, owner, symbol)
+  ).map((symbol) => symbolCompletion(symbol, word, snapshot));
+}
+function isMemberCompletionAccessible(snapshot, owner, symbol) {
+  return memberAccessFailure({
+    project: snapshot.project,
+    context: snapshot.context,
+    owner,
+    symbol
+  }) === null;
 }
 function membersForType(snapshot, type) {
   if (type.kind === "named") {
@@ -9808,6 +9909,7 @@ var init_strict_resolver = __esm({
                 pos
               );
             }
+            this.assertMemberAccessible(staticType, member, pos);
             if (member.static !== true) {
               throw new CompileError(
                 `Member '${staticType.name}.${name}' requires an instance receiver.`,
@@ -9960,6 +10062,7 @@ var init_strict_resolver = __esm({
               pos
             );
           }
+          this.assertMemberAccessible(type, member, pos);
           if (member.static === true) {
             throw new CompileError(
               `Static member '${type.name}.${name}' must be accessed through the type name, not an instance.`,
@@ -10281,6 +10384,7 @@ var init_strict_resolver = __esm({
                 pos
               );
             }
+            this.assertMemberAccessible(staticType, member, pos);
             if (member.static !== true) {
               throw new CompileError(
                 `Member '${staticType.name}.${callee.name}' requires an instance receiver.`,
@@ -10317,6 +10421,7 @@ var init_strict_resolver = __esm({
             (candidate) => (candidate.kind === "function" || candidate.kind === "method") && candidate.name === callee.name
           );
           if (member) {
+            if (type !== void 0) this.assertMemberAccessible(type, member, pos);
             if (member.static === true) {
               throw new CompileError(
                 `Static member '${type?.name}.${callee.name}' must be accessed through the type name, not an instance.`,
@@ -10867,6 +10972,7 @@ var init_strict_resolver = __esm({
               (candidate) => (candidate.kind === "function" || candidate.kind === "method") && candidate.name === memberName
             );
             if (!symbol2) return null;
+            this.assertMemberAccessible(staticType, symbol2, expression.pos);
             if (symbol2.static !== true) {
               throw new CompileError(
                 `Member '${staticType.name}.${memberName}' requires an instance receiver.`,
@@ -10908,6 +11014,9 @@ var init_strict_resolver = __esm({
           (candidate) => (candidate.kind === "function" || candidate.kind === "method") && candidate.name === memberName
         );
         if (!symbol) return null;
+        if (type !== void 0) {
+          this.assertMemberAccessible(type, symbol, expression.pos);
+        }
         if (symbol.static === true) {
           throw new CompileError(
             `Static member '${type?.name}.${memberName}' must be accessed through the type name, not an instance.`,
@@ -11285,6 +11394,36 @@ var init_strict_resolver = __esm({
       describe(type) {
         return formatType(type, this.project);
       }
+      /**
+       * Enforces C#-style member accessibility on a resolved member. Runs after
+       * the member is found so hover/definition still resolve while the strict
+       * compile carries the diagnostic.
+       */
+      assertMemberAccessible(owner, symbol, pos) {
+        const failure = memberAccessFailure({
+          project: this.project,
+          context: this.context,
+          owner,
+          symbol
+        });
+        if (failure === null) return;
+        if (failure.kind === "private") {
+          throw new CompileError(
+            `'${symbol.name}' is private to ${failure.declaringTypeName}.`,
+            pos
+          );
+        }
+        if (failure.kind === "interfaceProtected") {
+          throw new CompileError(
+            `'${symbol.name}' is protected; through an ${failure.interfaceName} reference it is accessible only from classes that implement ${failure.interfaceName} and their derived classes.`,
+            pos
+          );
+        }
+        throw new CompileError(
+          `'${symbol.name}' is protected; accessible only from ${failure.declaringTypeName} and derived classes.`,
+          pos
+        );
+      }
       symbolValue(symbol) {
         if (symbol.kind === "root" || symbol.kind === "parameter" || symbol.kind === "value") {
           return {
@@ -11307,6 +11446,13 @@ var init_strict_resolver = __esm({
         if (this.context.staticMember === true && symbol.static !== true) {
           return null;
         }
+        const accessFailure = memberAccessFailure({
+          project: this.project,
+          context: this.context,
+          owner,
+          symbol
+        });
+        if (accessFailure !== null) return null;
         return { owner, symbol };
       }
       nextCallSite(pos) {
@@ -12355,6 +12501,14 @@ var init_parity_contract = __esm({
 });
 
 // ../packages/neoscript-language/src/project-source-ast.ts
+function isNeoSourceAccessModifier(value) {
+  return value === "public" || value === "protected" || value === "private";
+}
+function effectiveSourceAccessModifier(modifiers, ownerKind) {
+  const explicit = modifiers.find(isNeoSourceAccessModifier);
+  if (explicit !== void 0) return explicit;
+  return ownerKind === "interface" ? "public" : "private";
+}
 var init_project_source_ast = __esm({
   "../packages/neoscript-language/src/project-source-ast.ts"() {
     "use strict";
@@ -12822,6 +12976,7 @@ function validateDeclarationSemantics(declarations, diagnostics) {
           message: `Member '${member.name}' repeats the '${modifier}' modifier.`
         });
       }
+      validateMemberAccessModifiers(declaration, member, diagnostics);
       if (member.kind !== "function") continue;
       if (declaration.kind === "interface") {
         if (member.body) {
@@ -12867,6 +13022,61 @@ function validateDeclarationSemantics(declarations, diagnostics) {
     }
   }
 }
+function validateMemberAccessModifiers(declaration, member, diagnostics) {
+  const accessModifiers = [
+    ...new Set(member.modifiers.filter(isNeoSourceAccessModifier))
+  ];
+  if (accessModifiers.length > 1) {
+    diagnostics.push({
+      range: member.nameRange,
+      severity: "error",
+      source: "neo-project",
+      code: "conflicting-access-modifiers",
+      message: `Member '${member.name}' declares more than one access modifier (${accessModifiers.join(", ")}); a member accepts at most one.`
+    });
+    return;
+  }
+  const accessModifier = accessModifiers[0];
+  if (accessModifier === void 0) return;
+  if (declaration.kind === "interface" && accessModifier === "private") {
+    diagnostics.push({
+      range: member.nameRange,
+      severity: "error",
+      source: "neo-project",
+      code: "private-interface-member",
+      message: `Interface member '${member.name}' cannot be private; private interface members are not yet supported. Use public or protected.`
+    });
+    return;
+  }
+  if (accessModifier !== "private") return;
+  if (member.modifiers.includes("virtual")) {
+    diagnostics.push({
+      range: member.nameRange,
+      severity: "error",
+      source: "neo-project",
+      code: "private-virtual-member",
+      message: `Member '${member.name}' cannot be both private and virtual; a private member is never overridable.`
+    });
+  }
+  if (member.modifiers.includes("abstract")) {
+    diagnostics.push({
+      range: member.nameRange,
+      severity: "error",
+      source: "neo-project",
+      code: "private-abstract-member",
+      message: `Member '${member.name}' cannot be both private and abstract; an abstract member exists to be implemented by descendants.`
+    });
+  }
+  if (member.modifiers.includes("override")) {
+    diagnostics.push({
+      range: member.nameRange,
+      severity: "error",
+      source: "neo-project",
+      code: "private-override-member",
+      message: `Member '${member.name}' cannot be both private and override; an override keeps the accessibility of the member it overrides, and a private member cannot be overridden.`
+    });
+  }
+}
 function isNameToken(token) {
   return token !== void 0 && (token.kind === "identifier" || token.kind === "type" || token.kind === "keyword");
 }
@@ -12902,12 +13112,16 @@ var init_project_source_parser = __esm({
     "use strict";
     init_lexer();
     init_neoflow_graph_parser();
+    init_project_source_ast();
     init_source_text();
     MODIFIERS = /* @__PURE__ */ new Set([
       "abstract",
       "async",
       "native",
       "override",
+      "private",
+      "protected",
+      "public",
       "sealed",
       "static",
       "virtual"
@@ -12945,6 +13159,14 @@ var init_project_source_parser = __esm({
         const annotations = this.parseAnnotations();
         const modifiers = this.parseModifiers();
         if (this.at("class")) {
+          const accessModifier = modifiers.find(isNeoSourceAccessModifier);
+          if (accessModifier !== void 0) {
+            throw this.failure(
+              "source-class-access-modifier",
+              `Access modifier '${accessModifier}' is valid only on class and interface member declarations, not on a class declaration.`,
+              start
+            );
+          }
           return this.parseClass(start, annotations, modifiers);
         }
         if (this.at("interface")) {
@@ -13545,6 +13767,7 @@ var init_project_schema_contract_generated = __esm({
           "isStatic",
           "isVirtual",
           "isAbstract",
+          "accessModifierKind",
           "defaultValue",
           "extendsMemberId",
           "system",
@@ -17356,6 +17579,10 @@ function sourceMemberSymbol(member, owner, typeIds, source) {
     type,
     static: staticMember,
     abstract: member.modifiers.includes("abstract"),
+    accessModifier: effectiveSourceAccessModifier(
+      member.modifiers,
+      owner.declaration.kind
+    ),
     location: location(owner.uri, member.range),
     selectionLocation: location(owner.uri, member.nameRange)
   };
@@ -17690,6 +17917,7 @@ var init_project_source_script_compiler = __esm({
     "use strict";
     init_compiler();
     init_language_spec();
+    init_project_source_ast();
     init_project();
     init_project_root();
     init_source_text();
@@ -18246,6 +18474,7 @@ function validateMembers(environment, diagnostics) {
       }
       for (const modifier of member.modifiers) {
         if (modifier === "async" && member.kind === "function") continue;
+        if (isNeoSourceAccessModifier(modifier)) continue;
         diagnose(
           diagnostics,
           ref.uri,
@@ -18899,6 +19128,7 @@ var init_project_source_type_checker = __esm({
   "../packages/neoscript-language/src/project-source-type-checker.ts"() {
     "use strict";
     init_language_spec();
+    init_project_source_ast();
     BUILTIN_ARITY = /* @__PURE__ */ new Map([
       ["List", 1],
       ["Set", 1],
@@ -24316,6 +24546,11 @@ function assertMember2(value, path) {
   assertMemberOwner(member.owner, `${path}.owner`);
   nonEmptyString(member.name, `${path}.name`);
   booleanAt(member.isStatic, `${path}.isStatic`);
+  stringIn(
+    member.accessModifier,
+    /* @__PURE__ */ new Set(["public", "protected", "private"]),
+    `${path}.accessModifier`
+  );
   stringIn(
     member.modifier,
     /* @__PURE__ */ new Set([
@@ -24746,12 +24981,14 @@ function assertInterfaceMember(value, path) {
       "name",
       "type",
       "settable",
+      "accessModifier",
       "source"
     ]);
     nonEmptyString(member.id, `${path}.id`);
     nonEmptyString(member.name, `${path}.name`);
     assertType2(member.type, `${path}.type`);
     booleanAt(member.settable, `${path}.settable`);
+    assertInterfaceMemberAccessModifier(member.accessModifier, path);
     assertSourceIdentity(member.source, `${path}.source`, "interfaceMember");
     return;
   }
@@ -24763,16 +25000,21 @@ function assertInterfaceMember(value, path) {
       "returnType",
       "arguments",
       "deferred",
+      "accessModifier",
       "source"
     ]);
     nonEmptyString(member.id, `${path}.id`);
     nonEmptyString(member.name, `${path}.name`);
     assertFunctionSignature(member, path);
+    assertInterfaceMemberAccessModifier(member.accessModifier, path);
     assertSourceIdentity(member.source, `${path}.source`, "interfaceMember");
     return;
   }
   invalid(`${path}.kind`, "must be property or function.");
 }
+function assertInterfaceMemberAccessModifier(value, path) {
+  stringIn(value, /* @__PURE__ */ new Set(["public", "protected"]), `${path}.accessModifier`);
+}
 function assertEnum2(value, path) {
   const neoEnum = objectAt(value, path, [
     "id",
@@ -25518,6 +25760,7 @@ var init_validate = __esm({
       "owner",
       "name",
       "isStatic",
+      "accessModifier",
       "modifier",
       "locked",
       "required",
@@ -27329,6 +27572,10 @@ function memberCommon(context, ownerClass, declaration, id2, owner, base) {
     owner,
     name: declaration.name,
     isStatic: declaration.modifiers.includes("static"),
+    // Non-class placements (collection entries, generic arguments, loose
+    // members) have no receiver type to scope visibility to; they are
+    // structurally public. Class schema entries apply the C# omission default.
+    accessModifier: owner.kind === "classMember" ? effectiveSourceAccessModifier(declaration.modifiers, "class") : "public",
     modifier: memberModifier2(declaration.modifiers, base?.modifier),
     locked: hasAnnotation(declaration.annotations, "locked"),
     required: declaration.kind === "field" ? !declaration.type.nullable : base?.required ?? false,
@@ -27546,6 +27793,10 @@ function lowerInterface(context, declaration) {
       `${declaration.name}.${member.name}`
     );
     const source = sourceIdentity2(member, "interfaceMember", member.name);
+    const accessModifier = effectiveSourceAccessModifier(
+      member.modifiers,
+      "interface"
+    );
     if (member.kind === "function") {
       return {
         id: memberId,
@@ -27559,6 +27810,7 @@ function lowerInterface(context, declaration) {
           selectionSpan: span(parameter3)
         })),
         deferred: member.modifiers.includes("async"),
+        accessModifier,
         source
       };
     }
@@ -27568,6 +27820,7 @@ function lowerInterface(context, declaration) {
       name: member.name,
       type: lowerType(context, member.type),
       settable: /\bset\s*;/.test(member.body ?? ""),
+      accessModifier,
       source
     };
   });
@@ -29066,11 +29319,12 @@ function emitInterface(context, value) {
     (interfaceId) => required(context.interfaces, interfaceId, "interface").name
   );
   const members = value.members.map((member) => {
+    const access = member.accessModifier === "public" ? "" : `${member.accessModifier} `;
     if (member.kind === "property") {
-      return `${id(member.id)}${renderType(context, member.type)} ${member.name} { get;${member.settable ? " set;" : ""} }`;
+      return `${id(member.id)}${access}${renderType(context, member.type)} ${member.name} { get;${member.settable ? " set;" : ""} }`;
     }
     const deferred = member.deferred ? "async " : "";
-    return `${id(member.id)}${deferred}${renderReturnType(context, member.returnType)} ${member.name}(${member.arguments.map(
+    return `${id(member.id)}${access}${deferred}${renderReturnType(context, member.returnType)} ${member.name}(${member.arguments.map(
       (argument2) => `${renderType(context, argument2.type)} ${argument2.name}`
     ).join(", ")});`;
   });
@@ -29135,9 +29389,10 @@ ${body ? `${signature} ${body}` : abstractContract ? `${signature};` : `native $
 ${prefix}${type} ${member.name}${initializer === null ? ";" : ` = ${initializer};`}`;
 }
 function memberModifier3(member) {
+  const accessPrefix = `${member.accessModifier} `;
   const staticPrefix = member.isStatic ? "static " : "";
   const modifier = member.modifier === "plain" ? "" : member.modifier === "abstractOverride" ? "abstract override " : member.modifier === "sealedOverride" ? "override " : `${member.modifier} `;
-  return `${staticPrefix}${modifier}`;
+  return `${accessPrefix}${staticPrefix}${modifier}`;
 }
 function renderExtendsGenericBindings(context, schemaClass2, base) {
   if (base.genericParameters.length === 0) return "";
@@ -33207,6 +33462,11 @@ var init_neoscript = __esm({
 });
 
 // ../src/models/members/member-kinds.ts
+function isMemberAccessModifierKind(value) {
+  if (value === "public") return true;
+  if (value === "protected") return true;
+  return value === "private";
+}
 function isValidCallableIdentifier(value) {
   if (typeof value !== "string") return false;
   if (!FunctionMemberNamePattern.test(value)) return false;
@@ -33650,6 +33910,7 @@ function isMemberBase(value) {
   if (typeof v.locked !== "boolean") return false;
   if (typeof v.required !== "boolean") return false;
   if (typeof v.isStatic !== "boolean") return false;
+  if (!isMemberAccessModifierKind(v.accessModifierKind)) return false;
   if (v.isVirtual !== void 0 && typeof v.isVirtual !== "boolean") {
     return false;
   }
@@ -33705,6 +33966,7 @@ function isMemberOverrideBase(value) {
   if (v.locked !== void 0 && typeof v.locked !== "boolean") return false;
   if (v.required !== void 0 && typeof v.required !== "boolean") return false;
   if (v.isStatic !== void 0 && v.isStatic !== false) return false;
+  if (!isMemberAccessModifierKind(v.accessModifierKind)) return false;
   if (v.isVirtual !== void 0 && typeof v.isVirtual !== "boolean") {
     return false;
   }
@@ -34212,6 +34474,9 @@ function substituteMember(member, env, members) {
       ...binding,
       name: resolved.name,
       locked: resolved.locked,
+      // Accessibility is a slot-owned declaration field — a binding member's
+      // modifier must not change the declaring slot's visibility.
+      accessModifierKind: resolved.accessModifierKind,
       system: resolved.system ?? void 0
     };
     const slotId = getOptionalString(member, "id");
@@ -35518,6 +35783,7 @@ function isNeoInterfaceMember(value) {
   if (value === null) return false;
   const member = value;
   if (typeof member.id !== "string" || member.id.length === 0) return false;
+  if (!isMemberAccessModifierKind(member.accessModifierKind)) return false;
   if (member.kind === "property") {
     if (!isNSTypeInfo(member.typeInfo)) return false;
     if (containsForbiddenMemberTypeInfo(member.typeInfo)) return false;
@@ -44882,6 +45148,29 @@ function migrateMemberStaticOwnership(data) {
   if (Object.prototype.hasOwnProperty.call(data, "isStatic")) return data;
   return { ...data, isStatic: false };
 }
+function migrateMemberAccessModifier(data) {
+  if (!isRecord5(data)) return data;
+  if (Object.prototype.hasOwnProperty.call(data, "accessModifierKind")) {
+    return data;
+  }
+  return { ...data, accessModifierKind: "public" };
+}
+function migrateInterfaceMemberAccessModifiers(data) {
+  if (!isRecord5(data)) return data;
+  const members = data.members;
+  if (!isRecord5(members)) return data;
+  let nextMembers = members;
+  for (const [memberKey, member] of Object.entries(members)) {
+    if (!isRecord5(member)) continue;
+    if (Object.prototype.hasOwnProperty.call(member, "accessModifierKind")) {
+      continue;
+    }
+    if (nextMembers === members) nextMembers = { ...members };
+    nextMembers[memberKey] = { ...member, accessModifierKind: "public" };
+  }
+  if (nextMembers === members) return data;
+  return { ...data, members: nextMembers };
+}
 function migrateProjectRecordData(args) {
   const currentVersion = CURRENT_PROJECT_RECORD_DATA_SCHEMA_VERSION[args.recordKind];
   if (args.dataSchemaVersion > currentVersion) {
@@ -45065,12 +45354,12 @@ var init_project_record_migrations = __esm({
     init_neoscript_call_receiver_migration();
     CURRENT_PROJECT_RECORD_DATA_SCHEMA_VERSION = {
       [ProjectRecordKind.Project]: 1,
-      [ProjectRecordKind.Member]: 4,
+      [ProjectRecordKind.Member]: 5,
       [ProjectRecordKind.Value]: 1,
       [ProjectRecordKind.Class]: 1,
       [ProjectRecordKind.InternalRecordRelation]: 1,
       [ProjectRecordKind.Enum]: 4,
-      [ProjectRecordKind.Interface]: 2,
+      [ProjectRecordKind.Interface]: 3,
       [ProjectRecordKind.Dialogue]: 5,
       [ProjectRecordKind.DialogueNode]: 4,
       [ProjectRecordKind.DialogueGroup]: 4,
@@ -45088,7 +45377,8 @@ var init_project_record_migrations = __esm({
       [ProjectRecordKind.Member]: {
         1: migrateGeneralFunctionCallIR,
         2: migrateMemberStaticOwnership,
-        3: migrateExplicitCallReceiverIR
+        3: migrateExplicitCallReceiverIR,
+        4: migrateMemberAccessModifier
       },
       [ProjectRecordKind.Value]: {},
       [ProjectRecordKind.Class]: {},
@@ -45096,7 +45386,9 @@ var init_project_record_migrations = __esm({
       [ProjectRecordKind.Enum]: {
         1: migrateEnumOptionKeyOrder
       },
-      [ProjectRecordKind.Interface]: {},
+      [ProjectRecordKind.Interface]: {
+        2: migrateInterfaceMemberAccessModifiers
+      },
       [ProjectRecordKind.Dialogue]: {
         1: migrateDialoguePrimaryLinkedValues,
         2: migrateGeneralFunctionCallIR,
@@ -53463,7 +53755,8 @@ function constructClassValue(info, scope, ctx) {
     classId,
     locked: false,
     required: true,
-    isStatic: false
+    isStatic: false,
+    accessModifierKind: "public"
   };
   const createdValues = [];
   const storageKeyDeclarations = /* @__PURE__ */ new Map();

package/package.json

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