@neocompose/cli 0.31.15 → 0.31.17

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## [0.31.17] - 2026-08-18
+
+### Fixed
+
+- Accept runtime interface patterns on open Class hierarchies while retaining
+  impossible-pattern diagnostics for sealed Classes.
+- Recognize typed NeoScript setters as writable from initializers and function
+  bodies, including compound assignments, and compile their setter bodies.
+- Preserve `NeoVariant<T>` member types in the local manifest used by
+  `neo script check --all`, matching `neo test` candidate compilation.
+
+## [0.31.16] - 2026-08-18
+
+### Fixed
+
+- Resolve unordered List membership from entry `containerId` rows during
+  NeoScript evaluation, so root-backed indexes and collection operations see
+  stored entries in CLI tests, web previews, and world construction.
+
 ## [0.31.15] - 2026-08-18
 
 ### Fixed

package/dist/neo.mjs

@@ -8817,6 +8817,18 @@ function typesOverlap(left, right, project) {
   if (isNull(right)) return isNullable(left);
   if (isNeoScriptTypeAssignable(left, right, project) || isNeoScriptTypeAssignable(right, left, project))
     return true;
+  if (left.kind === "named" && right.kind === "named") {
+    const leftDeclaration = project.typeById.get(left.typeId);
+    const rightDeclaration = project.typeById.get(right.typeId);
+    if (leftDeclaration?.kind === "interface" && rightDeclaration?.kind === "interface") {
+      return true;
+    }
+    const classDeclaration = leftDeclaration?.kind === "class" ? leftDeclaration : rightDeclaration?.kind === "class" ? rightDeclaration : null;
+    const interfaceDeclaration = leftDeclaration?.kind === "interface" ? leftDeclaration : rightDeclaration?.kind === "interface" ? rightDeclaration : null;
+    if (classDeclaration !== null && interfaceDeclaration !== null) {
+      return classDeclaration.sealed !== true;
+    }
+  }
   return isNumeric(left) && isNumeric(right);
 }
 function isUnknown(type) {
@@ -24110,6 +24122,7 @@ function buildProjectGraph(documents) {
         ...interfaceTypeIds.length ? { interfaceTypeIds } : {},
         ...typeParameters.length ? { typeParameters } : {},
         ...classDeclaration?.modifiers.includes("abstract") ? { abstract: true } : {},
+        ...classDeclaration?.modifiers.includes("sealed") ? { sealed: true } : {},
         location: location(info.uri, info.declaration.range),
         selectionLocation: location(info.uri, info.declaration.nameRange)
       };
@@ -24612,10 +24625,23 @@ function accessorBodyRange(source, bodyRange, keyword) {
       continue;
     }
     if (depth !== 1 || token.text !== keyword) continue;
-    const open = tokens[index + 1];
+    let openIndex = index + 1;
+    if (tokens[openIndex]?.text === "(") {
+      let parameterDepth = 1;
+      for (let cursor = openIndex + 1; cursor < tokens.length; cursor++) {
+        const candidate = tokens[cursor];
+        if (candidate.text === "(") parameterDepth++;
+        if (candidate.text === ")") parameterDepth--;
+        if (parameterDepth !== 0) continue;
+        openIndex = cursor + 1;
+        break;
+      }
+      if (parameterDepth !== 0) return null;
+    }
+    const open = tokens[openIndex];
     if (open?.text !== "{") return null;
     let accessorDepth = 1;
-    for (let cursor = index + 2; cursor < tokens.length; cursor++) {
+    for (let cursor = openIndex + 1; cursor < tokens.length; cursor++) {
       const candidate = tokens[cursor];
       if (candidate.text === "{") accessorDepth++;
       if (candidate.text === "}") accessorDepth--;
@@ -31325,6 +31351,7 @@ function schemaClass(value, environment, field) {
       `${field}.implementsInterfaceIds`
     ),
     ...value.declarationModifier === "abstract" ? { abstract: true } : {},
+    ...value.isSealed === true ? { sealed: true } : {},
     ...sourceLocation(value.source, environment, `${field}.source`),
     typeParameters: records(
       value.genericParameters ?? [],
@@ -31945,6 +31972,20 @@ function memberType(member, environment, visiting, field) {
       nullable: false
     };
   }
+  if (kind === "variant") {
+    const variantClass = [...environment.classes.values()].find(
+      (candidate) => candidate.name === NEO_VARIANT_TYPE_NAME
+    );
+    if (variantClass === void 0) return { ...unknownType(), nullable };
+    return {
+      kind: "named",
+      typeId: string2(variantClass.id, `${field}.variantClass.id`),
+      typeArguments: [
+        manifestType2(member.targetType, environment, `${field}.targetType`)
+      ],
+      nullable
+    };
+  }
   if (kind === "generic") {
     return typeParameter(
       string2(member.genericParamId, `${field}.genericParamId`),
@@ -32487,6 +32528,7 @@ var init_project_schema_manifest = __esm({
     "use strict";
     init_project();
     init_project_schema_contract_generated();
+    init_language_spec();
   }
 });
 
@@ -46337,6 +46379,23 @@ var init_member_kinds_db_response = __esm({
 });
 
 // ../src/models/members/unordered-list-membership.ts
+function buildUnorderedListMembershipIndex(values) {
+  const membersByContainerId = /* @__PURE__ */ new Map();
+  for (const candidate of values) {
+    const containerId = candidate.containerId;
+    if (typeof containerId !== "string") continue;
+    const bucket = membersByContainerId.get(containerId);
+    if (bucket === void 0) {
+      membersByContainerId.set(containerId, [candidate.id]);
+    } else {
+      bucket.push(candidate.id);
+    }
+  }
+  for (const bucket of membersByContainerId.values()) {
+    bucket.sort();
+  }
+  return membersByContainerId;
+}
 function unorderedListEntryIds(values, listValue2, membershipIndex) {
   if (!Array.isArray(listValue2.value)) return [];
   if (membershipIndex !== void 0) {
@@ -63887,9 +63946,11 @@ function makeEvaluatorLookups(members, values, options = {}) {
   for (const a of members) attrMap.set(a.id, a);
   const valMap = /* @__PURE__ */ new Map();
   for (const v of values) valMap.set(v.id, v);
+  const unorderedListMembership = buildUnorderedListMembershipIndex(values);
   const lookups = {
     memberById: (id2) => attrMap.get(id2) ?? null,
-    valueById: (id2) => valMap.get(id2) ?? null
+    valueById: (id2) => valMap.get(id2) ?? null,
+    unorderedListEntryIds: (containerValueId) => unorderedListMembership.get(containerValueId) ?? []
   };
   if (options.includeValueGraphIndexes === true) {
     return {
@@ -67836,9 +67897,24 @@ function resolveValueIfIdForMember(at, member, ctx) {
   );
   if (!row) return at;
   ctx.valueDependencies?.add(row.id);
+  if (isMemberListBase(member) && member.listKind === "unordered" && Array.isArray(row.value)) {
+    return evaluatorUnorderedListEntryIds(row.id, ctx);
+  }
   const value = resolveLocalizedRowValueForMember(row, member, ctx);
   return shouldUnwrapSingleLookupValue(member) ? unwrapSingleLookupValue(value, ctx) : value;
 }
+function evaluatorUnorderedListEntryIds(containerValueId, ctx) {
+  const runtimeRows = [...ctx.__runtimeSessionValues?.values() ?? []];
+  const overlayRows = [...ctx.__valueOverlay?.values() ?? []];
+  const localRows = [...runtimeRows, ...overlayRows];
+  const shadowedIds = new Set(localRows.map((row) => row.id));
+  const baseIds = ctx.vm.databaseVM?.unorderedListEntryIds?.(containerValueId) ?? ctx.vm.values.filter((row) => row.containerId === containerValueId).map((row) => row.id);
+  const ids = new Set(baseIds.filter((id2) => !shadowedIds.has(id2)));
+  for (const row of localRows) {
+    if (row.containerId === containerValueId) ids.add(row.id);
+  }
+  return [...ids].sort();
+}
 function shouldUnwrapSingleLookupValue(member) {
   if (member === null) return false;
   if (!isMemberLookup(member)) return false;
@@ -71980,7 +72056,7 @@ function initializerEvaluatorLookups(document) {
   });
   return lookups;
 }
-function buildInitializerRootValue(document, lookups) {
+function buildInitializerRootValueWithLookups(document, lookups) {
   const rootValue = {};
   for (const { root, memberId } of projectRootMembersInDisplayOrder(
     document.project
@@ -72020,7 +72096,7 @@ function evaluateMemberInitializer(args) {
       databaseVM
     },
     thisValue: null,
-    rootValue: buildInitializerRootValue(args.document, databaseVM),
+    rootValue: buildInitializerRootValueWithLookups(args.document, databaseVM),
     saveStaticBindings: args.saveStaticBindings,
     sessionStaticBindings: args.sessionStaticBindings,
     ...args.storedConstructionReplay === true ? {
@@ -111630,7 +111706,7 @@ var init_registry2 = __esm({
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
       formatVersion: 3,
       contractVersion: "3.13",
-      cliVersion: "0.31.15",
+      cliVersion: "0.31.17",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -118225,7 +118301,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.31.15");
+    console.log("0.31.17");
     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.31.15",
+  "version": "0.31.17",
   "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.31.15 -->
+<!-- reviewed-through-cli: 0.31.17 -->
 
 # 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.31.15 -->
+<!-- reviewed-through-cli: 0.31.17 -->
 ```
 
 The quoted version above is checked too, so this instruction cannot go stale

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

@@ -56,6 +56,11 @@ or narrowing guard before the next access.
 
 Treat lookup-return values with the same nullable narrowing rules.
 
+Runtime declaration patterns follow the possible runtime type, not only the
+static declaration. An open Class value may match an otherwise unrelated
+interface through a derived Class that implements it; a sealed Class with no
+such relationship remains a compile-time impossible pattern.
+
 A declaration pattern introduced by `is` stays available after a guard when
 every path that falls through matched the pattern, including when the guard's
 other paths return from a nested block: