@neocompose/cli 0.29.0 → 0.30.0

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## [0.30.0] - 2026-08-13
+
+### Added
+
+- P66 sealed classes: author a leaf type as `sealed class` in project source.
+  The modifier round-trips through pull and push, and the CLI rejects both
+  `sealed abstract` declarations and attempts to extend a sealed class.
+
+### Changed
+
+- Sealed classes are omitted from extends-position language completions, and
+  the project contract carries optional `isSealed` metadata. Absence and
+  explicit `false` are equivalent, so existing projects need no migration.
+- Unity export schema version is 20. Matching SDKs preserve the sealed
+  inheritance contract in generated C#.
+
 ## [0.29.0] - 2026-08-12
 
 ### Added

package/dist/neo.mjs

@@ -17376,7 +17376,7 @@ 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.10";
+    PROJECT_SCHEMA_MANIFEST_CONTRACT_VERSION = "3.11";
     PROJECT_FILE_UPLOAD_BATCH_SIZE = 32;
     NEO_PROJECT_SOURCE_RECORD_CONTRACT = {
       "recordFields": {
@@ -17437,6 +17437,7 @@ var init_project_schema_contract_generated = __esm({
           "extendsClassId",
           "implementsInterfaceIds",
           "hiddenInMemberSelector",
+          "isSealed",
           "isAbstract",
           "system",
           "allowedStorage",
@@ -26020,6 +26021,7 @@ function projectFallbackCompletions(analysis, document, position) {
   const expectedTypeName = construction?.expectedTypeName ?? recoveredInitializerType;
   const afterNew = expression && projectAfterNewAt(document, position);
   const typePosition = projectTypePositionAt(analysis, document, position);
+  const classBasePosition = projectClassBasePositionAt(document, position);
   const keywords = expression ? afterNew ? [] : ["new"] : typePosition ? [] : [
     "class",
     "interface",
@@ -26058,6 +26060,11 @@ function projectFallbackCompletions(analysis, document, position) {
       continue;
     }
     const isType = symbol.kind === "class" || symbol.kind === "interface" || symbol.kind === "enum" || symbol.kind === "genericParameter";
+    if (classBasePosition && symbol.kind === "class") {
+      const declaration = findTypeDeclaration(analysis, symbol.name);
+      if (declaration?.kind === "class" && declaration.modifiers.includes("sealed"))
+        continue;
+    }
     if (typePosition && !isType) continue;
     if (expression) {
       if (afterNew) {
@@ -26199,6 +26206,49 @@ function projectTypePositionAt(analysis, document, position) {
     line
   );
 }
+function projectClassBasePositionAt(document, position) {
+  const tokens = tokensBeforePosition(document.text, position);
+  let classIndex = -1;
+  for (let index = tokens.length - 1; index >= 0; index--) {
+    const text = tokens[index]?.text;
+    if (text === "class") {
+      classIndex = index;
+      break;
+    }
+    if (text === "{" || text === "}" || text === ";") return false;
+  }
+  if (classIndex < 0) return false;
+  let angleDepth = 0;
+  let parenthesisDepth = 0;
+  let bracketDepth = 0;
+  let colonIndex = -1;
+  for (let index = classIndex + 1; index < tokens.length; index++) {
+    const text = tokens[index]?.text;
+    if (text === "<") angleDepth++;
+    else if (text === ">") angleDepth = Math.max(0, angleDepth - 1);
+    else if (text === "(") parenthesisDepth++;
+    else if (text === ")") parenthesisDepth = Math.max(0, parenthesisDepth - 1);
+    else if (text === "[") bracketDepth++;
+    else if (text === "]") bracketDepth = Math.max(0, bracketDepth - 1);
+    else if (text === ":" && angleDepth === 0 && parenthesisDepth === 0 && bracketDepth === 0) {
+      colonIndex = index;
+      break;
+    } else if (text === "{" || text === "}" || text === ";") {
+      return false;
+    }
+  }
+  if (colonIndex < 0) return false;
+  angleDepth = 0;
+  for (let index = colonIndex + 1; index < tokens.length; index++) {
+    const text = tokens[index]?.text;
+    if (text === "<") angleDepth++;
+    else if (text === ">") angleDepth = Math.max(0, angleDepth - 1);
+    else if (angleDepth === 0 && (text === "(" || text === "{" || text === "}" || text === ";")) {
+      return false;
+    }
+  }
+  return true;
+}
 function sourceTypeAt(document, position) {
   const contains2 = (type) => {
     for (const argument2 of type.typeArguments) {
@@ -31520,6 +31570,7 @@ var init_document_contracts = __esm({
           "extendsClassId",
           "implementsInterfaceIds",
           "hiddenInMemberSelector",
+          "isSealed",
           "isAbstract",
           "system",
           "allowedStorage",
@@ -31534,6 +31585,7 @@ var init_document_contracts = __esm({
         derived: [],
         volatile: ["projectId", "createdAt", "updatedAt"],
         normalization: {
+          isSealed: "falseIsAbsent",
           targetMemberId: "nullIsAbsent",
           schemaKeyOrder: "nullIsAbsent",
           extendsClassId: "nullIsAbsent",
@@ -31802,6 +31854,10 @@ function normalizeDocumentFields(recordKind, value) {
       }
       continue;
     }
+    if (rule === "falseIsAbsent") {
+      if (current === false) delete normalized[field];
+      continue;
+    }
     const isFullMember = recordKind !== "member" || typeof normalized.extendsMemberId !== "string";
     if (recordKind === "member" && (current === void 0 || current === null) && rule.startsWith("missingIs") && !memberDefaultApplies(field, normalized.kind)) {
       if (current === null) delete normalized[field];
@@ -34399,6 +34455,7 @@ function schemaClassFromDocument(record3, context) {
     name: requiredString(data, "name", record3),
     ...optionalDocsTextProperty(data.docsText, record3),
     declarationModifier: data.isAbstract === true ? "abstract" : "concrete",
+    ...data.isSealed === void 0 ? {} : { isSealed: booleanValue(data.isSealed, record3, "isSealed") },
     schema: requiredRecord(data, "schema", record3),
     schemaKeyOrder: optionalStringArrayOrNull(data.schemaKeyOrder),
     extendsClassId: optionalStringOrNull(data.extendsClassId),
@@ -34434,6 +34491,7 @@ function schemaClassToDocument(schemaClass2) {
     implementsInterfaceIds: schemaClass2.implementsInterfaceIds,
     hiddenInMemberSelector: schemaClass2.hiddenInMemberSelector,
     isAbstract: schemaClass2.declarationModifier === "abstract",
+    isSealed: schemaClass2.isSealed,
     system: systemToDocument(schemaClass2.system),
     allowedStorage: schemaClass2.allowedStorage,
     allowedStorageKeys: schemaClass2.allowedStorageKeys,
@@ -35708,6 +35766,7 @@ function assertNeoSchemaClass(value, path) {
     ],
     [
       "docsText",
+      "isSealed",
       "constructorProjections",
       "constructorIds",
       "requiredConstructorId"
@@ -35723,6 +35782,9 @@ function assertNeoSchemaClass(value, path) {
   );
   stringRecord(type.schema, `${path}.schema`);
   nullableStringArray(type.schemaKeyOrder, `${path}.schemaKeyOrder`);
+  if (type.isSealed !== void 0) {
+    booleanAt(type.isSealed, `${path}.isSealed`);
+  }
   nullableNonEmptyString(type.extendsClassId, `${path}.extendsClassId`);
   stringArray(type.implementsInterfaceIds, `${path}.implementsInterfaceIds`);
   booleanAt(type.hiddenInMemberSelector, `${path}.hiddenInMemberSelector`);
@@ -39482,7 +39544,7 @@ function isNeoSchemaClassBase(value) {
   const v = value;
   return typeof v?.name === "string" && isValidDocsText(v.docsText) && isClassSchema(v?.schema) && isOptionalSchemaKeyOrder(v?.schemaKeyOrder) && (v.implementsInterfaceIds === void 0 || v.implementsInterfaceIds === null || Array.isArray(v.implementsInterfaceIds) && v.implementsInterfaceIds.every(
     (interfaceId) => typeof interfaceId === "string" && interfaceId.length > 0
-  )) && typeof v?.hiddenInMemberSelector === "boolean" && typeof v?.isAbstract === "boolean" && (v.allowedStorage === void 0 || v.allowedStorage === null || isEffectiveMemberStorage(v.allowedStorage)) && (v.allowedStorageKeys === void 0 || v.allowedStorageKeys === null || Array.isArray(v.allowedStorageKeys) && v.allowedStorageKeys.every((key) => typeof key === "string")) && (v.genericParams === void 0 || v.genericParams === null || Array.isArray(v.genericParams) && v.genericParams.every(isGenericParamDeclaration)) && (v.extendsGenericBindings === void 0 || v.extendsGenericBindings === null || isGenericBindingsRecord(v.extendsGenericBindings)) && (v.constructorProjections === void 0 || v.constructorProjections === null || Array.isArray(v.constructorProjections) && v.constructorProjections.every(isNeoClassConstructorProjection) && v.system?.kind === SystemProtectionKind.WorldAuthoring) && (v.constructorIds === void 0 || v.constructorIds === null || Array.isArray(v.constructorIds) && v.constructorIds.every(
+  )) && typeof v?.hiddenInMemberSelector === "boolean" && typeof v?.isAbstract === "boolean" && (v.isSealed === void 0 || typeof v.isSealed === "boolean") && (v.allowedStorage === void 0 || v.allowedStorage === null || isEffectiveMemberStorage(v.allowedStorage)) && (v.allowedStorageKeys === void 0 || v.allowedStorageKeys === null || Array.isArray(v.allowedStorageKeys) && v.allowedStorageKeys.every((key) => typeof key === "string")) && (v.genericParams === void 0 || v.genericParams === null || Array.isArray(v.genericParams) && v.genericParams.every(isGenericParamDeclaration)) && (v.extendsGenericBindings === void 0 || v.extendsGenericBindings === null || isGenericBindingsRecord(v.extendsGenericBindings)) && (v.constructorProjections === void 0 || v.constructorProjections === null || Array.isArray(v.constructorProjections) && v.constructorProjections.every(isNeoClassConstructorProjection) && v.system?.kind === SystemProtectionKind.WorldAuthoring) && (v.constructorIds === void 0 || v.constructorIds === null || Array.isArray(v.constructorIds) && v.constructorIds.every(
     (constructorId) => typeof constructorId === "string" && constructorId.length > 0
   ) && new Set(v.constructorIds).size === v.constructorIds.length) && (v.requiredConstructorId === void 0 || v.requiredConstructorId === null || typeof v.requiredConstructorId === "string" && v.requiredConstructorId.length > 0 && (v.constructorIds ?? []).length === 0) && (v.targetMemberId === void 0 || v.targetMemberId === null || typeof v.targetMemberId === "string" && v.targetMemberId.length > 0) && (v.system === void 0 || v.system === null || isSystemMetadata(v.system));
 }
@@ -46682,7 +46744,7 @@ function emitClass(context, schemaClass2, memberIds) {
     ...schemaClass2.system ? [systemAnnotation2(schemaClass2.system)] : [],
     ...relationsAnnotations(context, schemaClass2)
   ];
-  const modifier = schemaClass2.declarationModifier === "abstract" ? "abstract " : "";
+  const modifier = schemaClass2.isSealed ? "sealed " : schemaClass2.declarationModifier === "abstract" ? "abstract " : "";
   const generics = schemaClass2.genericParameters.length ? `<
 ${schemaClass2.genericParameters.map((parameter4) => {
     const constraint = parameter4.constraint ? ` extends ${parameter4.constraint.kind === "class" ? required(
@@ -53034,6 +53096,7 @@ function lowerClass(context, declaration) {
     name: declaration.name,
     ...declaration.docsText === void 0 ? {} : { docsText: declaration.docsText },
     declarationModifier: declaration.modifiers.includes("abstract") ? "abstract" : "concrete",
+    ...declaration.modifiers.includes("sealed") ? { isSealed: true } : {},
     schema,
     schemaKeyOrder: persistedSchemaOrder,
     extendsClassId,
@@ -77015,6 +77078,19 @@ function readClass(value) {
       throw new Error(`Class "${value.id}" schema value is invalid.`);
     }
   }
+  if (value.isSealed !== void 0 && typeof value.isSealed !== "boolean") {
+    throw new Error(`Class "${value.name}" (${value.id}) isSealed is invalid.`);
+  }
+  if (value.isAbstract !== void 0 && typeof value.isAbstract !== "boolean") {
+    throw new Error(
+      `Class "${value.name}" (${value.id}) isAbstract is invalid.`
+    );
+  }
+  if (value.isAbstract === true && value.isSealed === true) {
+    throw new Error(
+      `Class "${value.name}" (${value.id}) cannot be both abstract and sealed.`
+    );
+  }
   if (value.implementsInterfaceIds != null && (!Array.isArray(value.implementsInterfaceIds) || !value.implementsInterfaceIds.every((id2) => typeof id2 === "string"))) {
     throw new Error(`Class "${value.id}" implementsInterfaceIds is invalid.`);
   }
@@ -77287,6 +77363,14 @@ function assertProjectInterfaceDocumentValid(view, options = {}) {
   const classesById = new Map(
     classes.map((schemaClass2) => [schemaClass2.id, schemaClass2])
   );
+  for (const schemaClass2 of classes) {
+    if (schemaClass2.extendsClassId === void 0) continue;
+    const baseClass = classesById.get(schemaClass2.extendsClassId);
+    if (baseClass?.isSealed !== true) continue;
+    throw new Error(
+      `Class "${schemaClass2.name}" (${schemaClass2.id}) cannot extend sealed class "${baseClass.name}" (${baseClass.id}).`
+    );
+  }
   const genericParamConstraintsById = new Map(
     classes.flatMap(
       (schemaClass2) => (schemaClass2.genericParams ?? []).map(
@@ -104529,8 +104613,8 @@ var init_registry2 = __esm({
     "use strict";
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
       formatVersion: 3,
-      contractVersion: "3.10",
-      cliVersion: "0.29.0",
+      contractVersion: "3.11",
+      cliVersion: "0.30.0",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -104625,6 +104709,7 @@ var init_registry2 = __esm({
             "extendsClassId",
             "implementsInterfaceIds",
             "hiddenInMemberSelector",
+            "isSealed",
             "isAbstract",
             "system",
             "allowedStorage",
@@ -104639,6 +104724,7 @@ var init_registry2 = __esm({
           derived: [],
           volatile: ["projectId", "createdAt", "updatedAt"],
           normalization: {
+            isSealed: "falseIsAbsent",
             targetMemberId: "nullIsAbsent",
             schemaKeyOrder: "nullIsAbsent",
             extendsClassId: "nullIsAbsent",
@@ -111096,7 +111182,7 @@ There is no --keep-current: preserving current semantic state defines flatten.
 async function main() {
   const args = parseArgs(process.argv.slice(2));
   if (args.command === "--version") {
-    console.log("0.29.0");
+    console.log("0.30.0");
     return;
   }
   if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {

package/package.json

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

package/skills/neocompose-cli/SKILL.md

@@ -9,7 +9,7 @@ description: >-
   `@neocompose/cli` or `node cli/bin/neo.mjs` in the neo-compose repository.
 ---
 
-<!-- reviewed-through-cli: 0.29.0 -->
+<!-- reviewed-through-cli: 0.30.0 -->
 
 # Neo Compose CLI
 

package/skills/neocompose-cli/references/cli-development.md

@@ -83,7 +83,7 @@ wrappers.
 The marker near the top of `SKILL.md` must exactly match the package version:
 
 ```html
-<!-- reviewed-through-cli: 0.29.0 -->
+<!-- reviewed-through-cli: 0.30.0 -->
 ```
 
 The quoted version above is checked too, so this instruction cannot go stale

package/skills/neocompose-cli/references/declarations-and-construction.md

@@ -47,8 +47,17 @@ abstract class Item<TContext extends SomeClass> : INamed {
 ```
 
 Use ordinary `public`, `protected`, `private`, `static`, `virtual`, `abstract`,
-and `override` semantics. Interfaces are non-generic. Do not put `@id` on
-inferred list/dictionary type entries or on derived structural descriptors.
+`sealed`, and `override` semantics. A sealed class is an instantiable leaf:
+it may extend another class but cannot be extended, cannot also be abstract,
+and can only be sealed while it has no subclasses. Interfaces are non-generic.
+Do not put `@id` on inferred list/dictionary type entries or on derived
+structural descriptors.
+
+```neo
+sealed class DirtTile : PlaceableTile {
+  public bool IsWet = false;
+}
+```
 
 A bodyless function must be `abstract`, `native`, or an interface contract.
 `async` alone does not make it valid.