@neocompose/cli 0.31.10 → 0.31.12

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## [0.31.12] - 2026-08-17
+
+### Fixed
+
+- Re-emit stored variant member selections through canonical
+  `<Class>.Variants...` paths, including variants nested in class and list
+  rows, instead of failing with an unsupported numeric value kind.
+
+## [0.31.11] - 2026-08-17
+
+### Fixed
+
+- Resolve lookup variants declared in root-path folders from member defaults
+  without adding an unaddressable empty path segment.
+- Allow stored static class rows to assign variant members with canonical
+  `<Class>.Variants...` selections.
+- Recognize nested value returns in variant `initialize` delegates and retain
+  declared `is` bindings after terminating guards.
+
 ## [0.31.10] - 2026-08-17
 
 ### Fixed

package/dist/neo.mjs

@@ -7482,6 +7482,42 @@ var init_strict_parser = __esm({
   }
 });
 
+// ../packages/neoscript-language/src/strict-ast.ts
+function collectReturnStatements(statements) {
+  const result = [];
+  for (const statement of statements) {
+    if (statement.kind === "return") result.push(statement);
+    if (statement.kind === "if") {
+      for (const branch of statement.branches) {
+        result.push(...collectReturnStatements(branch.body));
+      }
+      if (statement.elseBody) {
+        result.push(...collectReturnStatements(statement.elseBody));
+      }
+    }
+    if (statement.kind === "for" || statement.kind === "forEach") {
+      result.push(...collectReturnStatements(statement.body));
+    }
+    if (statement.kind === "switch") {
+      for (const section of statement.sections) {
+        result.push(...collectReturnStatements(section.body));
+      }
+    }
+    if (statement.kind === "try") {
+      result.push(...collectReturnStatements(statement.body));
+      for (const clause of statement.catches) {
+        result.push(...collectReturnStatements(clause.body));
+      }
+    }
+  }
+  return result;
+}
+var init_strict_ast = __esm({
+  "../packages/neoscript-language/src/strict-ast.ts"() {
+    "use strict";
+  }
+});
+
 // ../packages/neoscript-language/src/declared-constructors.ts
 function neoScriptArgumentNameSetKey(names) {
   return [...names].map((name) => name.toLowerCase()).sort().join(",");
@@ -8152,7 +8188,7 @@ function mergeFactSets(sets) {
   return first.filter(
     (fact) => sets.slice(1).every(
       (set) => set.some(
-        (candidate) => candidate.path === fact.path && candidate.nullValue === fact.nullValue && typeAnnotationsEqual(candidate.targetType, fact.targetType)
+        (candidate) => candidate.path === fact.path && candidate.nullValue === fact.nullValue && candidate.bindingName === fact.bindingName && candidate.loose === fact.loose && typeAnnotationsEqual(candidate.targetType, fact.targetType)
       )
     )
   );
@@ -9106,31 +9142,6 @@ function instructionsPropagatePastSwitch(instructions) {
   }
   return false;
 }
-function collectReturns(statements) {
-  const result = [];
-  for (const statement of statements) {
-    if (statement.kind === "return") result.push(statement);
-    if (statement.kind === "if") {
-      for (const branch of statement.branches)
-        result.push(...collectReturns(branch.body));
-      if (statement.elseBody)
-        result.push(...collectReturns(statement.elseBody));
-    }
-    if (statement.kind === "for" || statement.kind === "forEach") {
-      result.push(...collectReturns(statement.body));
-    }
-    if (statement.kind === "switch") {
-      for (const section of statement.sections)
-        result.push(...collectReturns(section.body));
-    }
-    if (statement.kind === "try") {
-      result.push(...collectReturns(statement.body));
-      for (const clause of statement.catches)
-        result.push(...collectReturns(clause.body));
-    }
-  }
-  return result;
-}
 function functionArityMessage(name, minimum, maximum, got) {
   if (minimum === maximum) {
     return `Function '${name}' expects ${maximum} argument${maximum === 1 ? "" : "s"}, got ${got}.`;
@@ -9192,6 +9203,7 @@ var init_strict_resolver = __esm({
     "use strict";
     init_project();
     init_language_spec();
+    init_strict_ast();
     init_strict_lexer();
     init_declared_constructors();
     init_strict_compile_error();
@@ -9595,6 +9607,7 @@ var init_strict_resolver = __esm({
           }
           case "if": {
             const cumulativeFalseFacts = [];
+            const branchExitFacts = [];
             const branchExitNarrowings = [];
             const branchExitOwnershipScopes = [];
             const branches = statement.branches.map((branch) => {
@@ -9603,12 +9616,14 @@ var init_strict_resolver = __esm({
                 branch.cond.pos
               );
               const child = new Scope(scope);
-              this.applyFactsToScope(scope, child, [
+              const branchFacts = [
                 ...cumulativeFalseFacts,
                 ...factsWhenTrue(branch.cond)
-              ]);
+              ];
+              this.applyFactsToScope(scope, child, branchFacts);
               const instructions = this.resolveStatements(branch.body, child);
               if (!instructionsTerminate(instructions)) {
+                branchExitFacts.push(branchFacts);
                 branchExitNarrowings.push(new Map(child.narrowedPaths));
                 branchExitOwnershipScopes.push(child);
               }
@@ -9624,12 +9639,14 @@ var init_strict_resolver = __esm({
               this.applyFactsToScope(scope, elseScope, cumulativeFalseFacts);
               otherwise = this.resolveStatements(statement.elseBody, elseScope);
               if (!instructionsTerminate(otherwise)) {
+                branchExitFacts.push([...cumulativeFalseFacts]);
                 branchExitNarrowings.push(new Map(elseScope.narrowedPaths));
                 branchExitOwnershipScopes.push(elseScope);
               }
             } else {
               const noBranchScope = new Scope(scope);
               this.applyFactsToScope(scope, noBranchScope, cumulativeFalseFacts);
+              branchExitFacts.push([...cumulativeFalseFacts]);
               branchExitNarrowings.push(new Map(noBranchScope.narrowedPaths));
               branchExitOwnershipScopes.push(noBranchScope);
             }
@@ -9645,6 +9662,12 @@ var init_strict_resolver = __esm({
               }
             }
             mergeBranchOwnership(scope, branchExitOwnershipScopes);
+            this.applyFactsToScope(
+              scope,
+              scope,
+              mergeFactSets(branchExitFacts),
+              "bindings-only"
+            );
             return {
               type: "if" /* If */,
               branches,
@@ -11468,8 +11491,9 @@ var init_strict_resolver = __esm({
           pos
         );
       }
-      applyFactsToScope(outerScope, targetScope, facts) {
+      applyFactsToScope(outerScope, targetScope, facts, mode = "all") {
         for (const fact of facts) {
+          if (mode === "bindings-only" && !fact.bindingName) continue;
           const rootEntry = outerScope.lookup(pathRoot(fact.path));
           if (!rootEntry) continue;
           const natural = this.resolveExpression(fact.expression, outerScope);
@@ -11490,8 +11514,13 @@ var init_strict_resolver = __esm({
             const naturalDefinition = natural.type.kind === "named" ? this.project.typeById.get(natural.type.typeId) : void 0;
             const retainConcreteClass = !fact.bindingName && naturalDefinition?.kind === "class" && targetDefinition?.kind === "interface";
             const narrowed = retainConcreteClass ? { ...natural.type, nullable: false } : { ...target, nullable: false };
-            targetScope.narrow(fact.path, rootEntry, narrowed);
+            if (mode === "all") {
+              targetScope.narrow(fact.path, rootEntry, narrowed);
+            }
             if (fact.bindingName) {
+              if (mode === "bindings-only" && targetScope.lookup(fact.bindingName) !== null) {
+                continue;
+              }
               targetScope.define({
                 name: fact.bindingName,
                 type: narrowed,
@@ -13763,7 +13792,7 @@ var init_strict_resolver = __esm({
         }
       }
       inferLambdaReturn(lambda, collection, source, outerScope) {
-        const returns = collectReturns(lambda.body);
+        const returns = collectReturnStatements(lambda.body);
         if (returns.length === 0) {
           throw new CompileError("Select lambda must return a value.", lambda.pos);
         }
@@ -20552,7 +20581,7 @@ function validateInitialize(variant, argument2, diagnostics) {
       )
     );
   }
-  const returns = lambda.body.some(
+  const returns = collectReturnStatements(lambda.body).some(
     (statement) => statement.kind === "return" && statement.expr !== null
   );
   if (returns) return;
@@ -20579,7 +20608,7 @@ function validateApply(variant, argument2, diagnostics) {
       )
     );
   }
-  const returnsValue = lambda.body.some(
+  const returnsValue = collectReturnStatements(lambda.body).some(
     (statement) => statement.kind === "return" && statement.expr !== null
   );
   if (!returnsValue) return;
@@ -20827,6 +20856,7 @@ var init_project_source_variants = __esm({
     init_generated_csharp_identifiers();
     init_language_spec();
     init_strict_parser();
+    init_strict_ast();
     NEO_VARIANT_CONSTRUCTOR_ARGUMENTS = [
       "initialize",
       "apply",
@@ -33083,13 +33113,6 @@ var init_service = __esm({
   }
 });
 
-// ../packages/neoscript-language/src/strict-ast.ts
-var init_strict_ast = __esm({
-  "../packages/neoscript-language/src/strict-ast.ts"() {
-    "use strict";
-  }
-});
-
 // ../packages/neoscript-language/src/strict-parity-fixture.ts
 function location2(uri, line, startCharacter, endCharacter) {
   return {
@@ -49611,6 +49634,93 @@ var init_structured_leaf_source = __esm({
   }
 });
 
+// src/project-source/variant-selection-source.ts
+function isObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function buildVariantPathsByIdV4(manifest) {
+  const variants = manifest.variants ?? [];
+  if (variants.length === 0) return /* @__PURE__ */ new Map();
+  const classNames = new Map(
+    manifest.classes.map((entry) => [entry.id, entry.name])
+  );
+  const folderPaths = new Map(
+    (manifest.variantFolders ?? []).map(
+      (entry) => [entry.id, entry.path]
+    )
+  );
+  const paths = /* @__PURE__ */ new Map();
+  for (const variant of variants) {
+    const className = classNames.get(variant.classId);
+    if (className === void 0) continue;
+    paths.set(
+      variant.id,
+      neoVariantDottedPath({
+        className,
+        folderPath: variant.folderId === null ? "" : folderPaths.get(variant.folderId) ?? "",
+        variantName: variant.name
+      })
+    );
+  }
+  return paths;
+}
+function renderVariantSelectionV4(context, memberName, value) {
+  if (value === null) return "null";
+  if (!isObject2(value)) {
+    throw new Error(
+      `Variant member ${memberName} stores ${JSON.stringify(value)}, which is not a { classId, variantId } selection.`
+    );
+  }
+  const variantId = value.variantId;
+  if (variantId === null) {
+    const classId = value.classId;
+    if (typeof classId !== "string") {
+      throw new Error(
+        `Variant member ${memberName} selects the base entry without naming a class.`
+      );
+    }
+    const className = context.classes.get(classId)?.name;
+    if (className === void 0) {
+      throw new Error(
+        `Variant member ${memberName} selects class ${JSON.stringify(classId)}, which this project does not declare.`
+      );
+    }
+    return neoVariantDottedPath({
+      className,
+      folderPath: "",
+      variantName: null
+    });
+  }
+  if (typeof variantId !== "string") {
+    throw new Error(
+      `Variant member ${memberName} stores a variant id that is neither a string nor null.`
+    );
+  }
+  const path = context.variantPathsById.get(variantId);
+  if (path === void 0) {
+    throw new Error(
+      `Variant member ${memberName} selects variant ${JSON.stringify(variantId)}, which this project does not declare.`
+    );
+  }
+  const rowValueId = value.rowValueId;
+  if (rowValueId === null || rowValueId === void 0) return path;
+  if (typeof rowValueId !== "string") {
+    throw new Error(
+      `Variant member ${memberName} stores a malformed rowValueId.`
+    );
+  }
+  const rootPath = context.collectionValuePaths.get(rowValueId);
+  const reference2 = rootPath === void 0 ? `Reference(id: ${quoteNeoString(rowValueId)})` : `Reference(${rootPath})`;
+  return `${path}.Bind(${reference2})`;
+}
+var init_variant_selection_source = __esm({
+  "src/project-source/variant-selection-source.ts"() {
+    "use strict";
+    init_src();
+    init_source_format();
+  }
+});
+
 // src/project-source/emitter.ts
 function emitProjectSourcesV4(manifest, options = {}) {
   const context = {
@@ -49626,7 +49736,7 @@ function emitProjectSourcesV4(manifest, options = {}) {
     defaultInitializers: options.defaultInitializers ?? /* @__PURE__ */ new Map(),
     fileSymbols: options.fileSymbols ?? /* @__PURE__ */ new Map(),
     collectionValuePaths: options.collectionValuePaths ?? /* @__PURE__ */ new Map(),
-    variantPathsById: buildVariantPathsById(manifest),
+    variantPathsById: buildVariantPathsByIdV4(manifest),
     templateNames: new Map(
       [...manifest.textureTemplates, ...manifest.audioTemplates].map(
         (template) => [template.id, template.name]
@@ -50502,7 +50612,7 @@ function renderDefault(context, member) {
   return renderDefaultValue(context, member, value);
 }
 function renderActionListeners(context, member, value) {
-  if (!isObject2(value)) {
+  if (!isObject3(value)) {
     throw new Error(
       `NeoAction member ${member.name} stores a default that is not a listener set.`
     );
@@ -50514,7 +50624,7 @@ function renderActionListeners(context, member, value) {
     );
   }
   const names = listeners.map((listener, index) => {
-    if (!isObject2(listener)) {
+    if (!isObject3(listener)) {
       throw new Error(
         `NeoAction member ${member.name} listener ${index} is not a member target.`
       );
@@ -50575,7 +50685,7 @@ function renderDefaultValue(context, member, wrapper) {
     const entry = required(context.members, member.entryMemberId, "list entry");
     return `[${value.map((item) => renderNestedValue(context, entry, item)).join(", ")}]`;
   }
-  if (member.kind === "dictionary" && isObject2(value)) {
+  if (member.kind === "dictionary" && isObject3(value)) {
     const entry = required(
       context.members,
       member.entryMemberId,
@@ -50585,7 +50695,7 @@ function renderDefaultValue(context, member, wrapper) {
       ([key, item]) => `${quote(key)}: ${renderNestedValue(context, entry, item)}`
     ).join(", ")} }`;
   }
-  if (member.kind === "class" && isObject2(value)) {
+  if (member.kind === "class" && isObject3(value)) {
     const target = required(context.classes, member.classId, "class");
     const assignments = Object.entries(value).map(([key, item]) => {
       const childId = target.schema[key];
@@ -50602,9 +50712,9 @@ function renderDefaultValue(context, member, wrapper) {
     return renderActionListeners(context, member, value);
   }
   if (member.kind === "variant") {
-    return renderVariantSelection(context, member, value);
+    return renderVariantSelectionV4(context, member.name, value);
   }
-  if (member.kind === "functionRef" && isObject2(value) && typeof value.functionMemberId === "string") {
+  if (member.kind === "functionRef" && isObject3(value) && typeof value.functionMemberId === "string") {
     return required(
       context.members,
       value.functionMemberId,
@@ -50640,7 +50750,7 @@ function renderDefaultValue(context, member, wrapper) {
     return `new { ${assignments.join(", ")} }`;
   }
   if (member.kind === "sprite" || member.kind === "audio") {
-    if (!isObject2(value)) return jsonValue2(value);
+    if (!isObject3(value)) return jsonValue2(value);
     if (typeof value.fileId !== "string") {
       throw new Error(
         `${member.kind === "sprite" ? "Sprite" : "Audio"} member ${JSON.stringify(member.name)} default stores a file value with no fileId. Emitting it as null would delete the default on the next push.`
@@ -50659,7 +50769,7 @@ function renderDefaultValue(context, member, wrapper) {
     const target = symbol ?? (member.kind === "sprite" ? `Reference<NeoImage>(id: ${quote(value.fileId)})` : `Reference<NeoAudioClip>(id: ${quote(value.fileId)})`);
     return member.kind === "sprite" ? `${target}.Slice(${typeof value.sliceIndex === "number" ? value.sliceIndex : 0})` : target;
   }
-  if (leafKind !== null && isObject2(value)) {
+  if (leafKind !== null && isObject3(value)) {
     return `new(${structuredLeafFieldKeys(leafKind).map((key) => jsonValue2(value[key])).join(", ")})`;
   }
   return jsonValue2(value);
@@ -50954,7 +51064,7 @@ function jsonValue2(value) {
   if (typeof value === "boolean") return String(value);
   if (value === null || value === void 0) return "null";
   if (Array.isArray(value)) return `[${value.map(jsonValue2).join(", ")}]`;
-  if (isObject2(value))
+  if (isObject3(value))
     return `{ ${Object.entries(value).map(([key, entry]) => `${quote(key)}: ${jsonValue2(entry)}`).join(", ")} }`;
   throw new Error(`Cannot emit Neo value ${String(value)}.`);
 }
@@ -51159,81 +51269,9 @@ function required(map, key, kind) {
   if (!value) throw new Error(`Unknown ${kind} ${quote(key)}.`);
   return value;
 }
-function isObject2(value) {
+function isObject3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function buildVariantPathsById(manifest) {
-  if (manifest.variants.length === 0) return /* @__PURE__ */ new Map();
-  const classNames = new Map(
-    manifest.classes.map((entry) => [entry.id, entry.name])
-  );
-  const folderPaths = new Map(
-    manifest.variantFolders.map((entry) => [entry.id, entry.path])
-  );
-  const paths = /* @__PURE__ */ new Map();
-  for (const variant of manifest.variants) {
-    const className = classNames.get(variant.classId);
-    if (className === void 0) continue;
-    paths.set(
-      variant.id,
-      neoVariantDottedPath({
-        className,
-        folderPath: variant.folderId === null ? "" : folderPaths.get(variant.folderId) ?? "",
-        variantName: variant.name
-      })
-    );
-  }
-  return paths;
-}
-function renderVariantSelection(context, member, value) {
-  if (value === null) return "null";
-  if (!isObject2(value)) {
-    throw new Error(
-      `Variant member ${member.name} stores ${JSON.stringify(value)}, which is not a { classId, variantId } selection.`
-    );
-  }
-  const variantId = value.variantId;
-  if (variantId === null) {
-    const classId = value.classId;
-    if (typeof classId !== "string") {
-      throw new Error(
-        `Variant member ${member.name} selects the base entry without naming a class.`
-      );
-    }
-    const className = context.classes.get(classId)?.name;
-    if (className === void 0) {
-      throw new Error(
-        `Variant member ${member.name} selects class ${JSON.stringify(classId)}, which this project does not declare.`
-      );
-    }
-    return neoVariantDottedPath({
-      className,
-      folderPath: "",
-      variantName: null
-    });
-  }
-  if (typeof variantId !== "string") {
-    throw new Error(
-      `Variant member ${member.name} stores a variant id that is neither a string nor null.`
-    );
-  }
-  const path = context.variantPathsById.get(variantId);
-  if (path === void 0) {
-    throw new Error(
-      `Variant member ${member.name} selects variant ${JSON.stringify(variantId)}, which this project does not declare.`
-    );
-  }
-  const rowValueId = value.rowValueId;
-  if (rowValueId === null || rowValueId === void 0) return path;
-  if (typeof rowValueId !== "string") {
-    throw new Error(
-      `Variant member ${member.name} stores a malformed rowValueId.`
-    );
-  }
-  const rootPath = context.collectionValuePaths.get(rowValueId);
-  const reference2 = rootPath === void 0 ? `Reference(id: ${quote(rowValueId)})` : `Reference(${rootPath})`;
-  return `${path}.Bind(${reference2})`;
-}
 var SPECIALIZED_RELATION_PROPERTIES;
 var init_emitter = __esm({
   "src/project-source/emitter.ts"() {
@@ -51244,6 +51282,7 @@ var init_emitter = __esm({
     init_class_generics();
     init_members();
     init_structured_leaf_source();
+    init_variant_selection_source();
     SPECIALIZED_RELATION_PROPERTIES = /* @__PURE__ */ new Map([
       ["world.grid.tile-import", { property: "tileImports", collection: true }],
       ["world.grid.object-import", { property: "objectImports", collection: true }],
@@ -58785,6 +58824,285 @@ var init_lower_members = __esm({
   }
 });
 
+// src/project-source/lower-variants.ts
+function lowerVariants(context, analysis) {
+  const folders = lowerVariantFolders(context, analysis);
+  const foldersBySymbol = new Map(
+    analysis.variants.globals.filter((global) => isNeoVariantFolderTypeName(global.type.name)).map(
+      (global) => [
+        folderSymbolKey(owningClassName(global), global.name),
+        variantRecordId(global, global.type.name)
+      ]
+    )
+  );
+  const variants = variantGlobals(analysis).map((global) => {
+    const className = owningClassName(global);
+    const classId = requiredName2(context.classIdsByName, className, "class");
+    const variantId = variantRecordId(global, global.type.name);
+    return {
+      id: variantId,
+      source: sourceIdentity2(global, "variant", global.name),
+      classId,
+      name: global.name,
+      folderId: variantFolderId2(global, className, foldersBySymbol),
+      valueId: variantRootValueId(context, variantId, global, className)
+    };
+  });
+  return { variants, variantFolders: folders };
+}
+function variantValueBindingsV4(manifest, analysis) {
+  if (manifest.variants.length === 0) return [];
+  const variantsById = new Map(
+    manifest.variants.map((variant) => [variant.id, variant])
+  );
+  const classNames = new Map(
+    manifest.classes.map((entry) => [entry.id, entry.name])
+  );
+  return variantGlobals(analysis).flatMap((global) => {
+    const variant = variantsById.get(
+      variantRecordId(global, NEO_VARIANT_TYPE_NAME)
+    );
+    if (variant === void 0) return [];
+    return [
+      {
+        variantId: variant.id,
+        targetClassId: variant.classId,
+        targetClassName: requiredClassName2(classNames, variant.classId),
+        variantTypeName: global.type.name,
+        valueClassId: global.type.name === NEO_LOOKUP_VARIANT_TYPE_NAME ? requiredName2(
+          new Map(
+            manifest.classes.map((entry) => [entry.name, entry.id])
+          ),
+          valueClassName(global),
+          "class"
+        ) : null,
+        valueId: variant.valueId,
+        initializer: global.initializer,
+        source: global.source,
+        label: `${requiredClassName2(classNames, variant.classId)}.${NEO_VARIANT_SCOPE_NAME}.${variant.name}`
+      }
+    ];
+  });
+}
+function requiredClassName2(classNames, classId) {
+  const name = classNames.get(classId);
+  if (name === void 0) {
+    throw new Error(
+      `Variant targets class ${JSON.stringify(classId)}, which this push does not declare.`
+    );
+  }
+  return name;
+}
+function variantGlobals(analysis) {
+  return analysis.variants.globals.filter(
+    (global) => isNeoVariantTypeName(global.type.name)
+  );
+}
+function lowerVariantFolders(context, analysis) {
+  return analysis.variants.globals.filter((global) => isNeoVariantFolderTypeName(global.type.name)).map((global) => {
+    const className = owningClassName(global);
+    return {
+      id: variantRecordId(global, NEO_VARIANT_FOLDER_TYPE_NAME),
+      source: sourceIdentity2(global, "variantFolder", global.name),
+      classId: requiredName2(context.classIdsByName, className, "class"),
+      path: folderPath2(global),
+      binding: folderBinding(context, global)
+    };
+  });
+}
+function owningClassName(global) {
+  const argument2 = global.type.arguments[0]?.name;
+  if (argument2 === void 0) {
+    throw new Error(
+      `${global.type.name} ${global.name} must name the class it belongs to as its single type argument.`
+    );
+  }
+  return argument2;
+}
+function variantRecordId(global, typeName) {
+  const kind = isNeoVariantTypeName(typeName) ? "variant" : "variant-folder";
+  return materializedIdentityId(global, kind, global.name);
+}
+function variantRootValueId(context, variantId, global, className) {
+  const stored = storedVariantValueId(context, variantId);
+  if (stored !== null) return stored;
+  return `__pending__:value:${encodeURIComponent(global.source.uri)}:${global.source.range.start.line}:${global.source.range.start.character}:${encodeURIComponent(`${className}.${NEO_VARIANT_SCOPE_NAME}.${global.name}`)}`;
+}
+function storedVariantValueId(context, variantId) {
+  const stored = context.base.variants.find(
+    (variant) => variant.id === variantId
+  );
+  return stored?.valueId ?? null;
+}
+function variantFolderId2(global, className, foldersBySymbol) {
+  const symbol = neoVariantFolderAnnotationSymbol(
+    annotationsForFolderLookup(global.annotations)
+  );
+  if (symbol === null) return null;
+  const folderId = foldersBySymbol.get(folderSymbolKey(className, symbol));
+  if (folderId === void 0) {
+    throw new Error(
+      `Variant ${className}.${NEO_VARIANT_SCOPE_NAME}.${global.name} names folder ${JSON.stringify(symbol)}, which no NeoVariantFolder<${className}> declares.`
+    );
+  }
+  return folderId;
+}
+function annotationsForFolderLookup(annotations) {
+  return annotations.map((annotation2) => ({
+    name: annotation2.name,
+    arguments: annotation2.arguments.map((argument2) => ({
+      ...argument2.name === void 0 ? {} : { name: argument2.name },
+      text: argument2.expression
+    }))
+  }));
+}
+function folderSymbolKey(className, symbol) {
+  return `${className} ${symbol}`;
+}
+function folderPath2(global) {
+  const expression = unwrapAnnotated2(parseExpression(global.initializer));
+  if (expression.kind !== "new") {
+    throw new Error(
+      `Variant folder ${global.name} must be declared as new("Path").`
+    );
+  }
+  const pathIndex = expression.argumentNames?.findIndex(
+    (name) => name === "path"
+  );
+  const argument2 = expression.args[pathIndex !== void 0 && pathIndex >= 0 ? pathIndex : 0];
+  if (argument2 === void 0 || argument2.kind !== "litString") {
+    throw new Error(
+      `Variant folder ${global.name} requires one string-literal path argument.`
+    );
+  }
+  if (argument2.value.length === 0 && global.type.name !== NEO_LOOKUP_VARIANT_FOLDER_TYPE_NAME) {
+    throw new Error(
+      `Only a bound lookup variant folder may have an empty path.`
+    );
+  }
+  return argument2.value;
+}
+function unwrapAnnotated2(expression) {
+  let current = expression;
+  while (current.kind === "annotated") current = current.expression;
+  return current;
+}
+function buildVariantPathIndexV4(classIdsByName, analysis) {
+  const index = /* @__PURE__ */ new Map();
+  const foldersBySymbol = new Map(
+    analysis.variants.globals.filter((global) => isNeoVariantFolderTypeName(global.type.name)).map(
+      (global) => [
+        folderSymbolKey(owningClassName(global), global.name),
+        folderPath2(global)
+      ]
+    )
+  );
+  for (const [className, classId] of classIdsByName) {
+    index.set(
+      `${className}.${NEO_VARIANT_SCOPE_NAME}.${NEO_VARIANT_RESERVED_NAME}`,
+      {
+        classId,
+        variantId: null,
+        valueClassId: null
+      }
+    );
+  }
+  for (const global of variantGlobals(analysis)) {
+    const className = owningClassName(global);
+    const classId = classIdsByName.get(className);
+    if (classId === void 0) continue;
+    const symbol = neoVariantFolderAnnotationSymbol(
+      annotationsForFolderLookup(global.annotations)
+    );
+    const path = symbol === null ? null : foldersBySymbol.get(folderSymbolKey(className, symbol)) ?? null;
+    const scope = path === null || path === "" ? `${className}.${NEO_VARIANT_SCOPE_NAME}` : `${className}.${NEO_VARIANT_SCOPE_NAME}.${path.split(NEO_VARIANT_FOLDER_PATH_SEPARATOR).join(".")}`;
+    index.set(`${scope}.${global.name}`, {
+      classId,
+      variantId: variantRecordId(global, global.type.name),
+      valueClassId: global.type.name === NEO_LOOKUP_VARIANT_TYPE_NAME ? classIdsByName.get(valueClassName(global)) ?? null : null
+    });
+  }
+  return index;
+}
+function valueClassName(global) {
+  const argument2 = global.type.arguments[1]?.name;
+  if (argument2 === void 0) {
+    throw new Error(
+      `${global.type.name} ${global.name} requires a TValue type argument.`
+    );
+  }
+  return argument2;
+}
+function folderBinding(context, global) {
+  if (global.type.name !== NEO_LOOKUP_VARIANT_FOLDER_TYPE_NAME) return null;
+  const expression = unwrapAnnotated2(parseExpression(global.initializer));
+  if (expression.kind !== "new") {
+    throw new Error(
+      `Lookup variant folder ${global.name} must be declared with new(...).`
+    );
+  }
+  const named = /* @__PURE__ */ new Map();
+  expression.args.forEach((argument2, index) => {
+    const name = expression.argumentNames?.[index];
+    if (name !== void 0 && name !== null) named.set(name, argument2);
+  });
+  const collection = named.get("collection");
+  const collectionValue = named.get("collectionValue");
+  const collectionPath = collection === void 0 ? null : dottedPath(collection);
+  if (collectionPath === null) {
+    throw new Error(
+      `Lookup variant folder ${global.name} requires collection: Class.Member.`
+    );
+  }
+  const collectionMemberId = resolveQualifiedMemberId(context, collectionPath);
+  if (collectionMemberId === null) {
+    throw new Error(
+      `Lookup variant folder ${global.name} names unknown collection ${collectionPath}.`
+    );
+  }
+  if (collectionValue === void 0) {
+    throw new Error(
+      `Lookup variant folder ${global.name} requires collectionValue: Reference(...).`
+    );
+  }
+  const collectionValueId = lowerReferenceValue(collectionValue);
+  if (collectionValueId === null) {
+    throw new Error(
+      `Lookup variant folder ${global.name} has an invalid collectionValue reference.`
+    );
+  }
+  return { collectionMemberId, collectionValueId };
+}
+function lowerReferenceValue(expression) {
+  if (expression.kind !== "call" || expression.callee.kind !== "ident" || expression.callee.name !== "Reference")
+    return null;
+  const idIndex = expression.argumentNames?.findIndex((name) => name === "id") ?? -1;
+  const target = expression.args[idIndex >= 0 ? idIndex : 0];
+  if (target?.kind === "litString") return target.value;
+  const path = target === void 0 ? null : dottedPath(target);
+  if (path === null || !path.startsWith("root.")) return null;
+  return referenceId(`Reference(${path})`);
+}
+function dottedPath(expression) {
+  const parts = [];
+  let cursor = expression;
+  while (cursor.kind === "member") {
+    parts.unshift(cursor.name);
+    cursor = cursor.receiver;
+  }
+  if (cursor.kind !== "ident") return null;
+  parts.unshift(cursor.name);
+  return parts.join(".");
+}
+var init_lower_variants = __esm({
+  "src/project-source/lower-variants.ts"() {
+    "use strict";
+    init_src();
+    init_lower_support();
+    init_lower_members();
+  }
+});
+
 // src/project-source/root-value-paths.ts
 function rootValuePathsByValueId(records2) {
   const indexed = indexRecords(records2);
@@ -72933,7 +73251,7 @@ async function fetchProjectDocumentPartitionRecords(runner, mapKey) {
   });
 }
 function readProjectDocumentManifestPage(value) {
-  if (!isObject3(value)) {
+  if (!isObject4(value)) {
     throw new Error("Convex project document manifest page must be an object.");
   }
   const continueCursor = value.continueCursor;
@@ -72943,7 +73261,7 @@ function readProjectDocumentManifestPage(value) {
     );
   }
   const metadata = value.metadata ?? null;
-  if (metadata !== null && !isObject3(metadata)) {
+  if (metadata !== null && !isObject4(metadata)) {
     throw new Error(
       "Convex project document manifest page metadata must be an object or null."
     );
@@ -72968,7 +73286,7 @@ function readProjectDocumentManifestRecords(value) {
     );
   }
   return value.map((record3, index) => {
-    if (!isObject3(record3)) {
+    if (!isObject4(record3)) {
       throw new Error(
         `Convex project document manifest record at index ${index} was not an object.`
       );
@@ -73002,7 +73320,7 @@ function readProjectDocumentManifestRecords(value) {
   });
 }
 function readProjectDocumentManifestPageRecords(value) {
-  if (!isObject3(value)) {
+  if (!isObject4(value)) {
     throw new Error("Convex project document manifest page must be an object.");
   }
   return readProjectDocumentManifestRecords(value.records);
@@ -73040,7 +73358,7 @@ async function fetchProjectDocumentSnapshots(fetchBatch, snapshotIds) {
   return snapshotsById;
 }
 function readProjectDocumentSnapshotBatch(value, requestedIds) {
-  if (!isObject3(value)) {
+  if (!isObject4(value)) {
     throw new Error("Convex project record snapshot batch must be an object.");
   }
   const snapshots = value.snapshots;
@@ -73060,7 +73378,7 @@ function readProjectDocumentSnapshotBatch(value, requestedIds) {
     );
   }
   return snapshots.map((snapshot, index) => {
-    if (!isObject3(snapshot)) {
+    if (!isObject4(snapshot)) {
       throw new Error(
         `Convex project record snapshot at index ${index} was not an object.`
       );
@@ -73242,7 +73560,7 @@ function appendBucketRecord(buckets, recordKind, data) {
   buckets[bucket].push(data);
 }
 function readProjectDocument(value, options = {}) {
-  if (!isObject3(value)) {
+  if (!isObject4(value)) {
     throw new Error("Convex project document query returned a non-object.");
   }
   const localizationConfig = options.localizationConfig === "nullable" ? readOptionalNullableField(
@@ -73332,7 +73650,7 @@ function readProjectDocument(value, options = {}) {
   };
 }
 function readProjectDocumentRevisionMarker(value) {
-  if (!isObject3(value)) return null;
+  if (!isObject4(value)) return null;
   if (!("documentRevision" in value)) return null;
   const marker = value.documentRevision;
   if (isProjectDocumentRevisionMarker(marker)) return marker;
@@ -73341,7 +73659,7 @@ function readProjectDocumentRevisionMarker(value) {
   );
 }
 function readProjectDocumentContentHashHeads(value) {
-  if (!isObject3(value)) {
+  if (!isObject4(value)) {
     throw new Error(
       "Convex project document content hash source must be an object."
     );
@@ -73349,7 +73667,7 @@ function readProjectDocumentContentHashHeads(value) {
   return readArrayField(value, "projectDocumentContentHashHeads", isHashHead);
 }
 function isHashHead(value) {
-  if (!isObject3(value)) return false;
+  if (!isObject4(value)) return false;
   if (!isProjectRecordKind(value.recordKind)) return false;
   if (typeof value.recordId !== "string") return false;
   if (typeof value.deleted !== "boolean") return false;
@@ -73385,12 +73703,12 @@ function readOptionalArrayField(source, key, isValid) {
   if (!Object.prototype.hasOwnProperty.call(source, key)) return [];
   return readArrayField(source, key, isValid);
 }
-function isObject3(value) {
+function isObject4(value) {
   if (typeof value !== "object") return false;
   return value !== null;
 }
 function describeInvalidReadItem(value) {
-  if (!isObject3(value)) {
+  if (!isObject4(value)) {
     return `received ${typeof value}`;
   }
   const parts = [];
@@ -75068,285 +75386,6 @@ var init_lower_relations = __esm({
   }
 });
 
-// src/project-source/lower-variants.ts
-function lowerVariants(context, analysis) {
-  const folders = lowerVariantFolders(context, analysis);
-  const foldersBySymbol = new Map(
-    analysis.variants.globals.filter((global) => isNeoVariantFolderTypeName(global.type.name)).map(
-      (global) => [
-        folderSymbolKey(owningClassName(global), global.name),
-        variantRecordId(global, global.type.name)
-      ]
-    )
-  );
-  const variants = variantGlobals(analysis).map((global) => {
-    const className = owningClassName(global);
-    const classId = requiredName2(context.classIdsByName, className, "class");
-    const variantId = variantRecordId(global, global.type.name);
-    return {
-      id: variantId,
-      source: sourceIdentity2(global, "variant", global.name),
-      classId,
-      name: global.name,
-      folderId: variantFolderId2(global, className, foldersBySymbol),
-      valueId: variantRootValueId(context, variantId, global, className)
-    };
-  });
-  return { variants, variantFolders: folders };
-}
-function variantValueBindingsV4(manifest, analysis) {
-  if (manifest.variants.length === 0) return [];
-  const variantsById = new Map(
-    manifest.variants.map((variant) => [variant.id, variant])
-  );
-  const classNames = new Map(
-    manifest.classes.map((entry) => [entry.id, entry.name])
-  );
-  return variantGlobals(analysis).flatMap((global) => {
-    const variant = variantsById.get(
-      variantRecordId(global, NEO_VARIANT_TYPE_NAME)
-    );
-    if (variant === void 0) return [];
-    return [
-      {
-        variantId: variant.id,
-        targetClassId: variant.classId,
-        targetClassName: requiredClassName2(classNames, variant.classId),
-        variantTypeName: global.type.name,
-        valueClassId: global.type.name === NEO_LOOKUP_VARIANT_TYPE_NAME ? requiredName2(
-          new Map(
-            manifest.classes.map((entry) => [entry.name, entry.id])
-          ),
-          valueClassName(global),
-          "class"
-        ) : null,
-        valueId: variant.valueId,
-        initializer: global.initializer,
-        source: global.source,
-        label: `${requiredClassName2(classNames, variant.classId)}.${NEO_VARIANT_SCOPE_NAME}.${variant.name}`
-      }
-    ];
-  });
-}
-function requiredClassName2(classNames, classId) {
-  const name = classNames.get(classId);
-  if (name === void 0) {
-    throw new Error(
-      `Variant targets class ${JSON.stringify(classId)}, which this push does not declare.`
-    );
-  }
-  return name;
-}
-function variantGlobals(analysis) {
-  return analysis.variants.globals.filter(
-    (global) => isNeoVariantTypeName(global.type.name)
-  );
-}
-function lowerVariantFolders(context, analysis) {
-  return analysis.variants.globals.filter((global) => isNeoVariantFolderTypeName(global.type.name)).map((global) => {
-    const className = owningClassName(global);
-    return {
-      id: variantRecordId(global, NEO_VARIANT_FOLDER_TYPE_NAME),
-      source: sourceIdentity2(global, "variantFolder", global.name),
-      classId: requiredName2(context.classIdsByName, className, "class"),
-      path: folderPath2(global),
-      binding: folderBinding(context, global)
-    };
-  });
-}
-function owningClassName(global) {
-  const argument2 = global.type.arguments[0]?.name;
-  if (argument2 === void 0) {
-    throw new Error(
-      `${global.type.name} ${global.name} must name the class it belongs to as its single type argument.`
-    );
-  }
-  return argument2;
-}
-function variantRecordId(global, typeName) {
-  const kind = isNeoVariantTypeName(typeName) ? "variant" : "variant-folder";
-  return materializedIdentityId(global, kind, global.name);
-}
-function variantRootValueId(context, variantId, global, className) {
-  const stored = storedVariantValueId(context, variantId);
-  if (stored !== null) return stored;
-  return `__pending__:value:${encodeURIComponent(global.source.uri)}:${global.source.range.start.line}:${global.source.range.start.character}:${encodeURIComponent(`${className}.${NEO_VARIANT_SCOPE_NAME}.${global.name}`)}`;
-}
-function storedVariantValueId(context, variantId) {
-  const stored = context.base.variants.find(
-    (variant) => variant.id === variantId
-  );
-  return stored?.valueId ?? null;
-}
-function variantFolderId2(global, className, foldersBySymbol) {
-  const symbol = neoVariantFolderAnnotationSymbol(
-    annotationsForFolderLookup(global.annotations)
-  );
-  if (symbol === null) return null;
-  const folderId = foldersBySymbol.get(folderSymbolKey(className, symbol));
-  if (folderId === void 0) {
-    throw new Error(
-      `Variant ${className}.${NEO_VARIANT_SCOPE_NAME}.${global.name} names folder ${JSON.stringify(symbol)}, which no NeoVariantFolder<${className}> declares.`
-    );
-  }
-  return folderId;
-}
-function annotationsForFolderLookup(annotations) {
-  return annotations.map((annotation2) => ({
-    name: annotation2.name,
-    arguments: annotation2.arguments.map((argument2) => ({
-      ...argument2.name === void 0 ? {} : { name: argument2.name },
-      text: argument2.expression
-    }))
-  }));
-}
-function folderSymbolKey(className, symbol) {
-  return `${className} ${symbol}`;
-}
-function folderPath2(global) {
-  const expression = unwrapAnnotated2(parseExpression(global.initializer));
-  if (expression.kind !== "new") {
-    throw new Error(
-      `Variant folder ${global.name} must be declared as new("Path").`
-    );
-  }
-  const pathIndex = expression.argumentNames?.findIndex(
-    (name) => name === "path"
-  );
-  const argument2 = expression.args[pathIndex !== void 0 && pathIndex >= 0 ? pathIndex : 0];
-  if (argument2 === void 0 || argument2.kind !== "litString") {
-    throw new Error(
-      `Variant folder ${global.name} requires one string-literal path argument.`
-    );
-  }
-  if (argument2.value.length === 0 && global.type.name !== NEO_LOOKUP_VARIANT_FOLDER_TYPE_NAME) {
-    throw new Error(
-      `Only a bound lookup variant folder may have an empty path.`
-    );
-  }
-  return argument2.value;
-}
-function unwrapAnnotated2(expression) {
-  let current = expression;
-  while (current.kind === "annotated") current = current.expression;
-  return current;
-}
-function buildVariantPathIndexV4(classIdsByName, analysis) {
-  const index = /* @__PURE__ */ new Map();
-  const foldersBySymbol = new Map(
-    analysis.variants.globals.filter((global) => isNeoVariantFolderTypeName(global.type.name)).map(
-      (global) => [
-        folderSymbolKey(owningClassName(global), global.name),
-        folderPath2(global)
-      ]
-    )
-  );
-  for (const [className, classId] of classIdsByName) {
-    index.set(
-      `${className}.${NEO_VARIANT_SCOPE_NAME}.${NEO_VARIANT_RESERVED_NAME}`,
-      {
-        classId,
-        variantId: null,
-        valueClassId: null
-      }
-    );
-  }
-  for (const global of variantGlobals(analysis)) {
-    const className = owningClassName(global);
-    const classId = classIdsByName.get(className);
-    if (classId === void 0) continue;
-    const symbol = neoVariantFolderAnnotationSymbol(
-      annotationsForFolderLookup(global.annotations)
-    );
-    const path = symbol === null ? null : foldersBySymbol.get(folderSymbolKey(className, symbol)) ?? null;
-    const scope = path === null ? `${className}.${NEO_VARIANT_SCOPE_NAME}` : `${className}.${NEO_VARIANT_SCOPE_NAME}.${path.split(NEO_VARIANT_FOLDER_PATH_SEPARATOR).join(".")}`;
-    index.set(`${scope}.${global.name}`, {
-      classId,
-      variantId: variantRecordId(global, global.type.name),
-      valueClassId: global.type.name === NEO_LOOKUP_VARIANT_TYPE_NAME ? classIdsByName.get(valueClassName(global)) ?? null : null
-    });
-  }
-  return index;
-}
-function valueClassName(global) {
-  const argument2 = global.type.arguments[1]?.name;
-  if (argument2 === void 0) {
-    throw new Error(
-      `${global.type.name} ${global.name} requires a TValue type argument.`
-    );
-  }
-  return argument2;
-}
-function folderBinding(context, global) {
-  if (global.type.name !== NEO_LOOKUP_VARIANT_FOLDER_TYPE_NAME) return null;
-  const expression = unwrapAnnotated2(parseExpression(global.initializer));
-  if (expression.kind !== "new") {
-    throw new Error(
-      `Lookup variant folder ${global.name} must be declared with new(...).`
-    );
-  }
-  const named = /* @__PURE__ */ new Map();
-  expression.args.forEach((argument2, index) => {
-    const name = expression.argumentNames?.[index];
-    if (name !== void 0 && name !== null) named.set(name, argument2);
-  });
-  const collection = named.get("collection");
-  const collectionValue = named.get("collectionValue");
-  const collectionPath = collection === void 0 ? null : dottedPath(collection);
-  if (collectionPath === null) {
-    throw new Error(
-      `Lookup variant folder ${global.name} requires collection: Class.Member.`
-    );
-  }
-  const collectionMemberId = resolveQualifiedMemberId(context, collectionPath);
-  if (collectionMemberId === null) {
-    throw new Error(
-      `Lookup variant folder ${global.name} names unknown collection ${collectionPath}.`
-    );
-  }
-  if (collectionValue === void 0) {
-    throw new Error(
-      `Lookup variant folder ${global.name} requires collectionValue: Reference(...).`
-    );
-  }
-  const collectionValueId = lowerReferenceValue(collectionValue);
-  if (collectionValueId === null) {
-    throw new Error(
-      `Lookup variant folder ${global.name} has an invalid collectionValue reference.`
-    );
-  }
-  return { collectionMemberId, collectionValueId };
-}
-function lowerReferenceValue(expression) {
-  if (expression.kind !== "call" || expression.callee.kind !== "ident" || expression.callee.name !== "Reference")
-    return null;
-  const idIndex = expression.argumentNames?.findIndex((name) => name === "id") ?? -1;
-  const target = expression.args[idIndex >= 0 ? idIndex : 0];
-  if (target?.kind === "litString") return target.value;
-  const path = target === void 0 ? null : dottedPath(target);
-  if (path === null || !path.startsWith("root.")) return null;
-  return referenceId(`Reference(${path})`);
-}
-function dottedPath(expression) {
-  const parts = [];
-  let cursor = expression;
-  while (cursor.kind === "member") {
-    parts.unshift(cursor.name);
-    cursor = cursor.receiver;
-  }
-  if (cursor.kind !== "ident") return null;
-  parts.unshift(cursor.name);
-  return parts.join(".");
-}
-var init_lower_variants = __esm({
-  "src/project-source/lower-variants.ts"() {
-    "use strict";
-    init_src();
-    init_lower_support();
-    init_lower_members();
-  }
-});
-
 // src/project-source/lower-schema.ts
 function lowerProjectSchemaV4(base, analysis, options = {}) {
   const classIdsByName = identityMap(analysis.schema.classes, "class");
@@ -95184,6 +95223,7 @@ function buildValueEmitContext(records2, manifest) {
     mainLocale: projectMainLocale(records2),
     symbolsByValueId,
     rootPathsByValueId: rootValuePathsByValueId(records2.values()),
+    variantPathsById: buildVariantPathsByIdV4(manifest),
     symbolsByDialogueId: new Map(
       [...dialogues].flatMap(
         ([id2, dialogue]) => typeof dialogue.sourceName === "string" ? [[id2, dialogue.sourceName]] : []
@@ -95635,6 +95675,12 @@ function buildValueLowerContext(state, manifest, options = {}) {
   const classesByName = new Map(
     manifest.classes.map((entry) => [entry.name, entry])
   );
+  const variantPathTargets = options.analysis === void 0 ? /* @__PURE__ */ new Map() : buildVariantPathIndexV4(
+    new Map(
+      manifest.classes.map((entry) => [entry.name, entry.id])
+    ),
+    options.analysis
+  );
   const sourceConstructorIndex = options.analysis === void 0 ? EMPTY_DECLARED_CONSTRUCTOR_INDEX : buildDeclaredConstructorIndex(options.analysis);
   const declaredConstructorIndex = withPersistedConstructorSignatures(
     sourceConstructorIndex,
@@ -95661,6 +95707,7 @@ function buildValueLowerContext(state, manifest, options = {}) {
     ),
     staticValueIdsBySymbol: staticTargets,
     rootValueTargetsByPath: rootValueTargetsByPath(Object.values(state)),
+    variantPathTargets,
     dialogueTargetsBySymbol: dialogueTargetsBySymbol(options.analysis),
     projectFileIdsBySymbol: projectFileIdsBySymbol(state, options.analysis),
     mainLocale: projectMainLocaleFromState(state),
@@ -97962,6 +98009,20 @@ function lowerValueBody(context, member, expression, base, source, environment,
         ...next,
         value: lowerActionValue(context, expression, source.ownerClassId)
       };
+    case "variant":
+      return {
+        ...next,
+        value: lowerVariantDefault(
+          context,
+          expression,
+          {
+            name: member.valueType === null ? NEO_VARIANT_TYPE_NAME : NEO_LOOKUP_VARIANT_TYPE_NAME,
+            nullable: !member.required,
+            arguments: []
+          },
+          `${source.label}.${member.name}`
+        )
+      };
     case "class":
       return lowerClassValue(
         context,
@@ -100054,6 +100115,17 @@ function emitValueBody(context, member, value, visited, targetTyped, environment
   if (kind === 24) return functionReferenceValue(context, body);
   if (kind === 25) return delegateValue(context, body);
   if (kind === 26) return actionValue(context, body);
+  if (kind === 27 /* Variant */) {
+    return renderVariantSelectionV4(
+      {
+        classes: context.manifestClasses,
+        variantPathsById: context.variantPathsById,
+        collectionValuePaths: context.rootPathsByValueId
+      },
+      String(member.name ?? member.id),
+      body
+    );
+  }
   if (kind === 12) {
     return fileValue(
       context,
@@ -100076,8 +100148,9 @@ function emitValueBody(context, member, value, visited, targetTyped, environment
       targetTyped,
       environment
     );
+  const kindName = MemberKind[kind];
   throw new Error(
-    `Stored member ${String(member.name ?? member.id)} has unsupported value kind ${kind}.`
+    typeof kindName === "string" ? `Stored member ${String(member.name ?? member.id)} uses unsupported ${kindName} value kind (${kind}).` : `Stored member ${String(member.name ?? member.id)} has unknown value kind ${kind}.`
   );
 }
 function classValue(context, member, value, visited, targetTyped, outerEnvironment) {
@@ -101629,6 +101702,7 @@ var init_value_sources = __esm({
     init_projection();
     init_project_file_source();
     init_lower_members();
+    init_lower_variants();
     init_key_reference_spelling();
     init_member_records();
     init_class_generics();
@@ -101645,6 +101719,7 @@ var init_value_sources = __esm({
     init_structured_leaf_source();
     init_member_kind_type_names();
     init_initializer_replay();
+    init_variant_selection_source();
     INFERRED_GENERIC_CLASS_PREFIX = "__inferred_class__:";
     MEMBER_KIND_DICTIONARY2 = 5;
     MEMBER_KIND_LIST2 = 6;
@@ -111474,7 +111549,7 @@ var init_registry2 = __esm({
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
       formatVersion: 3,
       contractVersion: "3.13",
-      cliVersion: "0.31.10",
+      cliVersion: "0.31.12",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -118069,7 +118144,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.10");
+    console.log("0.31.12");
     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.10",
+  "version": "0.31.12",
   "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.10 -->
+<!-- reviewed-through-cli: 0.31.12 -->
 
 # 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.10 -->
+<!-- reviewed-through-cli: 0.31.12 -->
 ```
 
 The quoted version above is checked too, so this instruction cannot go stale

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

@@ -56,6 +56,17 @@ or narrowing guard before the next access.
 
 Treat lookup-return values with the same nullable narrowing rules.
 
+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:
+
+```neo
+if (!(item is BedItem bedItem)) {
+  throw "Expected a bed item";
+}
+return bedItem.Name;
+```
+
 Use `SpriteInfo.Empty` when a required sprite should intentionally render no
 image. It is the canonical non-null empty sprite: it has no backing file and
 uses slice index zero.