@neocompose/cli 0.31.9 → 0.31.11

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## [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
+
+- Allow a normal pull to merge remote changes while local source contains new
+  members whose server-owned identity envelope has not been assigned yet.
+- Recompile locally edited constructors after pull merge instead of rejecting
+  stale server IR compiled for their previous parameter list.
+
 ## [0.31.9] - 2026-08-17
 
 ### Added

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 {
@@ -58785,6 +58808,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);
@@ -75068,285 +75370,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");
@@ -95005,10 +95028,40 @@ function readPulledProjectDocumentV4(records2) {
   const raw = structuredClone(
     pulledProjectDocumentRaw(replayWorkspace(records2))
   );
-  return readProjectDocument(completeProspectiveLocalizedTexts(raw), {
-    constructors: "authored-or-compiled",
-    identities: "prospective"
-  });
+  return readProjectDocument(
+    completeProspectiveMemberCreateEnvelopes(
+      completeProspectiveLocalizedTexts(raw)
+    ),
+    {
+      constructors: "authored-or-compiled",
+      identities: "prospective"
+    }
+  );
+}
+function completeProspectiveMemberCreateEnvelopes(raw) {
+  const members = raw.members;
+  if (!Array.isArray(members)) return raw;
+  if (!members.some(isPendingMemberWithoutCreateEnvelope)) return raw;
+  const project = raw.project;
+  if (!isObjectRecord2(project) || typeof project.id !== "string") {
+    throw new Error(
+      "Pending source-authored members need the server create envelope, but the project record has no id."
+    );
+  }
+  return {
+    ...raw,
+    members: members.map(
+      (member) => isPendingMemberWithoutCreateEnvelope(member) ? {
+        projectId: project.id,
+        createdAt: 0,
+        updatedAt: 0,
+        ...member
+      } : member
+    )
+  };
+}
+function isPendingMemberWithoutCreateEnvelope(value) {
+  return isObjectRecord2(value) && typeof value.id === "string" && value.id.startsWith("__pending__:") && (typeof value.projectId !== "string" || typeof value.createdAt !== "number" || typeof value.updatedAt !== "number");
 }
 function completeProspectiveLocalizedTexts(raw) {
   const localizedTexts = raw.localizedTexts;
@@ -95605,6 +95658,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,
@@ -95631,6 +95690,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),
@@ -97932,6 +97992,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,
@@ -101599,6 +101673,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();
@@ -104634,16 +104709,45 @@ function buildEmitRecordSet(document, plans, side) {
     if (data === void 0) continue;
     const serverRecord = document.records.get(key);
     const [recordKind, recordId] = key.split(/:(.+)/, 2);
+    const resolvedRecordKind = serverRecord?.recordKind ?? recordKind;
+    const resolvedRecordId = serverRecord?.recordId ?? recordId;
     records2.set(key, {
-      recordKind: serverRecord?.recordKind ?? recordKind,
-      recordId: serverRecord?.recordId ?? recordId,
+      recordKind: resolvedRecordKind,
+      recordId: resolvedRecordId,
       contentHash: plan.serverHash,
       deleted: false,
-      data
+      data: side === "emit" ? composeProspectivePullRecord(
+        resolvedRecordKind,
+        resolvedRecordId,
+        data,
+        serverRecord
+      ) : data
     });
   }
   return records2;
 }
+function composeProspectivePullRecord(recordKind, recordId, data, serverRecord) {
+  if (!isSchemaRecordKindV4(recordKind) || !isObjectRecord2(data)) return data;
+  let baseRecord = null;
+  if (serverRecord !== void 0) {
+    if (!isObjectRecord2(serverRecord.data)) {
+      throw new Error(
+        `Cannot compose pulled ${recordKind} record ${JSON.stringify(recordId)} because its server payload is not an object.`
+      );
+    }
+    baseRecord = {
+      recordKind,
+      recordId,
+      data: serverRecord.data
+    };
+  }
+  return composeDocumentRecord(
+    recordKind,
+    recordId,
+    partitionDocumentFields(recordKind, data).authored,
+    baseRecord
+  ).data;
+}
 var init_pull = __esm({
   "src/commands/pull.ts"() {
     "use strict";
@@ -111415,7 +111519,7 @@ var init_registry2 = __esm({
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
       formatVersion: 3,
       contractVersion: "3.13",
-      cliVersion: "0.31.9",
+      cliVersion: "0.31.11",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -118010,7 +118114,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.9");
+    console.log("0.31.11");
     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.9",
+  "version": "0.31.11",
   "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.9 -->
+<!-- reviewed-through-cli: 0.31.11 -->
 
 # 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.9 -->
+<!-- reviewed-through-cli: 0.31.11 -->
 ```
 
 The quoted version above is checked too, so this instruction cannot go stale