@neocompose/cli 0.9.4 → 0.10.0

package/CHANGELOG.md

@@ -7,6 +7,20 @@
 - 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.10.0] - 2026-07-25
+
+### Added
+
+- Declare List indexes and column settings in source with `@index(member: ...)`
+  and `@column(member: ...)`. Both were already in the schema contract and
+  offered by the language server, but lowering carried them from the manifest
+  cache and the emitter never wrote them back, so a workspace that pushed
+  without `neo/obj/` silently lost them.
+- Declare a class hidden from the member selector and classes tree with
+  `@hidden`, the class-level counterpart to `@locked`. It maps to
+  `NeoSchemaClassAttribute.Hidden`, which the contract already carried; absent
+  means visible.
+
 ## [0.9.4] - 2026-07-25
 
 ### Fixed

package/README.md

@@ -141,8 +141,23 @@ abstract class InventoryItem<
 The source identifier is the persisted name. `@settings` and `@storage` are
 typed by their declaration context; invalid fields and enum cases are
 diagnostics. Swift-like `.EnumCase` syntax works whenever the expected enum
-type is known. Focused annotations such as `@id`, `@locked`, `@system`, and
-`@relations` carry cross-cutting behavior.
+type is known. Focused annotations such as `@id`, `@locked`, `@hidden`,
+`@system`, and `@relations` carry cross-cutting behavior. `@hidden` marks a
+class the member selector and classes tree leave out; absent means visible.
+
+Lists take repeatable `@index` and `@column` annotations naming a field on the
+entry class. An index requires a non-localizable `string` or a single-select
+enum; a column may also target the reserved `__other__` key, which carries the
+default layout for every field a subclass adds.
+
+```neo
+@id("outpost-list-id")
+@settings(kind: .Unordered)
+@index(member: Slug, unique: true)
+@column(member: Slug, width: 158, frozen: true)
+@column(member: Notes, hidden: true)
+public List<Outpost> Outposts = [];
+```
 
 Stable IDs preserve identity across rename, reorder, and file moves. Omit an
 `@id` only to create something. A successful real push assigns the ID and

package/dist/neo.mjs

@@ -14285,6 +14285,9 @@ function validateMember(uri, member, documentKind, ownerScope, environment, diag
     diagnostics
   );
   validateTypeAnnotations(uri, member.type, environment, diagnostics);
+  if (documentKind !== "flow") {
+    validateListAnnotations(uri, member, environment, diagnostics);
+  }
   const scope = new Map(ownerScope);
   if (member.kind === "function") {
     for (const parameter3 of member.parameters) {
@@ -14435,6 +14438,9 @@ function validateAnnotations(uri, annotations, context, environment, diagnostics
         continue;
       }
       seen.add(field.name);
+      if (field.name === "member" && (annotation2.name === "index" || annotation2.name === "column")) {
+        continue;
+      }
       validateExpressionText(
         uri,
         argument2.text,
@@ -14458,6 +14464,7 @@ function fieldsForAnnotation(name, context, environment) {
   if (name === "locked") {
     return context.kind === "member" || context.kind === "flowBinding" ? [] : null;
   }
+  if (name === "hidden") return context.kind === "class" ? [] : null;
   if (name === "settings") return settingsFields(context);
   if (name === "storage") return storageFields(context);
   if (name === "relations") return relationFields(context, environment);
@@ -15489,6 +15496,121 @@ function contextualAnnotationEnum(annotations, name, field) {
   const value = annotations.find((annotation2) => annotation2.name === name)?.arguments.find((argument2) => argument2.name === field)?.text.trim();
   return value?.startsWith(".") ? value.slice(1) : null;
 }
+function validateListAnnotations(uri, member, environment, diagnostics) {
+  const declared = member.annotations.filter(
+    (annotation2) => annotation2.name === "index" || annotation2.name === "column"
+  );
+  if (declared.length === 0) return;
+  const entryClass = listEntryClass(member.type, environment);
+  const seen = /* @__PURE__ */ new Set();
+  for (const annotation2 of declared) {
+    const target = memberKeyArgument(annotation2);
+    if (target === null) {
+      pushDiagnostic(
+        diagnostics,
+        uri,
+        annotation2.range,
+        "missing-list-annotation-member",
+        `@${annotation2.name} on '${member.name}' requires a member naming a field on the list entry, such as @${annotation2.name}(member: Name).`
+      );
+      continue;
+    }
+    if (target.key === null) {
+      pushDiagnostic(
+        diagnostics,
+        uri,
+        target.range,
+        "invalid-list-annotation-member",
+        `@${annotation2.name} on '${member.name}' must name a list entry field directly, such as @${annotation2.name}(member: Name).`
+      );
+      continue;
+    }
+    if (seen.has(`${annotation2.name} ${target.key}`)) {
+      pushDiagnostic(
+        diagnostics,
+        uri,
+        target.range,
+        "duplicate-list-annotation",
+        `@${annotation2.name}(member: ${target.key}) is declared more than once on '${member.name}'.`
+      );
+      continue;
+    }
+    seen.add(`${annotation2.name} ${target.key}`);
+    if (annotation2.name === "column" && target.key === LIST_COLUMN_INHERITANCE_KEY) {
+      continue;
+    }
+    if (entryClass === null) continue;
+    const field = resolveEntryField(entryClass, target.key, environment);
+    if (field === null) {
+      pushDiagnostic(
+        diagnostics,
+        uri,
+        target.range,
+        "unresolved-list-annotation-member",
+        `@${annotation2.name}(member: ${target.key}) on '${member.name}' does not resolve on list entry class '${entryClass.name}'.`
+      );
+      continue;
+    }
+    if (annotation2.name !== "index") continue;
+    const domainError = indexKeyDomainError(field, environment);
+    if (domainError !== null) {
+      pushDiagnostic(
+        diagnostics,
+        uri,
+        target.range,
+        "invalid-list-index-member",
+        `@index(member: ${target.key}) on '${member.name}' is invalid: ${domainError}.`
+      );
+    }
+  }
+}
+function memberKeyArgument(annotation2) {
+  const positional = annotation2.arguments[0];
+  const argument2 = annotation2.arguments.find((entry) => entry.name === "member") ?? (positional !== void 0 && positional.name === void 0 ? positional : void 0);
+  if (argument2 === void 0) return null;
+  const text = argument2.text.trim();
+  return {
+    key: IDENTIFIER_PATTERN2.test(text) ? text : null,
+    range: argument2.range
+  };
+}
+function listEntryClass(type, environment) {
+  if (type.name !== "List" && type.name !== "Set") return null;
+  const entry = type.typeArguments[0];
+  if (entry === void 0) return null;
+  return environment.types.get(entry.name) ?? null;
+}
+function resolveEntryField(entryClass, key, environment) {
+  const visited = /* @__PURE__ */ new Set();
+  let current = entryClass;
+  while (current !== void 0 && !visited.has(current.name)) {
+    visited.add(current.name);
+    const match = current.members.find((entry) => entry.name === key);
+    if (match !== void 0) return match;
+    current = current.baseTypes.map((base) => environment.types.get(base.name)).find((base) => base !== void 0);
+  }
+  return null;
+}
+function indexKeyDomainError(field, environment) {
+  if (field.kind !== "field") {
+    return `'${field.name}' is a ${field.kind}, and index keys require a stored field`;
+  }
+  if (field.type.name === "string") {
+    return annotationBoolean(field.annotations, "settings", "localizable") === false ? null : `'${field.name}' is localizable, and String index keys must be non-localizable`;
+  }
+  if (environment.enums.has(field.type.name)) return null;
+  const entry = field.type.typeArguments[0];
+  if (field.type.name === "List" && entry !== void 0 && environment.enums.has(entry.name) && annotationBoolean(field.annotations, "settings", "multiselect") === true) {
+    return `'${field.name}' is a multiselect Enum, and index keys require a single-select Enum`;
+  }
+  return `'${field.name}' is a ${field.type.name} field, and index keys require a non-localizable String or a single-select Enum`;
+}
+function annotationBoolean(annotations, name, field) {
+  const value = annotations.find((annotation2) => annotation2.name === name)?.arguments.find((argument2) => argument2.name === field)?.text.trim();
+  if (value === "true") return true;
+  if (value === "false") return false;
+  return null;
+}
 function isListContext(context) {
   return (context.kind === "member" || context.kind === "type") && (context.type.name === "List" || context.type.name === "Set");
 }
@@ -15533,7 +15655,7 @@ function pushDiagnostic(diagnostics, uri, range2, code, message) {
     message
   });
 }
-var primitiveType;
+var primitiveType, IDENTIFIER_PATTERN2, LIST_COLUMN_INHERITANCE_KEY;
 var init_project_source_semantics = __esm({
   "../packages/neoscript-language/src/project-source-semantics.ts"() {
     "use strict";
@@ -15542,6 +15664,8 @@ var init_project_source_semantics = __esm({
     init_strict_parser();
     init_project_root();
     primitiveType = (name) => ({ name });
+    IDENTIFIER_PATTERN2 = /^[A-Za-z_][A-Za-z0-9_]*$/;
+    LIST_COLUMN_INHERITANCE_KEY = "__other__";
   }
 });
 
@@ -21308,6 +21432,16 @@ function annotationSignatureParameters(name) {
       return ["relation descriptors"];
     case "incomplete":
       return ["string reason"];
+    case "index":
+      return ["entry member", "bool unique"];
+    case "column":
+      return [
+        "entry member",
+        "int width",
+        "bool hidden",
+        "bool frozen",
+        "bool wrapContent"
+      ];
     default:
       return null;
   }
@@ -28783,7 +28917,7 @@ function lowerClass(context, declaration) {
     schemaKeyOrder: persistedSchemaOrder,
     extendsClassId,
     implementsInterfaceIds,
-    hiddenInMemberSelector: base?.hiddenInMemberSelector ?? false,
+    hiddenInMemberSelector: hasAnnotation(declaration.annotations, "hidden"),
     system: systemMetadata(declaration.annotations),
     allowedStorage: storage ? storageValue(storage, "allowed") : null,
     // Class storage keys never exist in source. Retain only the historical
@@ -28800,6 +28934,11 @@ function lowerClass(context, declaration) {
   };
 }
 function lowerMember(context, ownerClass, declaration, id2, owner) {
+  const member = lowerMemberKind(context, ownerClass, declaration, id2, owner);
+  assertListAnnotationPlacement(ownerClass, declaration, member.kind);
+  return member;
+}
+function lowerMemberKind(context, ownerClass, declaration, id2, owner) {
   const base = context.baseMembers.get(id2);
   const common = memberCommon(
     context,
@@ -29139,8 +29278,8 @@ function lowerFieldMember(context, ownerClass, declaration, id2, commonInput, ba
       kind: "list",
       entryMemberId: entryId,
       listKind: contextualEnumArgument(settings, "kind") === "Unordered" ? "unordered" : "ordered",
-      indexes: base?.kind === "list" ? base.indexes : [],
-      columns: base?.kind === "list" ? base.columns : []
+      indexes: lowerListIndexes(ownerClass, declaration),
+      columns: lowerListColumns(ownerClass, declaration)
     };
   }
   if (name === "Dictionary") {
@@ -29210,6 +29349,70 @@ function lowerFieldMember(context, ownerClass, declaration, id2, commonInput, ba
     `Unsupported field type ${JSON.stringify(name)} on ${ownerClass.name}.${declaration.name}.`
   );
 }
+function lowerListIndexes(ownerClass, declaration) {
+  const declared = /* @__PURE__ */ new Set();
+  return declaration.annotations.filter((entry) => entry.name === "index").map((entry) => {
+    const schemaKey = memberKeyArgument2(entry, ownerClass, declaration);
+    if (declared.has(schemaKey)) {
+      throw new Error(
+        `@index(member: ${schemaKey}) is declared more than once on ${ownerClass.name}.${declaration.name}.`
+      );
+    }
+    declared.add(schemaKey);
+    return { schemaKey, unique: booleanArgument(entry, "unique") ?? false };
+  });
+}
+function lowerListColumns(ownerClass, declaration) {
+  const declared = /* @__PURE__ */ new Set();
+  return declaration.annotations.filter((entry) => entry.name === "column").map((entry) => {
+    const memberKey = memberKeyArgument2(entry, ownerClass, declaration);
+    if (declared.has(memberKey)) {
+      throw new Error(
+        `@column(member: ${memberKey}) is declared more than once on ${ownerClass.name}.${declaration.name}.`
+      );
+    }
+    declared.add(memberKey);
+    const width = numberArgument(entry, "width");
+    return {
+      memberKey,
+      // `-1` is the generated C# marker's "unset" sentinel for an int
+      // property that has no nullable form; the record spells that as null.
+      width: width === null || width === UNSET_LIST_COLUMN_WIDTH ? null : width,
+      hidden: booleanArgument(entry, "hidden") ?? false,
+      frozen: booleanArgument(entry, "frozen") ?? false,
+      wrapContent: booleanArgument(entry, "wrapContent") ?? false
+    };
+  });
+}
+function memberKeyArgument2(value, ownerClass, declaration) {
+  const positional = value.arguments[0];
+  const raw = argument(value, "member") ?? (positional !== void 0 && positional.name === void 0 ? positional.expression : null);
+  if (raw === null) {
+    throw new Error(
+      `@${value.name} on ${ownerClass.name}.${declaration.name} requires a member naming a field on the list entry, such as @${value.name}(member: Name).`
+    );
+  }
+  const expression = parseAnnotationExpression(raw);
+  if (expression.kind !== "ident") {
+    throw new Error(
+      `@${value.name}(member: ${raw.trim()}) on ${ownerClass.name}.${declaration.name} must name a list entry field directly, such as @${value.name}(member: Name).`
+    );
+  }
+  return expression.name;
+}
+function assertListAnnotationPlacement(ownerClass, declaration, loweredKind) {
+  if (loweredKind === "list") return;
+  if (hasAnnotation(declaration.annotations, "index")) {
+    throw new Error(
+      `@index on ${ownerClass.name}.${declaration.name} is only valid on a List member; this declaration lowers to a ${loweredKind} member.`
+    );
+  }
+  if (hasAnnotation(declaration.annotations, "column")) {
+    throw new Error(
+      `@column on ${ownerClass.name}.${declaration.name} is only valid on a List member; this declaration lowers to a ${loweredKind} member.`
+    );
+  }
+}
 function lowerCollectionEntry(context, ownerClass, entryType, entryId, parentMemberId) {
   if (context.loweredMembers.has(entryId)) return;
   const base = context.baseMembers.get(entryId);
@@ -30041,13 +30244,14 @@ function* zip(left, right) {
     yield [left[index], right[index]];
   }
 }
-var primitiveMemberKinds;
+var UNSET_LIST_COLUMN_WIDTH, primitiveMemberKinds;
 var init_lower_members = __esm({
   "src/project-source/lower-members.ts"() {
     "use strict";
     init_src();
     init_lower_support();
     init_ui_action_source();
+    UNSET_LIST_COLUMN_WIDTH = -1;
     primitiveMemberKinds = /* @__PURE__ */ new Set([
       "null",
       "bool",
@@ -30752,6 +30956,7 @@ ${namedArguments(
 function emitClass(context, schemaClass2, memberIds) {
   const annotations = [
     id(schemaClass2.id).trimEnd(),
+    ...schemaClass2.hiddenInMemberSelector ? ["@hidden"] : [],
     ...schemaClass2.allowedStorage ? [`@storage(allowed: .${enumCase(schemaClass2.allowedStorage)})`] : [],
     ...schemaClass2.system ? [systemAnnotation(schemaClass2.system)] : [],
     ...relationsAnnotations(context, schemaClass2)
@@ -30883,6 +31088,7 @@ function emitMember(context, member) {
       ].join(", ")})`
     ] : [],
     ...memberSettings(context, member),
+    ...listAnnotations(member),
     ...member.system ? [systemAnnotation(member.system)] : []
   ];
   const prefix = memberModifier3(member);
@@ -31024,6 +31230,28 @@ function memberSettings(context, member) {
   }
   return settings.length ? [`@settings(${settings.join(", ")})`] : [];
 }
+function listAnnotations(member) {
+  if (member.kind !== "list") return [];
+  return [
+    ...member.indexes.map((entry) => {
+      assertIdentifier(entry.schemaKey, "list index member");
+      return `@index(${[
+        `member: ${entry.schemaKey}`,
+        ...entry.unique ? ["unique: true"] : []
+      ].join(", ")})`;
+    }),
+    ...member.columns.map((entry) => {
+      assertIdentifier(entry.memberKey, "list column member");
+      return `@column(${[
+        `member: ${entry.memberKey}`,
+        ...entry.width === null ? [] : [`width: ${entry.width}`],
+        ...entry.hidden ? ["hidden: true"] : [],
+        ...entry.frozen ? ["frozen: true"] : [],
+        ...entry.wrapContent ? ["wrapContent: true"] : []
+      ].join(", ")})`;
+    })
+  ];
+}
 function renderMemberType(context, member) {
   const nullable = !member.required;
   let value;

package/package.json

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

package/skills/neocompose-cli/SKILL.md

@@ -196,8 +196,14 @@ abstract class InventoryItem<
 - `@settings(...)` and `@storage(...)` are context-aware typed contracts.
   Numeric limits are numeric literals. A class supports only
   `@storage(allowed: ...)`; storage keys are member-only.
-- Keep focused annotations such as `@locked`, `@system`, and `@relations`
-  separate from contextual settings.
+- Keep focused annotations such as `@locked`, `@hidden`, `@system`, and
+  `@relations` separate from contextual settings. `@hidden` is class-only and
+  hides the class from the member selector and classes tree; absent is visible.
+- `@index(member: Field, unique: ...)` and
+  `@column(member: Field, width: ..., hidden: ..., frozen: ..., wrapContent: ...)`
+  are repeatable List annotations. `member:` is a bare field name on the entry
+  class — an index needs a non-localizable `string` or a single-select enum,
+  and a column may also target the reserved `__other__` key.
 - `.EnumCase` works only when one expected enum type is known. Use explicit
   `EnumType.Case` when context is ambiguous.
 - Defaults and settings must be statically analyzable. Project source is parsed