@neocompose/cli 0.89.8 → 0.89.10

package/dist/test-worker.mjs

@@ -25397,6 +25397,7 @@ function indexRuntimeCollectionChange(collection, entry, ctx, removedEntries = n
     indexes4.memberByRowId.clear();
   }
   if (Array.isArray(collection)) forgetLocalListIndexes(ctx, collection);
+  else indexes4.declaredListByArray = /* @__PURE__ */ new WeakMap();
   markOverlayMutated(ctx, collection);
   if (ctx.__valueOverlay instanceof LazyValueOverlay)
     indexes4.overlayRevision = ctx.__valueOverlay.revision;
@@ -29012,6 +29013,7 @@ function replaceRowValue(row, value, receiver, ctx) {
   unindexEvaluatorRow(indexes4, row, true);
   row.value = value;
   indexEvaluatorRow(indexes4, row, true);
+  indexes4.declaredListByArray = /* @__PURE__ */ new WeakMap();
   markOverlayMutated(ctx, receiver);
   if (ctx.__valueOverlay instanceof LazyValueOverlay)
     indexes4.overlayRevision = ctx.__valueOverlay.revision;
@@ -33268,6 +33270,17 @@ function runtimeTypeCheck(value, checkType, ctx, seenCollections = /* @__PURE__
     case 8 /* Enum */:
       return Array.isArray(value) && value.every((v) => typeof v === "string");
     case 7 /* Class */: {
+      if (isVariantClassId(checkType.classId)) {
+        if (!isVariantRefValue(value)) return false;
+        const targetParameter = evaluatorSchemaIndex(ctx).classesById.get(
+          checkType.classId
+        )?.genericParams?.[0];
+        const target = targetParameter === void 0 ? void 0 : receiverClosedTypeArguments(checkType.typeArguments, ctx)?.[targetParameter.id];
+        return target?.type !== 7 /* Class */ || evaluatorSchemaIndex(ctx).classIsOrExtends(
+          value.classId,
+          target.classId
+        );
+      }
       if (typeof value !== "object") return false;
       const row = trackedRowForValueReference(value, ctx);
       const runtimeClassId = row === null ? void 0 : classIdForValueRow(row, ctx);
@@ -38464,6 +38477,21 @@ function encodeRequiredConstructorArgument(args) {
       `Constructor argument '${args.parameterId}' has an unresolved generic type.`
     );
   }
+  if (args.typeInfo.type === 7 /* Class */ && isVariantClassId(args.typeInfo.classId)) {
+    if (args.value === null || args.value === void 0) return null;
+    const selection = readVariantSelection(
+      args.value,
+      `Constructor argument '${args.parameterId}'`
+    );
+    if (selection.rowValueId !== null) {
+      adoptTracked(selection.rowValueId, "variant-row");
+    }
+    return {
+      classId: selection.classId,
+      variantId: selection.variantId,
+      ...selection.rowValueId === null ? {} : { rowValueId: selection.rowValueId }
+    };
+  }
   if (args.typeInfo.type === 7 /* Class */ || args.typeInfo.type === 22 /* Interface */) {
     if (args.value === null || args.value === void 0) return null;
     const aggregateId2 = trackedId ?? replayedAggregateId;
@@ -38599,6 +38627,16 @@ function readVariantSelection(value, label) {
   }
   return { classId, variantId, rowValueId: rowValueId ?? null };
 }
+function variantConstructorRecord(row, schemaKeys) {
+  const recipe = isLiteralValueContent(row) ? row.constructorArgs : void 0;
+  const result = {};
+  if (recipe == null) return result;
+  for (let index = 0; index < schemaKeys.length; index++) {
+    const argument2 = recipe[`__arg_${index}__`];
+    if (argument2 !== void 0) result[schemaKeys[index]] = argument2;
+  }
+  return result;
+}
 function resolveVariantGraph(selection, ctx) {
   const variantId = selection.variantId;
   if (variantId === null) {
@@ -38636,20 +38674,14 @@ function resolveVariantGraph(selection, ctx) {
     );
   }
   const effectiveRoot = { ...root };
-  const recipe = row.constructorArgs;
-  if (typeof recipe === "object" && recipe !== null) {
-    const settledVariantSlots = [
-      ["Initialize", 0],
-      ["Apply", 1],
-      ["Overrides", 2],
-      ["ChildOverrides", 3]
-    ];
-    for (const [schemaKey, argumentIndex] of settledVariantSlots) {
-      if (effectiveRoot[schemaKey] !== void 0) continue;
-      const argument2 = recipe[`__arg_${argumentIndex}__`];
-      if (argument2 === void 0 || argument2 === null) continue;
-      effectiveRoot[schemaKey] = argument2;
-    }
+  const recipe = variantConstructorRecord(row, [
+    "Initialize",
+    "Apply",
+    "Overrides",
+    "ChildOverrides"
+  ]);
+  for (const [key, value] of Object.entries(recipe)) {
+    if (effectiveRoot[key] === void 0) effectiveRoot[key] = value;
   }
   return {
     variantId,
@@ -38744,7 +38776,7 @@ function invokeVariantClosure(args) {
     [DELEGATE_LEXICAL_THIS]: lexicalThis,
     [DELEGATE_LEXICAL_ROOT]: ctx.rootValue
   };
-  return invokeDelegateValue(bound, parameters, ctx);
+  return invokeDelegateValue(bound, parameters, ctx, void 0, lexicalThis);
 }
 function writeVariantOverrideSlot(target, schemaKey, value, ctx, answeredValueIds) {
   assertStoredReplayMutableValue(target, ctx, "variant override", schemaKey);
@@ -38940,6 +38972,32 @@ function replacesInterfaceSlotRow(member, target, overrideRow, ctx) {
   if (targetRow === null) return false;
   return classIdForValueRow(targetRow, ctx) !== overrideRow.classId;
 }
+function readVariantChildOverrideSlot(entryRow, schemaKey, ctx) {
+  const entry = readRowValue(entryRow, ctx);
+  if (typeof entry !== "object" || entry === null || Array.isArray(entry))
+    return null;
+  const classId = classIdForValueRow(entryRow, ctx);
+  const memberId = classId == null ? null : cachedMergedSchemaMemberId(classId, schemaKey, ctx);
+  const member = memberId === null ? null : evalMemberById(ctx.vm, memberId);
+  if (member === null) {
+    throw new NSGetterRuntimeError(
+      `Child override '${entryRow.id}' has no '${schemaKey}' member.`
+    );
+  }
+  const slot = readClassMember({
+    member,
+    schemaKey,
+    record: entry,
+    expandedRecord: () => variantConstructorRecord(entryRow, ["Selector", "Overrides"]),
+    mode: "runtime"
+  });
+  if (slot.kind === "value") return slot.value;
+  if (slot.kind === "declaration") {
+    const result = readDeclarationDefault(member, ctx);
+    return result.matched ? result.value : null;
+  }
+  return null;
+}
 function applyVariantDeclarativeHalves(instance, graph, ctx, answeredValueIds) {
   applyVariantPartial(
     instance,
@@ -38978,14 +39036,13 @@ function applyVariantDeclarativeHalves(instance, graph, ctx, answeredValueIds) {
         `Variant '${graph.name}' references missing child-override row '${entryId}'.`
       );
     }
-    const entry = entryRow.value;
+    const entry = readRowValue(entryRow, ctx);
     if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
       continue;
     }
-    const entryRecord = entry;
     const label = `Variant '${graph.name}' child override '${entryId}'`;
     const child = invokeVariantClosure({
-      closureValueId: entryRecord.Selector,
+      closureValueId: readVariantChildOverrideSlot(entryRow, "Selector", ctx),
       ctx,
       label: `${label} Selector`,
       lexicalThis: instance,
@@ -38998,7 +39055,7 @@ function applyVariantDeclarativeHalves(instance, graph, ctx, answeredValueIds) {
     }
     applyVariantPartial(
       child,
-      entryRecord.Overrides,
+      readVariantChildOverrideSlot(entryRow, "Overrides", ctx),
       ctx,
       label,
       answeredValueIds
@@ -39120,7 +39177,7 @@ function collectVariantDeclarativeAnsweredSlots(instance, graph, ctx) {
     }
     const label = `Variant '${graph.name}' child override '${entryId}'`;
     const child = invokeVariantClosure({
-      closureValueId: Reflect.get(entryRow.value, "Selector"),
+      closureValueId: readVariantChildOverrideSlot(entryRow, "Selector", ctx),
       ctx,
       label: `${label} Selector`,
       lexicalThis: instance,
@@ -39133,7 +39190,7 @@ function collectVariantDeclarativeAnsweredSlots(instance, graph, ctx) {
     }
     collectVariantPartialAnsweredSlots(
       child,
-      Reflect.get(entryRow.value, "Overrides"),
+      readVariantChildOverrideSlot(entryRow, "Overrides", ctx),
       ctx,
       label,
       slots
@@ -45504,22 +45561,29 @@ function lookupEntryTypeInfo2(member, collectionTypeInfo) {
 }
 
 // ../packages/neoscript-runtime/src/values/member-declared-type-info.ts
-function resolveMemberDeclaredTypeInfo(member, members2, ownerClass = null, env) {
+function resolveMemberDeclaredTypeInfo(member, members2, classes, ownerClass = null, env) {
   return resolveMemberDeclaredTypeInfoInternal(
     member,
     members2,
+    classes,
     /* @__PURE__ */ new Set(),
     ownerClass,
     env,
     ownerClass === null ? void 0 : classConstrainedGenerics([ownerClass])
   );
 }
-function resolveMemberDeclaredTypeInfoInternal(member, members2, seen, ownerClass, env, isClassConstrained) {
+function resolveMemberDeclaredTypeInfoInternal(member, members2, classes, seen, ownerClass, env, isClassConstrained) {
   const resolved = env === void 0 ? resolveMember(member, members2) : substituteMember(member, env, members2);
   const memberId = getField(resolved, "id");
   if (typeof memberId === "string" && seen.has(memberId)) return null;
   const nextSeen = typeof memberId === "string" ? /* @__PURE__ */ new Set([...seen, memberId]) : new Set(seen);
   if (isMemberNSPropertyBase(resolved)) return resolved.returnTypeInfo;
+  if (isMemberVariantBase(resolved)) {
+    return variantMemberDeclaredTypeInfo(
+      resolved,
+      neoVariantSystemClass(classes, resolved.valueTypeInfo != null)
+    );
+  }
   if (isClassSlotMember(resolved)) {
     const typeArguments = Object.fromEntries(
       Object.entries(declaredSlotArguments(resolved) ?? {}).flatMap(
@@ -45539,6 +45603,7 @@ function resolveMemberDeclaredTypeInfoInternal(member, members2, seen, ownerClas
           const argumentType2 = resolveMemberDeclaredTypeInfoInternal(
             argumentMember,
             members2,
+            classes,
             nextSeen,
             ownerClass,
             env,
@@ -45609,6 +45674,7 @@ function resolveMemberDeclaredTypeInfoInternal(member, members2, seen, ownerClas
       const typeInfo = resolveMemberDeclaredTypeInfoInternal(
         descriptor,
         members2,
+        classes,
         nextSeen,
         ownerClass,
         env,
@@ -45637,6 +45703,7 @@ function resolveMemberDeclaredTypeInfoInternal(member, members2, seen, ownerClas
     const entryTypeInfo = resolveMemberDeclaredTypeInfoInternal(
       entry,
       members2,
+      classes,
       nextSeen,
       ownerClass,
       env,
@@ -45661,6 +45728,7 @@ function resolveMemberDeclaredTypeInfoInternal(member, members2, seen, ownerClas
         return resolveMemberDeclaredTypeInfoInternal(
           collection,
           members2,
+          classes,
           nextSeen,
           ownerClass,
           env,
@@ -45703,6 +45771,15 @@ function recordEntries(value) {
   if (typeof value !== "object" || value === null) return [];
   return Object.values(value);
 }
+function isVariantArgument(value, typeInfo) {
+  return typeInfo?.type === 7 /* Class */ && isVariantClassId(typeInfo.classId) && isVariantRefValue(value);
+}
+function remapVariantArgument(value, typeInfo, remap) {
+  if (!isVariantArgument(value, typeInfo)) return value;
+  if (typeof value.rowValueId !== "string") return value;
+  const rowValueId = remap(value.rowValueId);
+  return rowValueId === value.rowValueId ? value : { ...value, rowValueId };
+}
 var MaterializedValueGraphContext = class _MaterializedValueGraphContext {
   /**
    * P79 §7a. Generic in the caller's document view so a pass typed against a
@@ -45939,7 +46016,7 @@ var MaterializedValueGraphContext = class _MaterializedValueGraphContext {
           const typeInfo = parameterTypes.get(parameterId);
           return [
             parameterId,
-            typeInfo !== void 0 && (isAggregateTypeInfo(typeInfo) || typeInfo.type === 29 /* Reference */) && typeof argument2 === "string" ? rewriteId(argument2) : argument2
+            typeInfo !== void 0 && (isAggregateTypeInfo(typeInfo) || typeInfo.type === 29 /* Reference */) && typeof argument2 === "string" ? rewriteId(argument2) : remapVariantArgument(argument2, typeInfo, rewriteId)
           ];
         }
       )
@@ -45975,15 +46052,18 @@ var MaterializedValueGraphContext = class _MaterializedValueGraphContext {
       ids.push(edge.targetValueId);
     return ids;
   }
-  /** The targets a row's Reference creation data names (P112 §1.1). */
+  /** Reference targets and bound lookup rows retained by creation data. */
   referenceArgumentIds(row) {
     if (!isLiteralValueContent(row)) return [];
     const args = row.constructorArgs;
     if (args === void 0 || args === null) return [];
     const ids = [];
-    for (const parameterId of this.referenceParameterIds(row)) {
+    for (const [parameterId, typeInfo] of this.constructorParameterTypes(row)) {
       const argument2 = args[parameterId];
-      if (typeof argument2 === "string") ids.push(argument2);
+      if (typeInfo.type === 29 /* Reference */ && typeof argument2 === "string")
+        ids.push(argument2);
+      else if (isVariantArgument(argument2, typeInfo) && typeof argument2.rowValueId === "string")
+        ids.push(argument2.rowValueId);
     }
     return ids;
   }
@@ -45992,23 +46072,23 @@ var MaterializedValueGraphContext = class _MaterializedValueGraphContext {
     const args = row.constructorArgs;
     if (args === void 0 || args === null) return args;
     let remapped;
-    for (const parameterId of this.referenceParameterIds(
+    for (const [parameterId, typeInfo] of this.constructorParameterTypes(
       row,
       contextualMember
     )) {
       const argument2 = args[parameterId];
-      if (typeof argument2 !== "string") continue;
-      const target = remap(argument2);
+      const target = typeInfo.type === 29 /* Reference */ && typeof argument2 === "string" ? remap(argument2) : remapVariantArgument(argument2, typeInfo, remap);
       if (target !== argument2) (remapped ??= { ...args })[parameterId] = target;
     }
     return remapped ?? args;
   }
-  *referenceParameterIds(row, contextualMember) {
-    for (const [parameterId, typeInfo] of this.constructorParameterTypes(
-      row,
-      contextualMember
-    ))
-      if (typeInfo.type === 29 /* Reference */) yield parameterId;
+  *variantArgumentSelections(row) {
+    if (!isLiteralValueContent(row)) return;
+    if (row.constructorArgs == null) return;
+    for (const [parameterId, typeInfo] of this.constructorParameterTypes(row)) {
+      const argument2 = row.constructorArgs[parameterId];
+      if (isVariantArgument(argument2, typeInfo)) yield argument2;
+    }
   }
   slotEntries(row) {
     const value = row.value;
@@ -46109,6 +46189,17 @@ var MaterializedValueGraphContext = class _MaterializedValueGraphContext {
       if (member === void 0) return null;
       return this.memberTypeInfo(member, env);
     }
+    if ((rawTypeInfo.type === 7 /* Class */ || rawTypeInfo.type === 22 /* Interface */) && rawTypeInfo.typeArguments !== void 0) {
+      const typeArguments = {};
+      for (const [parameterId, argument2] of Object.entries(
+        rawTypeInfo.typeArguments
+      )) {
+        const resolved = this.resolveTypeInfo(argument2, env);
+        if (resolved === null) return null;
+        typeArguments[parameterId] = resolved;
+      }
+      return { ...rawTypeInfo, typeArguments };
+    }
     if (rawTypeInfo.type === 30 /* Tuple */) {
       const elements = [];
       for (const element of rawTypeInfo.elements) {
@@ -46140,7 +46231,8 @@ var MaterializedValueGraphContext = class _MaterializedValueGraphContext {
       const member = substituteMember(rawMember, env, this.document.members);
       const typeInfo = resolveMemberDeclaredTypeInfo(
         member,
-        this.document.members
+        this.document.members,
+        this.document.classes
       );
       return typeInfo === null ? null : this.resolveTypeInfo(typeInfo, env);
     } catch {
@@ -46377,7 +46469,11 @@ function tryResolveTypeInfo(document2, rawTypeInfo, env) {
 function tryMemberTypeInfo(document2, rawMember, env) {
   try {
     const member = substituteMember(rawMember, env, document2.members);
-    const typeInfo = resolveMemberDeclaredTypeInfo(member, document2.members);
+    const typeInfo = resolveMemberDeclaredTypeInfo(
+      member,
+      document2.members,
+      document2.classes
+    );
     if (typeInfo === null) return null;
     return tryResolveTypeInfo(document2, typeInfo, env);
   } catch {
@@ -58921,11 +59017,97 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     if (callee.kind !== "member") return null;
     const isInitialize = callee.name === VARIANT_INITIALIZE_NAME;
     const isApply = callee.name === VARIANT_APPLY_NAME;
-    if (!isInitialize && !isApply) return null;
+    const isBind = callee.name === "Bind";
+    if (!isInitialize && !isApply && !isBind) return null;
     if (callee.receiver.kind === "ident" && !this.hasValueReceiver(callee.receiver.name, scope) && this.project.typeByName.has(callee.receiver.name)) {
       return null;
     }
     const receiver = receiverValue ? receiverValue() : this.resolveExpression(callee.receiver, scope);
+    if (isBind) {
+      const variantInfo2 = this.variantTypeInfo(receiver.type);
+      if (variantInfo2 === null) return null;
+      if (variantInfo2.valueType === null) {
+        throw new CompileError("Only a lookup variant can bind a row.", pos);
+      }
+      if (callee.optional === true) {
+        throw new CompileError("Bind requires a non-null lookup variant.", pos);
+      }
+      if (receiver.pointer.type !== "variant" /* Variant */) {
+        throw new CompileError(
+          "Bind requires a declared lookup variant path.",
+          pos
+        );
+      }
+      requireArgCount("NeoLookupVariant.Bind", argumentsList2, 1, pos);
+      const row2 = argumentsList2[0];
+      if (row2.kind !== "call") {
+        throw new CompileError(
+          'Bind requires Reference(id: "value-id").',
+          row2.pos
+        );
+      }
+      if (row2.callee.kind !== "ident" || row2.callee.name !== "Reference") {
+        throw new CompileError(
+          "Bind requires a Reference row argument.",
+          row2.pos
+        );
+      }
+      requireArgCount("Bind Reference", row2.args, 1, row2.pos);
+      if (row2.argumentNames?.[0] !== "id") {
+        throw new CompileError(
+          'Bind requires Reference(id: "value-id").',
+          row2.pos
+        );
+      }
+      const id = row2.args[0];
+      if (id.kind !== "litString") {
+        throw new CompileError(
+          "Bound row id must be a string literal.",
+          id.pos
+        );
+      }
+      if (id.value.length === 0) {
+        throw new CompileError("Bound row id must not be empty.", id.pos);
+      }
+      if (row2.typeArguments !== void 0) {
+        if (row2.typeArguments.length !== 1) {
+          throw new CompileError(
+            "Reference requires exactly one generic target type.",
+            row2.pos
+          );
+        }
+        this.requireAssignable(
+          this.resolveType(row2.typeArguments[0]),
+          variantInfo2.valueType,
+          row2.pos,
+          "Lookup variant row"
+        );
+      }
+      const rowType = this.context.persistedReferenceTypes?.get(id.value);
+      if (rowType !== void 0) {
+        this.requireAssignable(
+          neoScriptReadType(rowType),
+          variantInfo2.valueType,
+          row2.pos,
+          "Lookup variant row"
+        );
+      }
+      const bound = this.project.typeByName.get(NEO_VARIANT_TYPE_NAME);
+      if (bound === void 0) {
+        throw new CompileError(
+          `The seeded '${NEO_VARIANT_TYPE_NAME}' class is missing.`,
+          pos
+        );
+      }
+      return {
+        pointer: { ...receiver.pointer, rowValueId: id.value },
+        type: {
+          kind: "named",
+          typeId: bound.id,
+          typeArguments: receiver.type.kind === "named" ? receiver.type.typeArguments?.slice(0, 1) ?? [] : []
+        }
+      };
+    }
     if (isInitialize) {
       const variantInfo2 = this.variantTypeInfo(receiver.type);
       if (variantInfo2 === null) return null;
@@ -60827,6 +61009,33 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         typeArguments
       );
     }
+    if (callee.kind === "lambda" && expected !== void 0) {
+      rejectTypeArguments();
+      const parameterTypes = callee.params.map((parameter3) => {
+        if (parameter3.type === null) {
+          throw new CompileError(
+            "An immediately invoked lambda requires explicit parameter types.",
+            parameter3.pos
+          );
+        }
+        return this.resolveType(parameter3.type);
+      });
+      return this.resolveDelegateCall(
+        this.resolveDelegateLambda(
+          callee,
+          {
+            kind: "delegate",
+            parameterTypes,
+            returnType: expected
+          },
+          scope
+        ),
+        argumentsList2,
+        scope,
+        pos,
+        false
+      );
+    }
     const variantCall = this.resolveVariantCall(
       callee,
       argumentsList2,
@@ -71527,7 +71736,7 @@ function resolveAnalyzerMember(context, member) {
 }
 
 // ../src/runtime/neoscript/neoscript-language-context-adapter.ts
-var NEOSCRIPT_COMPILER_ADAPTER_REVISION = 6;
+var NEOSCRIPT_COMPILER_ADAPTER_REVISION = 8;
 var UNKNOWN_TYPE = {
   kind: "primitive",
   name: "unknown"
@@ -73817,6 +74026,7 @@ function compileMemberInitializerBody(args) {
   const returnTypeInfo = resolveMemberDeclaredTypeInfo(
     args.member,
     members2,
+    args.classes,
     args.thisClass
   );
   if (returnTypeInfo === null) {
@@ -73864,7 +74074,8 @@ function compileValueRowInitializerBody(args) {
   }
   const returnTypeInfo = resolveMemberDeclaredTypeInfo(
     args.member,
-    args.members
+    args.members,
+    args.classes
   );
   if (returnTypeInfo === null) {
     throw new Error(
@@ -73997,7 +74208,9 @@ function compilationProjectForDocument(document2, state) {
     classes: document2.classes,
     enums: document2.enums,
     interfaces: document2.interfaces,
-    constructors: document2.constructors ?? []
+    constructors: document2.constructors ?? [],
+    variants: document2.variants ?? [],
+    variantFolders: document2.variantFolders ?? []
   });
   return state.compilationProject;
 }
@@ -74093,6 +74306,8 @@ function compileValueInitializerDependency(document2, valueId, compilationProjec
     enums: document2.enums,
     interfaces: document2.interfaces,
     constructors: document2.constructors ?? [],
+    variants: document2.variants ?? [],
+    variantFolders: document2.variantFolders ?? [],
     member: site.member,
     valueRow: { ...site.row },
     valueId: site.row.id,
@@ -74111,7 +74326,9 @@ function compileMemberInitializerDependency(document2, memberId, compilationProj
     classes: document2.classes,
     enums: document2.enums,
     interfaces: document2.interfaces,
-    constructors: document2.constructors ?? []
+    constructors: document2.constructors ?? [],
+    variants: document2.variants ?? [],
+    variantFolders: document2.variantFolders ?? []
   };
   const memberIndex = documentMemberCompilationIndex(document2);
   const member = memberIndex.membersById.get(memberId);
@@ -86384,7 +86601,9 @@ function buildNeoScriptProject(document2) {
     classes: document2.classes,
     enums: document2.enums,
     interfaces: document2.interfaces,
-    constructors: document2.constructors ?? []
+    constructors: document2.constructors ?? [],
+    variants: document2.variants,
+    variantFolders: document2.variantFolders
   });
 }
 function neoScriptProjectFingerprint(document2) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neocompose/cli",
-  "version": "0.89.8",
+  "version": "0.89.10",
   "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.89.8 -->
+<!-- reviewed-through-cli: 0.89.10 -->
 
 # Neo Compose CLI
 

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

@@ -143,7 +143,7 @@ The marker near the top of `SKILL.md` must exactly match the package version,
 and this quoted copy is checked too:
 
 ```html
-<!-- reviewed-through-cli: 0.89.8 -->
+<!-- reviewed-through-cli: 0.89.10 -->
 ```
 
 Keep this skill on current behavior. Upgrade steps, rollout prerequisites,

package/skills/neocompose-cli/references/declarations/constructors.md

@@ -31,6 +31,26 @@ Foo value = new(bar: "BAR", isFun: true) { IsFun = false };
 - A header constructor disables implicit parameterless `new` and forbids
   other constructor overloads. Its derived identity takes no `@id`.
 
+## Variant parameters
+
+Constructors accept `NeoVariant<T>` and `NeoLookupVariant<T, TValue>` selections,
+including nullable selections and generic targets such as `NeoVariant<Kid<int>>`.
+A member initializer can retain the selection for each instance:
+
+```neo
+class Box : NeoObject {}
+class Made(NeoVariant<Box> selection) {
+  public NeoVariant<Box> Selection = selection;
+}
+Made value = new(Box.Variants.Base);
+```
+
+Push and export retain the selected variant and any bound lookup row for replay.
+`null` is an empty nullable selection; `Box.Variants.Base` selects the base class.
+To pass a bound lookup selection directly, use a declared variant path and a
+stored row ID, such as `new Made(Box.Variants.Seeds.BySeed.Bind(Reference(id: "row-id")))`.
+This compiles to a fixed selection; `Bind` does not evaluate a dynamic row expression.
+
 ## Declared constructors
 
 Declare overloadable constructors as members when each body owns its own

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

@@ -39,6 +39,9 @@ abstract class Item<TContext extends SomeClass> : INamed {
 The `@id`s above are pulled IDs. New declarations omit them; push assigns them.
 Never put `@id` on inferred list/dictionary entry types or derived structural
 descriptors.
+Generic bindings and their nested collection descriptors follow the owning
+declaration's identity. Deleting and recreating an idless declaration creates
+fresh bindings; retaining its pulled IDs preserves them.
 
 ## Modifiers
 

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

@@ -50,6 +50,8 @@ return this.Beds
   entries. Declared index lookups (`items.Index.Name[key]`) preserve the source
   entries' write permissions: writable fields can be updated through unique
   results or a bucket's entries, while bucket membership stays read-only.
+  Subsequent index lookups reflect writes to indexed fields, including writes
+  through `Where` results.
 
 ## Reductions
 

package/skills/neocompose-cli/references/neoscript/delegates-and-listeners.md

@@ -18,6 +18,8 @@ List<Item> ready = this.Items.Where((item) => item.Count > 0);
 - Call any non-null delegate expression directly: `callbacks[0](value)`,
   `(cond ? a : b)()`, `Factory.Make()()`. Force-unwrap a nullable one first:
   `callbacks["key"]!()`. Void delegates are statements only.
+- A typed lambda can be called immediately when its result has an expected
+  type: `int n = ((int x) => x + 1)(2);`. Declare each parameter's type.
 - Inside a class body, invoke delegate and action members directly:
   `Selector()`, `OnUpdated()`.