@neocompose/cli 0.89.8 → 0.89.9

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;
@@ -45504,22 +45532,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 +45574,7 @@ function resolveMemberDeclaredTypeInfoInternal(member, members2, seen, ownerClas
           const argumentType2 = resolveMemberDeclaredTypeInfoInternal(
             argumentMember,
             members2,
+            classes,
             nextSeen,
             ownerClass,
             env,
@@ -45609,6 +45645,7 @@ function resolveMemberDeclaredTypeInfoInternal(member, members2, seen, ownerClas
       const typeInfo = resolveMemberDeclaredTypeInfoInternal(
         descriptor,
         members2,
+        classes,
         nextSeen,
         ownerClass,
         env,
@@ -45637,6 +45674,7 @@ function resolveMemberDeclaredTypeInfoInternal(member, members2, seen, ownerClas
     const entryTypeInfo = resolveMemberDeclaredTypeInfoInternal(
       entry,
       members2,
+      classes,
       nextSeen,
       ownerClass,
       env,
@@ -45661,6 +45699,7 @@ function resolveMemberDeclaredTypeInfoInternal(member, members2, seen, ownerClas
         return resolveMemberDeclaredTypeInfoInternal(
           collection,
           members2,
+          classes,
           nextSeen,
           ownerClass,
           env,
@@ -45703,6 +45742,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 +45987,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 +46023,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 +46043,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 +46160,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 +46202,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 +46440,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 +58988,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 +60980,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 +71707,7 @@ function resolveAnalyzerMember(context, member) {
 }
 
 // ../src/runtime/neoscript/neoscript-language-context-adapter.ts
-var NEOSCRIPT_COMPILER_ADAPTER_REVISION = 6;
+var NEOSCRIPT_COMPILER_ADAPTER_REVISION = 7;
 var UNKNOWN_TYPE = {
   kind: "primitive",
   name: "unknown"
@@ -73817,6 +73997,7 @@ function compileMemberInitializerBody(args) {
   const returnTypeInfo = resolveMemberDeclaredTypeInfo(
     args.member,
     members2,
+    args.classes,
     args.thisClass
   );
   if (returnTypeInfo === null) {
@@ -73864,7 +74045,8 @@ function compileValueRowInitializerBody(args) {
   }
   const returnTypeInfo = resolveMemberDeclaredTypeInfo(
     args.member,
-    args.members
+    args.members,
+    args.classes
   );
   if (returnTypeInfo === null) {
     throw new Error(
@@ -73997,7 +74179,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 +74277,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 +74297,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 +86572,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.9",
   "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.9 -->
 
 # 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.9 -->
 ```
 
 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()`.
 

package/skills/neocompose-cli/references/values/identities.md

@@ -70,7 +70,6 @@ stored instance rather than building a copy. Its owning placement keeps it,
 so a constructor that stores it needs a `Reference` field:
 
 ```neo
-@id("86ac7c7d-8d3b-4642-9def-cdf32643bdc5")
 DeliveryQuest HARD_AS_STONE = new();
 // The core quest list owns HARD_AS_STONE.
 WorkflowStep UNLOCK = new QuestUnlockStep(HARD_AS_STONE);
@@ -82,13 +81,15 @@ class QuestUnlockStep(DeliveryQuest quest) : WorkflowStep {
 
 - The local needs exactly one owning placement. Unowned locals, ambiguous
   placements, and cycles are source errors.
-- A nested target needs its existing `@id`. A structurally owned list entry
-  may use an unused UUID-v4 in the same push.
-- A local nested inside an evaluated constructor stays idless on first push;
-  push assigns its identity before it can be referenced. Don't give it a fresh
-  UUID.
-- A direct static owner supplies a pending identity for an idless local, and
-  aliases of that static local work too.
+- New nested locals can be referenced before their first push or export, including
+  inside lists, dictionaries, and constructor-backed owners. Preparation resolves
+  each reference to the row its unique owner creates. Aliases share that identity.
+  Sibling constructor arguments and explicit `Reference(LOCAL)` calls reuse the
+  child within the same owning tree. A parent constructor may borrow a child
+  that one of its field overrides owns; pull preserves both uses.
+  Direct `Reference(LOCAL)` fields resolve after the owning constructor runs.
+- Push writes assigned IDs back to source. Dry-run and export prepare the same
+  references without requiring hand-written IDs or an earlier push.
 - A member default is a construction template, so its local is not a single
   stored instance.
 - Owned locals inside evaluated initializers need directly addressable fields,

package/skills/neocompose-cli/references/world/variants.md

@@ -44,6 +44,8 @@ frame. For editing an existing clip, see [frame overrides](animation.md).
 - Selections compare equal when class, variant, and bound lookup row match.
   An unset optional selection differs from `Base`.
 
+Variant selections can also be [constructor parameters](../declarations/constructors.md#variant-parameters). A constructor can retain a named, base, or bound lookup selection in a member initializer.
+
 ## Folders
 
 ```neo
@@ -112,8 +114,9 @@ NeoLookupVariant<ExampleObject, NeoSortingLayer> Layered = new(
 ## Type restrictions
 
 `NeoVariantFolder` and `NeoLookupVariantFolder` are top-level records, never
-member or parameter types. Variant handles are valid as Variant members only,
-not as collection entries, lookup targets, parameters, or generic bindings.
+member or parameter types. Variant handles are valid as Variant members and
+constructor parameters, not as collection entries, lookup targets, ordinary
+function parameters, or generic bindings.
 
 ## Stored overrides